X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fpopups%2Fchannels.cpp;h=10146741224651594086b8c514b892f2ce2c20b2;hp=f6b5aa14e99317cb6d08e35f70d265e4ea5a6927;hb=30677c1392b54604b01558cf29b44572731659fc;hpb=0a47889b01386b1e55c7df73ca301046a195ff97

diff --git a/pv/popups/channels.cpp b/pv/popups/channels.cpp
index f6b5aa14..10146741 100644
--- a/pv/popups/channels.cpp
+++ b/pv/popups/channels.cpp
@@ -14,8 +14,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <map>
@@ -25,60 +24,59 @@
 #include <QGridLayout>
 #include <QLabel>
 
-#include "channels.h"
+#include "channels.hpp"
 
-#include <pv/prop/binding/deviceoptions.h>
-#include <pv/sigsession.h>
-#include <pv/view/signal.h>
-
-#include <libsigrok/libsigrok.hpp>
-
-using namespace Qt;
+#include <pv/session.hpp>
+#include <pv/binding/device.hpp>
+#include <pv/data/signalbase.hpp>
+#include <pv/devices/device.hpp>
 
+using std::make_shared;
 using std::map;
-using std::set;
+using std::out_of_range;
 using std::shared_ptr;
+using std::unordered_set;
 using std::vector;
 
+using pv::data::SignalBase;
+
 using sigrok::Channel;
 using sigrok::ChannelGroup;
 using sigrok::Device;
 
