icons: Added trigger markers

[pulseview.git] / pv / sigsession.cpp

diff --git a/pv/sigsession.cpp b/pv/sigsession.cpp
index a2eba967a0793ede0c2d104d50ed4bad54ab6c2e..84c75896d42d01f60ee8e0cd1ef2e04b2d28d9f4 100644 (file)
--- a/pv/sigsession.cpp
+++ b/pv/sigsession.cpp
@@ -22,20 +22,20 @@
 #include <libsigrokdecode/libsigrokdecode.h>
 #endif
 
-#include "sigsession.h"
+#include "sigsession.hpp"
 
-#include "devicemanager.h"
+#include "devicemanager.hpp"
 
-#include "data/analog.h"
-#include "data/analogsnapshot.h"
-#include "data/decoderstack.h"
-#include "data/logic.h"
-#include "data/logicsnapshot.h"
-#include "data/decode/decoder.h"
+#include "data/analog.hpp"
+#include "data/analogsnapshot.hpp"
+#include "data/decoderstack.hpp"
+#include "data/logic.hpp"
+#include "data/logicsnapshot.hpp"
+#include "data/decode/decoder.hpp"
 
-#include "view/analogsignal.h"
-#include "view/decodetrace.h"
-#include "view/logicsignal.h"
+#include "view/analogsignal.hpp"
+#include "view/decodetrace.hpp"
+#include "view/logicsignal.hpp"
 
 #include <cassert>
 #include <mutex>
@@ -82,7 +82,7 @@ using Glib::VariantBase;
 using Glib::Variant;
 
 namespace pv {
-SigSession::SigSession(DeviceManager &device_manager) :
+Session::Session(DeviceManager &device_manager) :
        device_manager_(device_manager),
        session_(device_manager.context()->create_session()),
        capture_state_(Stopped)
@@ -90,33 +90,33 @@ SigSession::SigSession(DeviceManager &device_manager) :
        set_default_device();
 }
 
-SigSession::~SigSession()
+Session::~Session()
 {
        // Stop and join to the thread
        stop_capture();
 }
 
-DeviceManager& SigSession::device_manager()
+DeviceManager& Session::device_manager()
 {
        return device_manager_;
 }
 
-const DeviceManager& SigSession::device_manager() const
+const DeviceManager& Session::device_manager() const
 {
        return device_manager_;
 }
 
-const shared_ptr<sigrok::Session>& SigSession::session() const
+const shared_ptr<sigrok::Session>& Session::session() const
 {
        return session_;
 }
 
-shared_ptr<Device> SigSession::device() const
+shared_ptr<Device> Session::device() const
 {
        return device_;
 }
 
-void SigSession::set_device(shared_ptr<Device> device)
+void Session::set_device(shared_ptr<Device> device)
 {
        // Ensure we are not capturing before setting the device
        stop_capture();
@@ -137,25 +137,35 @@ void SigSession::set_device(shared_ptr<Device> device)
        if (session_device)
                session_ = session_device->parent();
 
-       device_ = device;
        decode_traces_.clear();
 
        if (device) {
                if (!session_device)
                {
                        session_ = device_manager_.context()->create_session();
-                       device->open();
+
+                       try {
+                               device->open();
+                       } catch(const sigrok::Error &e) {
+                               throw QString(e.what());
+                       }
+
                        session_->add_device(device);
                }
+
+               device_ = device;
                session_->add_datafeed_callback([=]
                        (shared_ptr<Device> device, shared_ptr<Packet> packet) {
                                data_feed_in(device, packet);
                        });
                update_signals(device);
-       }
+       } else
+               device_ = nullptr;
+
+       device_selected();
 }
 
-void SigSession::set_file(const string &name)
+void Session::set_file(const string &name)
 {
        session_ = device_manager_.context()->load_session(name);
        device_ = session_->devices()[0];
@@ -166,9 +176,10 @@ void SigSession::set_file(const string &name)
                });
        device_manager_.update_display_name(device_);
        update_signals(device_);
+       device_selected();
 }
 
