Paint decoder traces

diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp
index cea71bda9cdc6ea4ab42ef42f1ed423762357362..2ab730aa9a9a7261ab4cc7576452fcac69e50cc2 100644 (file)
--- a/pv/sigsession.cpp
+++ b/pv/sigsession.cpp
@@ -187,7 +187,7 @@ void SigSession::stop_capture()
        _sampling_thread.reset();
 }
 
-vector< shared_ptr<view::Signal> > SigSession::get_signals()
+vector< shared_ptr<view::Signal> > SigSession::get_signals() const
 {
        lock_guard<mutex> lock(_signals_mutex);
        return _signals;
@@ -213,6 +213,12 @@ void SigSession::add_decoder(srd_decoder *const dec,
        signals_changed();
 }
 
+vector< shared_ptr<view::DecodeSignal> > SigSession::get_decode_signals() const
+{
+       lock_guard<mutex> lock(_signals_mutex);
+       return _decode_traces;
+}
+
 void SigSession::set_capture_state(capture_state state)
 {
        lock_guard<mutex> lock(_sampling_mutex);

diff --git a/pv/sigsession.h b/pv/sigsession.h
index 4ce6131d4bd39f9a7daf09c43e3b2044aa290df9..2fb2a1c8af8e6ad109d1fd52d67ef51e2c36f85b 100644 (file)
--- a/pv/sigsession.h
+++ b/pv/sigsession.h
@@ -90,7 +90,7 @@ public:
        void stop_capture();
 
        std::vector< boost::shared_ptr<view::Signal> >
-               get_signals();
+               get_signals() const;
 
        boost::shared_ptr<data::Logic> get_data();
 
@@ -98,6 +98,9 @@ public:
                std::map<const srd_probe*,
                        boost::shared_ptr<view::Signal> > probes);
 
+       std::vector< boost::shared_ptr<view::DecodeSignal> >
+               get_decode_signals() const;
+
 private:
        void set_capture_state(capture_state state);
 

diff --git a/pv/view/header.cpp b/pv/view/header.cpp
index fd40e216e196f0bd6b7a2fb09c52bf70061edcf3..e14a9f246ecfb39e7d390e9d9f96be136cdf80e9 100644 (file)
--- a/pv/view/header.cpp
+++ b/pv/view/header.cpp
@@ -61,33 +61,30 @@ Header::Header(View &parent) :
                this, SLOT(on_signals_moved()));
 }
 