-using pv::view::Signal;
-
 namespace pv {
 namespace popups {
 
-Channels::Channels(SigSession &session, QWidget *parent) :
+Channels::Channels(Session &session, QWidget *parent) :
 	Popup(parent),
-	_session(session),
-	_updating_channels(false),
-	_enable_all_channels(tr("Enable All"), this),
-	_disable_all_channels(tr("Disable All"), this),
-	_check_box_mapper(this)
+	session_(session),
+	updating_channels_(false),
+	enable_all_channels_(tr("Enable All"), this),
+	disable_all_channels_(tr("Disable All"), this),
+	check_box_mapper_(this)
 {
 	// Create the layout
-	setLayout(&_layout);
+	setLayout(&layout_);
 
-	shared_ptr<sigrok::Device> device = _session.device();
+	const shared_ptr<sigrok::Device> device = session_.device()->device();
 	assert(device);
 
 	// Collect a set of signals
-	map<shared_ptr<Channel>, shared_ptr<Signal> > signal_map;
-	const vector< shared_ptr<Signal> > sigs = _session.get_signals();
+	map<shared_ptr<Channel>, shared_ptr<SignalBase> > signal_map;
+
+	unordered_set< shared_ptr<SignalBase> > sigs;
+	for (const shared_ptr<data::SignalBase> b : session_.signalbases())
+		sigs.insert(b);
 
-	for (const shared_ptr<Signal> &sig : sigs)
+	for (const shared_ptr<SignalBase> &sig : sigs)
 		signal_map[sig->channel()] = sig;
 
 	// Populate channel groups
-	for (auto entry : device->channel_groups())
-	{
-		shared_ptr<ChannelGroup> group = entry.second;
-		// Make a set of signals, and removed this signals from the
-		// signal map.
-		vector< shared_ptr<Signal> > group_sigs;
-		for (auto channel : group->channels())
-		{
+	for (auto entry : device->channel_groups()) {
+		const shared_ptr<ChannelGroup> group = entry.second;
+		// Make a set of signals and remove these signals from the signal map
+		vector< shared_ptr<SignalBase> > group_sigs;
+		for (auto channel : group->channels()) {
 			const auto iter = signal_map.find(channel);
 
 			if (iter == signal_map.end())
@@ -92,149 +90,161 @@ Channels::Channels(SigSession &session, QWidget *parent) :
 	}
 
 	// Make a vector of the remaining channels
-	vector< shared_ptr<Signal> > global_sigs;
-	for (auto channel : device->channels())
-	{
-		const map<shared_ptr<Channel>, shared_ptr<Signal> >::
+	vector< shared_ptr<SignalBase> > global_sigs;
+	for (auto channel : device->channels()) {
+		const map<shared_ptr<Channel>, shared_ptr<SignalBase> >::
 			const_iterator iter = signal_map.find(channel);
 		if (iter != signal_map.end())
 			global_sigs.push_back((*iter).second);
 	}
 
 	// Create a group
-	populate_group(NULL, global_sigs);
+	populate_group(nullptr, global_sigs);
 
 	// Create the enable/disable all buttons
-	connect(&_enable_all_channels, SIGNAL(clicked()),
+	connect(&enable_all_channels_, SIGNAL(clicked()),
 		this, SLOT(enable_all_channels()));
-	connect(&_disable_all_channels, SIGNAL(clicked()),
+	connect(&disable_all_channels_, SIGNAL(clicked()),
 		this, SLOT(disable_all_channels()));
 
-	_enable_all_channels.setFlat(true);
-	_disable_all_channels.setFlat(true);
+	enable_all_channels_.setFlat(true);
+	disable_all_channels_.setFlat(true);
 
-	_buttons_bar.addWidget(&_enable_all_channels);
-	_buttons_bar.addWidget(&_disable_all_channels);
-	_buttons_bar.addStretch(1);
+	buttons_bar_.addWidget(&enable_all_channels_);
+	buttons_bar_.addWidget(&disable_all_channels_);
+	buttons_bar_.addStretch(1);
 
-	_layout.addRow(&_buttons_bar);
+	layout_.addRow(&buttons_bar_);
 
 	// Connect the check-box signal mapper
-	connect(&_check_box_mapper, SIGNAL(mapped(QWidget*)),
+	connect(&check_box_mapper_, SIGNAL(mapped(QWidget*)),
 		this, SLOT(on_channel_checked(QWidget*)));
 }
 
 void Channels::set_all_channels(bool set)
 {
-	_updating_channels = true;
+	updating_channels_ = true;
 
-	for (map<QCheckBox*, shared_ptr<Signal> >::const_iterator i =
-		_check_box_signal_map.begin();
-		i != _check_box_signal_map.end(); i++)
-	{
-		const shared_ptr<Signal> sig = (*i).second;
+	for (auto entry : check_box_signal_map_) {
+		QCheckBox *cb = entry.first;
+		const shared_ptr<SignalBase> sig = entry.second;
 		assert(sig);
 
-		sig->enable(set);
-		(*i).first->setChecked(set);
+		sig->set_enabled(set);
+		cb->setChecked(set);
 	}
 
-	_updating_channels = false;
+	updating_channels_ = false;
 }
 
 void Channels::populate_group(shared_ptr<ChannelGroup> group,
-	const vector< shared_ptr<pv::view::Signal> > sigs)
+	const vector< shared_ptr<SignalBase> > sigs)
 {
-	using pv::prop::binding::DeviceOptions;
+	using pv::binding::Device;
 
 	// Only bind options if this is a group. We don't do it for general
 	// options, because these properties are shown in the device config
 	// popup.
-	shared_ptr<DeviceOptions> binding;
+	shared_ptr<Device> binding;
 	if (group)
-		binding = shared_ptr<DeviceOptions>(new DeviceOptions(group));
+		binding = make_shared<Device>(group);
 
 	// Create a title if the group is going to have any content
-	if ((!sigs.empty() || (binding && !binding->properties().empty())) &&
-		group)
-		_layout.addRow(new QLabel(
-			QString("<h3>%1</h3>").arg(group->name().c_str())));
+	if ((!sigs.empty() || (binding && !binding->properties().empty())) && group)
+	{
+		QLabel *label = new QLabel(
+			QString("<h3>%1</h3>").arg(group->name().c_str()));
+		layout_.addRow(label);
+		group_label_map_[group] = label;
+	}
 
 	// Create the channel group grid
-	QGridLayout *const channel_grid =
-		create_channel_group_grid(sigs);
-	_layout.addRow(channel_grid);
+	QGridLayout *const channel_grid = create_channel_group_grid(sigs);
+	layout_.addRow(channel_grid);
 
 	// Create the channel group options
-	if (binding)
-	{
-		binding->add_properties_to_form(&_layout, true);
-		_group_bindings.push_back(binding);
+	if (binding) {
+		binding->add_properties_to_form(&layout_, true);
+		group_bindings_.push_back(binding);
 	}
 }
 
 QGridLayout* Channels::create_channel_group_grid(
-	const vector< shared_ptr<pv::view::Signal> > sigs)
+	const vector< shared_ptr<SignalBase> > sigs)
 {
 	int row = 0, col = 0;
 	QGridLayout *const grid = new QGridLayout();
 
-	for (const shared_ptr<pv::view::Signal>& sig : sigs)
-	{
+	for (const shared_ptr<SignalBase>& sig : sigs) {
 		assert(sig);
 
-		QCheckBox *const checkbox = new QCheckBox(sig->name());
-		_check_box_mapper.setMapping(checkbox, checkbox);
+		QCheckBox *const checkbox = new QCheckBox(sig->display_name());
+		check_box_mapper_.setMapping(checkbox, checkbox);
 		connect(checkbox, SIGNAL(toggled(bool)),
-			&_check_box_mapper, SLOT(map()));
+			&check_box_mapper_, SLOT(map()));
 
 		grid->addWidget(checkbox, row, col);
 
-		_check_box_signal_map[checkbox] = sig;
+		check_box_signal_map_[checkbox] = sig;
 
-		if(++col >= 8)
+		if (++col >= 8)
 			col = 0, row++;
 	}
 
 	return grid;
 }
 
-void Channels::showEvent(QShowEvent *e)
+void Channels::showEvent(QShowEvent *event)
 {
-	pv::widgets::Popup::showEvent(e);
+	pv::widgets::Popup::showEvent(event);
 
-	_updating_channels = true;
+	const shared_ptr<sigrok::Device> device = session_.device()->device();
+	assert(device);
 
-	for (map<QCheckBox*, shared_ptr<Signal> >::const_iterator i =
-		_check_box_signal_map.begin();
-		i != _check_box_signal_map.end(); i++)
-	{
-		const shared_ptr<Signal> sig = (*i).second;
+	// Update group labels
+	for (auto entry : device->channel_groups()) {
+		const shared_ptr<ChannelGroup> group = entry.second;
+
+		try {
+			QLabel* label = group_label_map_.at(group);
+			label->setText(QString("<h3>%1</h3>").arg(group->name().c_str()));
+		} catch (out_of_range&) {
+			// Do nothing
+		}
+	}
+
+	updating_channels_ = true;
+
+	for (auto entry : check_box_signal_map_) {
+		QCheckBox *cb = entry.first;
+		const shared_ptr<SignalBase> sig = entry.second;
 		assert(sig);
 
-		(*i).first->setChecked(sig->enabled());
+		// Update the check box
+		cb->setChecked(sig->enabled());
+		cb->setText(sig->display_name());
 	}
 
-	_updating_channels = false;
+	updating_channels_ = false;
 }
 
 void Channels::on_channel_checked(QWidget *widget)
 {
-	if (_updating_channels)
+	if (updating_channels_)
 		return;
 
 	QCheckBox *const check_box = (QCheckBox*)widget;
 	assert(check_box);
 
 	// Look up the signal of this check-box
-	map< QCheckBox*, shared_ptr<Signal> >::const_iterator iter =
-		_check_box_signal_map.find((QCheckBox*)check_box);
-	assert(iter != _check_box_signal_map.end());
+	map< QCheckBox*, shared_ptr<SignalBase> >::const_iterator iter =
+		check_box_signal_map_.find((QCheckBox*)check_box);
+	assert(iter != check_box_signal_map_.end());
 
-	const shared_ptr<pv::view::Signal> s = (*iter).second;
+	const shared_ptr<SignalBase> s = (*iter).second;
 	assert(s);
 
-	s->enable(check_box->isChecked());
+	s->set_enabled(check_box->isChecked());
 }
 
 void Channels::enable_all_channels()
@@ -247,5 +257,5 @@ void Channels::disable_all_channels()
 	set_all_channels(false);
 }
 
-} // popups
-} // pv
+}  // namespace popups
+}  // namespace pv