-void SigSession::set_default_device()
+void Session::set_default_device()
 {
        shared_ptr<HardwareDevice> default_device;
        const list< shared_ptr<HardwareDevice> > &devices =
@@ -189,13 +200,13 @@ void SigSession::set_default_device()
        }
 }
 
-SigSession::capture_state SigSession::get_capture_state() const
+Session::capture_state Session::get_capture_state() const
 {
        lock_guard<mutex> lock(sampling_mutex_);
        return capture_state_;
 }
 
-void SigSession::start_capture(function<void (const QString)> error_handler)
+void Session::start_capture(function<void (const QString)> error_handler)
 {
        stop_capture();
 
@@ -217,11 +228,11 @@ void SigSession::start_capture(function<void (const QString)> error_handler)
 
        // Begin the session
        sampling_thread_ = std::thread(
-               &SigSession::sample_thread_proc, this, device_,
+               &Session::sample_thread_proc, this, device_,
                        error_handler);
 }
 
-void SigSession::stop_capture()
+void Session::stop_capture()
 {
        if (get_capture_state() != Stopped)
                session_->stop();
@@ -231,7 +242,7 @@ void SigSession::stop_capture()
                sampling_thread_.join();
 }
 
-set< shared_ptr<data::SignalData> > SigSession::get_data() const
+set< shared_ptr<data::SignalData> > Session::get_data() const
 {
        shared_lock<shared_mutex> lock(signals_mutex_);
        set< shared_ptr<data::SignalData> > data;
@@ -243,18 +254,18 @@ set< shared_ptr<data::SignalData> > SigSession::get_data() const
        return data;
 }
 
-boost::shared_mutex& SigSession::signals_mutex() const
+boost::shared_mutex& Session::signals_mutex() const
 {
        return signals_mutex_;
 }
 
-const vector< shared_ptr<view::Signal> >& SigSession::signals() const
+const vector< shared_ptr<view::Signal> >& Session::signals() const
 {
        return signals_;
 }
 
 #ifdef ENABLE_DECODE
-bool SigSession::add_decoder(srd_decoder *const dec)
+bool Session::add_decoder(srd_decoder *const dec)
 {
        map<const srd_channel*, shared_ptr<view::LogicSignal> > channels;
        shared_ptr<data::DecoderStack> decoder_stack;
@@ -310,13 +321,13 @@ bool SigSession::add_decoder(srd_decoder *const dec)
        return true;
 }
 
-vector< shared_ptr<view::DecodeTrace> > SigSession::get_decode_signals() const
+vector< shared_ptr<view::DecodeTrace> > Session::get_decode_signals() const
 {
        shared_lock<shared_mutex> lock(signals_mutex_);
        return decode_traces_;
 }
 
-void SigSession::remove_decode_signal(view::DecodeTrace *signal)
+void Session::remove_decode_signal(view::DecodeTrace *signal)
 {
        for (auto i = decode_traces_.begin(); i != decode_traces_.end(); i++)
                if ((*i).get() == signal)
@@ -328,7 +339,7 @@ void SigSession::remove_decode_signal(view::DecodeTrace *signal)
 }
 #endif
 
-void SigSession::set_capture_state(capture_state state)
+void Session::set_capture_state(capture_state state)
 {
        lock_guard<mutex> lock(sampling_mutex_);
        const bool changed = capture_state_ != state;
@@ -337,7 +348,7 @@ void SigSession::set_capture_state(capture_state state)
                capture_state_changed(state);
 }
 
-void SigSession::update_signals(shared_ptr<Device> device)
+void Session::update_signals(shared_ptr<Device> device)
 {
        assert(device);
        assert(capture_state_ == Stopped);
@@ -404,7 +415,7 @@ void SigSession::update_signals(shared_ptr<Device> device)
        signals_changed();
 }
 