-boost::shared_ptr<pv::view::Signal> Header::get_mouse_over_signal(
-       const QPoint &pt)
+shared_ptr<Trace> Header::get_mouse_over_trace(const QPoint &pt)
 {
        const int w = width();
-       const vector< shared_ptr<Signal> > sigs(
-               _view.session().get_signals());
+       const vector< shared_ptr<Trace> > traces(_view.get_traces());
 
        const int v_offset = _view.v_offset();
-       BOOST_FOREACH(const shared_ptr<Signal> s, sigs)
+       BOOST_FOREACH(const shared_ptr<Trace> t, traces)
        {
-               assert(s);
+               assert(t);
 
-               if (s->pt_in_label_rect(s->get_v_offset() - v_offset,
+               if (t->pt_in_label_rect(t->get_v_offset() - v_offset,
                        0, w, pt))
-                       return s;
+                       return t;
        }
 
-       return shared_ptr<Signal>();
+       return shared_ptr<Trace>();
 }
 
 void Header::clear_selection()
 {
-       const vector< shared_ptr<Signal> > sigs(
-               _view.session().get_signals());
-       BOOST_FOREACH(const shared_ptr<Signal> s, sigs) {
-               assert(s);
-               s->select(false);
+       const vector< shared_ptr<Trace> > traces(_view.get_traces());
+       BOOST_FOREACH(const shared_ptr<Trace> t, traces) {
+               assert(t);
+               t->select(false);
        }
 
        update();
@@ -96,22 +93,21 @@ void Header::clear_selection()
 void Header::paintEvent(QPaintEvent*)
 {
        const int w = width();
-       const vector< shared_ptr<Signal> > sigs(
-               _view.session().get_signals());
+       const vector< shared_ptr<Trace> > traces(_view.get_traces());
 
        QPainter painter(this);
        painter.setRenderHint(QPainter::Antialiasing);
 
        const int v_offset = _view.v_offset();
-       const bool dragging = !_drag_sigs.empty();
-       BOOST_FOREACH(const shared_ptr<Signal> s, sigs)
+       const bool dragging = !_drag_traces.empty();
+       BOOST_FOREACH(const shared_ptr<Trace> t, traces)
        {
-               assert(s);
+               assert(t);
 
-               const int y = s->get_v_offset() - v_offset;
-               const bool highlight = !dragging && s->pt_in_label_rect(
+               const int y = t->get_v_offset() - v_offset;
+               const bool highlight = !dragging && t->pt_in_label_rect(
                        y, 0, w, _mouse_point);
-               s->paint_label(painter, y, w, highlight);
+               t->paint_label(painter, y, w, highlight);
        }
 
        painter.end();
@@ -121,46 +117,45 @@ void Header::mousePressEvent(QMouseEvent *event)
 {
        assert(event);
 
-       const vector< shared_ptr<Signal> > sigs(
-               _view.session().get_signals());
+       const vector< shared_ptr<Trace> > traces(_view.get_traces());
 
        if (event->button() & Qt::LeftButton) {
                _mouse_down_point = event->pos();
 
                // Save the offsets of any signals which will be dragged
-               BOOST_FOREACH(const shared_ptr<Signal> s, sigs)
-                       if (s->selected())
-                               _drag_sigs.push_back(
-                                       make_pair(s, s->get_v_offset()));
+               BOOST_FOREACH(const shared_ptr<Trace> t, traces)
+                       if (t->selected())
+                               _drag_traces.push_back(
+                                       make_pair(t, t->get_v_offset()));
        }
 
        // Select the signal if it has been clicked
-       const shared_ptr<Signal> mouse_over_signal =
-               get_mouse_over_signal(event->pos());
-       if (mouse_over_signal) {
-               if (mouse_over_signal->selected())
-                       mouse_over_signal->select(false);
+       const shared_ptr<Trace> mouse_over_trace =
+               get_mouse_over_trace(event->pos());
+       if (mouse_over_trace) {
+               if (mouse_over_trace->selected())
+                       mouse_over_trace->select(false);
                else {
-                       mouse_over_signal->select(true);
+                       mouse_over_trace->select(true);
 
                        if (~QApplication::keyboardModifiers() &
                                Qt::ControlModifier)
-                               _drag_sigs.clear();
+                               _drag_traces.clear();
 
                        // Add the signal to the drag list
                        if (event->button() & Qt::LeftButton)
-                               _drag_sigs.push_back(
-                                       make_pair(mouse_over_signal,
-                                       mouse_over_signal->get_v_offset()));
+                               _drag_traces.push_back(
+                                       make_pair(mouse_over_trace,
+                                       mouse_over_trace->get_v_offset()));
                }
        }
 
        if (~QApplication::keyboardModifiers() & Qt::ControlModifier) {
                // Unselect all other signals because the Ctrl is not
                // pressed
-               BOOST_FOREACH(const shared_ptr<Signal> s, sigs)
-                       if (s != mouse_over_signal)
-                               s->select(false);
+               BOOST_FOREACH(const shared_ptr<Trace> t, traces)
+                       if (t != mouse_over_trace)
+                               t->select(false);
        }
 
        selection_changed();
@@ -171,7 +166,7 @@ void Header::mouseReleaseEvent(QMouseEvent *event)
 {
        assert(event);
        if (event->button() == Qt::LeftButton) {
-               _drag_sigs.clear();
+               _drag_traces.clear();
                _view.normalize_layout();
        }
 }
@@ -182,23 +177,23 @@ void Header::mouseMoveEvent(QMouseEvent *event)
        _mouse_point = event->pos();
 
        // Move the signals if we are dragging
-       if (!_drag_sigs.empty()) {
+       if (!_drag_traces.empty()) {
                const int delta = event->pos().y() - _mouse_down_point.y();
 
-               for (std::list<std::pair<boost::weak_ptr<Signal>,
-                       int> >::iterator i = _drag_sigs.begin();
-                       i != _drag_sigs.end(); i++) {
-                       const boost::shared_ptr<Signal> sig((*i).first);
-                       if (sig) {
+               for (std::list<std::pair<boost::weak_ptr<Trace>,
+                       int> >::iterator i = _drag_traces.begin();
+                       i != _drag_traces.end(); i++) {
+                       const boost::shared_ptr<Trace> trace((*i).first);
+                       if (trace) {
                                const int y = (*i).second + delta;
                                const int y_snap =
                                        ((y + View::SignalSnapGridSize / 2) /
                                                View::SignalSnapGridSize) *
                                                View::SignalSnapGridSize;
-                               sig->set_v_offset(y_snap);
+                               trace->set_v_offset(y_snap);
 
-                               // Ensure the signal is selected
-                               sig->select();
+                               // Ensure the trace is selected
+                               trace->select();
                        }
                        
                }
@@ -217,54 +212,54 @@ void Header::leaveEvent(QEvent*)
 
 void Header::contextMenuEvent(QContextMenuEvent *event)
 {
-       const shared_ptr<Signal> s = get_mouse_over_signal(_mouse_point);
+       const shared_ptr<Trace> t = get_mouse_over_trace(_mouse_point);
 
-       if (!s)
+       if (!t)
                return;
 
        QMenu menu(this);
        menu.addAction(_action_set_name);
        menu.addAction(_action_set_colour);
 
-       _context_signal = s;
+       _context_trace = t;
        menu.exec(event->globalPos());
-       _context_signal.reset();
+       _context_trace.reset();
 }
 
 void Header::on_action_set_name_triggered()
 {
        bool ok = false;
 
-       shared_ptr<view::Signal> context_signal = _context_signal;
-       if (!context_signal)
+       shared_ptr<view::Trace> context_trace = _context_trace;
+       if (!context_trace)
                return;
 
        const QString new_label = QInputDialog::getText(this, tr("Set Name"),
-               tr("Name"), QLineEdit::Normal, context_signal->get_name(), &ok);
+               tr("Name"), QLineEdit::Normal, context_trace->get_name(), &ok);
 
        if (ok)
-               context_signal->set_name(new_label);
+               context_trace->set_name(new_label);
 }
 
 void Header::on_action_set_colour_triggered()
 {
-       shared_ptr<view::Signal> context_signal = _context_signal;
-       if (!context_signal)
+       shared_ptr<view::Trace> context_trace = _context_trace;
+       if (!context_trace)
                return;
 
        const QColor new_colour = QColorDialog::getColor(
-               context_signal->get_colour(), this, tr("Set Colour"));
+               context_trace->get_colour(), this, tr("Set Colour"));
 
        if (new_colour.isValid())
-               context_signal->set_colour(new_colour);
+               context_trace->set_colour(new_colour);
 }
 
 void Header::on_signals_changed()
 {
-       const vector< shared_ptr<Signal> > sigs(_view.session().get_signals());
-       BOOST_FOREACH(shared_ptr<Signal> s, sigs) {
-               assert(s);
-               connect(s.get(), SIGNAL(text_changed()), this, SLOT(update()));
+       const vector< shared_ptr<Trace> > traces(_view.get_traces());
+       BOOST_FOREACH(shared_ptr<Trace> t, traces) {
+               assert(t);
+               connect(t.get(), SIGNAL(text_changed()), this, SLOT(update()));
        }
 }
 

diff --git a/pv/view/header.h b/pv/view/header.h
index 22e8e4dbd2c3dbba58908d6a7a7a1208339bdfb0..7a180359539f7f6f9d03590b4042648804d0c72c 100644 (file)
--- a/pv/view/header.h
+++ b/pv/view/header.h
@@ -32,7 +32,7 @@
 namespace pv {
 namespace view {
 
-class Signal;
+class Trace;
 class View;
 
 class Header : public MarginWidget
@@ -43,7 +43,7 @@ public:
        Header(View &parent);
 
 private:
-       boost::shared_ptr<pv::view::Signal> get_mouse_over_signal(
+       boost::shared_ptr<pv::view::Trace> get_mouse_over_trace(
                const QPoint &pt);
 
        void clear_selection();
@@ -78,10 +78,10 @@ private:
        QPoint _mouse_point;
        QPoint _mouse_down_point;
 
-       std::list<std::pair<boost::weak_ptr<Signal>, int> >
-               _drag_sigs;
+       std::list<std::pair<boost::weak_ptr<Trace>, int> >
+               _drag_traces;
 
-       boost::shared_ptr<Signal> _context_signal;
+       boost::shared_ptr<Trace> _context_trace;
        QAction *_action_set_name;
        QAction *_action_set_colour;
 };

diff --git a/pv/view/view.cpp b/pv/view/view.cpp
index 3619ba0694d8f4bc48c5c8a97368e9f005192a9e..b4815e704ac6b002f21fc0eb42aa6850e33619cf 100644 (file)
--- a/pv/view/view.cpp
+++ b/pv/view/view.cpp
@@ -28,6 +28,7 @@
 #include <QMouseEvent>
 #include <QScrollBar>
 
+#include "decodesignal.h"
 #include "header.h"
 #include "ruler.h"
 #include "signal.h"
@@ -116,6 +117,11 @@ SigSession& View::session()
        return _session;
 }
 
+const SigSession& View::session() const
+{
+       return _session;
+}
+
 double View::scale() const
 {
        return _scale;
@@ -159,16 +165,33 @@ void View::set_scale_offset(double scale, double offset)
        _viewport->update();
 }
 
+vector< shared_ptr<Trace> > View::get_traces() const
+{
+       const vector< shared_ptr<Signal> > sigs(
+               session().get_signals());
+       const vector< shared_ptr<DecodeSignal> > decode_sigs(
+               session().get_decode_signals());
+       vector< shared_ptr<Trace> > traces(
+               sigs.size() + decode_sigs.size());
+
+       vector< shared_ptr<Trace> >::iterator i = traces.begin();
+       i = copy(sigs.begin(), sigs.end(), i);
+       i = copy(decode_sigs.begin(), decode_sigs.end(), i);
+
+       sort(traces.begin(), traces.end(), compare_trace_v_offsets);
+       return traces;
+}
+
 list<weak_ptr<SelectableItem> > View::selected_items() const
 {
        list<weak_ptr<SelectableItem> > items;
 
        // List the selected signals
-       const vector< shared_ptr<Signal> > sigs(_session.get_signals());
-       BOOST_FOREACH (shared_ptr<Signal> s, sigs) {
-               assert(s);
-               if (s->selected())
-                       items.push_back(s);
+       const vector< shared_ptr<Trace> > traces(get_traces());
+       BOOST_FOREACH (shared_ptr<Trace> t, traces) {
+               assert(t);
+               if (t->selected())
+                       items.push_back(t);
        }
 
        // List the selected cursors
@@ -218,15 +241,15 @@ const QPoint& View::hover_point() const
 
 void View::normalize_layout()
 {
-       const vector< shared_ptr<Signal> > sigs(_session.get_signals());
+       const vector< shared_ptr<Trace> > traces(get_traces());
 
        int v_min = INT_MAX;
-       BOOST_FOREACH(const shared_ptr<Signal> s, sigs)
-               v_min = min(s->get_v_offset(), v_min);
+       BOOST_FOREACH(const shared_ptr<Trace> t, traces)
+               v_min = min(t->get_v_offset(), v_min);
 
        const int delta = -min(v_min, 0);
-       BOOST_FOREACH(shared_ptr<Signal> s, sigs)
-               s->set_v_offset(s->get_v_offset() + delta);
+       BOOST_FOREACH(shared_ptr<Trace> t, traces)
+               t->set_v_offset(t->get_v_offset() + delta);
 
        verticalScrollBar()->setSliderPosition(_v_offset + delta);
        v_scroll_value_changed(verticalScrollBar()->sliderPosition());
@@ -275,6 +298,14 @@ void View::update_scroll()
                areaSize.height());
 }
 
+bool View::compare_trace_v_offsets(const shared_ptr<Trace> &a,
+       const shared_ptr<Trace> &b)
+{
+       assert(a);
+       assert(b);
+       return a->get_v_offset() < b->get_v_offset();
+}
+
 bool View::eventFilter(QObject *object, QEvent *event)
 {
        const QEvent::Type type = event->type();

diff --git a/pv/view/view.h b/pv/view/view.h
index f378e9116c24a6ccb0b3376cf2fe7d77ac18b7ba..dce8c252aff968f2c110eaa9e39de5eed16e7672 100644 (file)
--- a/pv/view/view.h
+++ b/pv/view/view.h
@@ -23,6 +23,9 @@
 
 #include <stdint.h>
 
+#include <vector>
+
+#include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 
 #include <QAbstractScrollArea>
@@ -38,6 +41,7 @@ namespace view {
 
 class Header;
 class Ruler;
+class Trace;
 class Viewport;
 
 class View : public QAbstractScrollArea {
@@ -65,6 +69,7 @@ public:
        explicit View(SigSession &session, QWidget *parent = 0);
 
        SigSession& session();
+       const SigSession& session() const;
 
        /**
         * Returns the view time scale in seconds per pixel.
@@ -88,6 +93,8 @@ public:
         */
        void set_scale_offset(double scale, double offset);
 
+       std::vector< boost::shared_ptr<Trace> > get_traces() const;
+
        std::list<boost::weak_ptr<SelectableItem> > selected_items() const;
 
        /**
@@ -131,6 +138,10 @@ private:
        
        void update_scroll();
 
+       static bool compare_trace_v_offsets(
+               const boost::shared_ptr<pv::view::Trace> &a,
+               const boost::shared_ptr<pv::view::Trace> &b);
+
 private:
        bool eventFilter(QObject *object, QEvent *event);
 

diff --git a/pv/view/viewport.cpp b/pv/view/viewport.cpp
index 7f2cedea0ccde0a1975c5a202e82a46fd62400b2..0e0ae8ae4ad0807f5b99abe1f31ca458f437af94 100644 (file)
--- a/pv/view/viewport.cpp
+++ b/pv/view/viewport.cpp
@@ -49,11 +49,10 @@ Viewport::Viewport(View &parent) :
 int Viewport::get_total_height() const
 {
        int h = 0;
-       const vector< shared_ptr<Signal> > sigs(
-               _view.session().get_signals());
-       BOOST_FOREACH(const shared_ptr<Signal> s, sigs) {
-               assert(s);
-               h = max(s->get_v_offset() + View::SignalHeight, h);
+       const vector< shared_ptr<Trace> > traces(_view.get_traces());
+       BOOST_FOREACH(const shared_ptr<Trace> t, traces) {
+               assert(t);
+               h = max(t->get_v_offset() + View::SignalHeight, h);
        }
 
        return h;
@@ -61,8 +60,7 @@ int Viewport::get_total_height() const
 
 void Viewport::paintEvent(QPaintEvent*)
 {
-       const vector< shared_ptr<Signal> > sigs(
-               _view.session().get_signals());
+       const vector< shared_ptr<Trace> > traces(_view.get_traces());
 
        QPainter p(this);
        p.setRenderHint(QPainter::Antialiasing);
@@ -72,10 +70,10 @@ void Viewport::paintEvent(QPaintEvent*)
 
        // Plot the signal
        const int v_offset = _view.v_offset();
-       BOOST_FOREACH(const shared_ptr<Signal> s, sigs)
+       BOOST_FOREACH(const shared_ptr<Trace> t, traces)
        {
-               assert(s);
-               s->paint(p, s->get_v_offset() - v_offset, 0, width(),
+               assert(t);
+               t->paint(p, t->get_v_offset() - v_offset, 0, width(),
                        _view.scale(), _view.offset());
        }