using std::set;
using std::shared_ptr;
using std::string;
+using std::unordered_set;
using std::vector;
using sigrok::Analog;
// Ensure we are not capturing before setting the device
stop_capture();
- // Are we setting a session device?
- auto session_device = dynamic_pointer_cast<SessionDevice>(device);
- // Did we have a session device selected previously?
- auto prev_session_device = dynamic_pointer_cast<SessionDevice>(device_);
-
if (device_) {
session_->remove_datafeed_callbacks();
- if (!prev_session_device) {
+
+ // Did we have a hardware device selected previously?
+ if (!dynamic_pointer_cast<HardwareDevice>(device_)) {
device_->close();
session_->remove_devices();
}
}
- if (session_device)
- session_ = session_device->parent();
-
decode_traces_.clear();
if (device) {
- if (!session_device)
- {
+ // Are we setting a session device?
+ const auto session_device =
+ dynamic_pointer_cast<SessionDevice>(device);
+
+ if (session_device)
+ session_ = session_device->parent();
+ else {
session_ = device_manager_.context()->create_session();
try {
(shared_ptr<Device> device, shared_ptr<Packet> packet) {
data_feed_in(device, packet);
});
+ device_manager_.update_display_name(device);
update_signals(device);
} else
device_ = nullptr;
device_selected();
}
-void Session::set_file(const string &name)
+void Session::set_session_file(const string &name)
{
- session_ = device_manager_.context()->load_session(name);
- device_ = session_->devices()[0];
- decode_traces_.clear();
- session_->add_datafeed_callback([=]
- (shared_ptr<Device> device, shared_ptr<Packet> packet) {
- data_feed_in(device, packet);
- });
- device_manager_.update_display_name(device_);
- update_signals(device_);
- device_selected();
+ const shared_ptr<sigrok::Session> session =
+ device_manager_.context()->load_session(name);
+ set_device(session->devices()[0]);
}
void Session::set_default_device()
return signals_mutex_;
}
-const vector< shared_ptr<view::Signal> >& Session::signals() const
+const unordered_set< shared_ptr<view::Signal> >& Session::signals() const
{
return signals_;
}
assert(device);
assert(capture_state_ == Stopped);
- // Clear the decode traces
- decode_traces_.clear();
-
// Detect what data types we will receive
auto channels = device->channels();
unsigned int logic_channel_count = std::count_if(
{
lock_guard<mutex> data_lock(data_mutex_);
- logic_data_.reset();
- if (logic_channel_count != 0) {
+ if (logic_channel_count == 0) {
+ logic_data_.reset();
+ } else if (!logic_data_ ||
+ logic_data_->num_channels() != logic_channel_count) {
logic_data_.reset(new data::Logic(
logic_channel_count));
assert(logic_data_);
{
unique_lock<shared_mutex> lock(signals_mutex_);
+ unordered_set< shared_ptr<view::Signal> > prev_sigs(signals_);
signals_.clear();
for (auto channel : device->channels()) {
shared_ptr<view::Signal> signal;
- switch(channel->type()->id()) {
- case SR_CHANNEL_LOGIC:
- signal = shared_ptr<view::Signal>(
- new view::LogicSignal(*this, device,
- channel, logic_data_));
- break;
-
- case SR_CHANNEL_ANALOG:
- {
- shared_ptr<data::Analog> data(
- new data::Analog());
- signal = shared_ptr<view::Signal>(
- new view::AnalogSignal(
- *this, channel, data));
- break;
- }
-
- default:
- assert(0);
- break;
+ // Find the channel in the old signals
+ const auto iter = std::find_if(
+ prev_sigs.cbegin(), prev_sigs.cend(),
+ [&](const shared_ptr<view::Signal> &s) {
+ return s->channel() == channel;
+ });
+ if (iter != prev_sigs.end()) {
+ // Copy the signal from the old set to the new
+ signal = *iter;
+ auto logic_signal = dynamic_pointer_cast<
+ view::LogicSignal>(signal);
+ if (logic_signal)
+ logic_signal->set_logic_data(
+ logic_data_);
+ } else {
+ // Create a new signal
+ switch(channel->type()->id()) {
+ case SR_CHANNEL_LOGIC:
+ signal = shared_ptr<view::Signal>(
+ new view::LogicSignal(*this,
+ device, channel,
+ logic_data_));
+ break;
+
+ case SR_CHANNEL_ANALOG:
+ {
+ shared_ptr<data::Analog> data(
+ new data::Analog());
+ signal = shared_ptr<view::Signal>(
+ new view::AnalogSignal(
+ *this, channel, data));
+ break;
+ }
+
+ default:
+ assert(0);
+ break;
+ }
}
assert(signal);
- signals_.push_back(signal);
+ signals_.insert(signal);
}
-
}
signals_changed();