-shared_ptr<view::Signal> SigSession::signal_from_channel(
+shared_ptr<view::Signal> Session::signal_from_channel(
        shared_ptr<Channel> channel) const
 {
        lock_guard<boost::shared_mutex> lock(signals_mutex_);
@@ -416,10 +427,14 @@ shared_ptr<view::Signal> SigSession::signal_from_channel(
        return shared_ptr<view::Signal>();
 }
 
-void SigSession::read_sample_rate(shared_ptr<Device> device)
+void Session::read_sample_rate(shared_ptr<Device> device)
 {
-       uint64_t sample_rate = VariantBase::cast_dynamic<Variant<guint64>>(
-               device->config_get(ConfigKey::SAMPLERATE)).get();
+       const auto keys = device_->config_keys(ConfigKey::DEVICE_OPTIONS);
+       const auto iter = keys.find(ConfigKey::SAMPLERATE);
+       const uint64_t sample_rate = (iter != keys.end() &&
+               (*iter).second.find(sigrok::GET) != (*iter).second.end()) ?
+               VariantBase::cast_dynamic<Variant<guint64>>(
+                       device->config_get(ConfigKey::SAMPLERATE)).get() : 0;
 
        // Set the sample rate of all data
        const set< shared_ptr<data::SignalData> > data_set = get_data();
@@ -429,7 +444,7 @@ void SigSession::read_sample_rate(shared_ptr<Device> device)
        }
 }
 
-void SigSession::sample_thread_proc(shared_ptr<Device> device,
+void Session::sample_thread_proc(shared_ptr<Device> device,
        function<void (const QString)> error_handler)
 {
        assert(device);
@@ -458,12 +473,12 @@ void SigSession::sample_thread_proc(shared_ptr<Device> device,
        }
 }
 
-void SigSession::feed_in_header(shared_ptr<Device> device)
+void Session::feed_in_header(shared_ptr<Device> device)
 {
        read_sample_rate(device);
 }
 
-void SigSession::feed_in_meta(shared_ptr<Device> device,
+void Session::feed_in_meta(shared_ptr<Device> device,
        shared_ptr<Meta> meta)
 {
        (void)device;
@@ -482,13 +497,13 @@ void SigSession::feed_in_meta(shared_ptr<Device> device,
        signals_changed();
 }
 
-void SigSession::feed_in_frame_begin()
+void Session::feed_in_frame_begin()
 {
        if (cur_logic_snapshot_ || !cur_analog_snapshots_.empty())
                frame_began();
 }
 
-void SigSession::feed_in_logic(shared_ptr<Logic> logic)
+void Session::feed_in_logic(shared_ptr<Logic> logic)
 {
        lock_guard<mutex> lock(data_mutex_);
 
@@ -504,13 +519,14 @@ void SigSession::feed_in_logic(shared_ptr<Logic> logic)
                set_capture_state(Running);
 
                // Get sample limit.
-               uint64_t sample_limit;
-               try {
-                       sample_limit = VariantBase::cast_dynamic<Variant<guint64>>(
-                               device_->config_get(ConfigKey::LIMIT_SAMPLES)).get();
-               } catch (Error) {
-                       sample_limit = 0;
-               }
+               const auto keys = device_->config_keys(
+                       ConfigKey::DEVICE_OPTIONS);
+               const auto iter = keys.find(ConfigKey::LIMIT_SAMPLES);
+               const uint64_t sample_limit = (iter != keys.end() &&
+                       (*iter).second.find(sigrok::GET) !=
+                       (*iter).second.end()) ?
+                       VariantBase::cast_dynamic<Variant<guint64>>(
+                       device_->config_get(ConfigKey::LIMIT_SAMPLES)).get() : 0;
 
                // Create a new data snapshot
                cur_logic_snapshot_ = shared_ptr<data::LogicSnapshot>(
@@ -532,7 +548,7 @@ void SigSession::feed_in_logic(shared_ptr<Logic> logic)
        data_received();
 }
 
-void SigSession::feed_in_analog(shared_ptr<Analog> analog)
+void Session::feed_in_analog(shared_ptr<Analog> analog)
 {
        lock_guard<mutex> lock(data_mutex_);
 
@@ -600,7 +616,7 @@ void SigSession::feed_in_analog(shared_ptr<Analog> analog)
        data_received();
 }
 
-void SigSession::data_feed_in(shared_ptr<Device> device, shared_ptr<Packet> packet)
+void Session::data_feed_in(shared_ptr<Device> device, shared_ptr<Packet> packet)
 {
        assert(device);
        assert(packet);