pv/popups/channels.cpp

   1 /*
   2  * This file is part of the PulseView project.
   3  *
   4  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <map>
  21
  22 #include <QApplication>
  23 #include <QCheckBox>
  24 #include <QFontMetrics>
  25 #include <QFormLayout>
  26 #include <QGridLayout>
  27 #include <QHBoxLayout>
  28 #include <QLabel>
  29
  30 #include "channels.hpp"
  31
  32 #include <pv/session.hpp>
  33 #include <pv/binding/device.hpp>
  34 #include <pv/data/logic.hpp>
  35 #include <pv/data/logicsegment.hpp>
  36 #include <pv/data/signalbase.hpp>
  37 #include <pv/devices/device.hpp>
  38
  39 using std::make_shared;
  40 using std::map;
  41 using std::out_of_range;
  42 using std::shared_ptr;
  43 using std::unordered_set;
  44 using std::vector;
  45 using std::weak_ptr;
  46
  47 using pv::data::SignalBase;
  48 using pv::data::Logic;
  49 using pv::data::LogicSegment;
  50
  51 using sigrok::Channel;
  52 using sigrok::ChannelGroup;
  53 using sigrok::Device;
  54
  55 namespace pv {
  56 namespace popups {
  57
  58 Channels::Channels(Session &session, QWidget *parent) :
  59         Popup(parent),
  60         session_(session),
  61         updating_channels_(false),
  62         enable_all_channels_(tr("All"), this),
  63         disable_all_channels_(tr("All"), this),
  64         enable_all_logic_channels_(tr("Logic"), this),
  65         disable_all_logic_channels_(tr("Logic"), this),
  66         enable_all_analog_channels_(tr("Analog"), this),
  67         disable_all_analog_channels_(tr("Analog"), this),
  68         enable_all_named_channels_(tr("Named"), this),
  69         disable_all_unnamed_channels_(tr("Unnamed"), this),
  70         enable_all_changing_channels_(tr("Changing"), this),
  71         disable_all_non_changing_channels_(tr("Non-changing"), this),
  72         check_box_mapper_(this)
  73 {
  74         // Create the layout
  75         setLayout(&layout_);
  76
  77         const shared_ptr<sigrok::Device> device = session_.device()->device();
  78         assert(device);
  79
  80         // Collect a set of signals
  81         map<shared_ptr<Channel>, shared_ptr<SignalBase> > signal_map;
  82
  83         unordered_set< shared_ptr<SignalBase> > sigs;
  84         for (const shared_ptr<data::SignalBase>& b : session_.signalbases())
  85                 sigs.insert(b);
  86
  87         for (const shared_ptr<SignalBase> &sig : sigs)
  88                 signal_map[sig->channel()] = sig;
  89
  90         // Populate channel groups
  91         for (auto& entry : device->channel_groups()) {
  92                 const shared_ptr<ChannelGroup> group = entry.second;
  93                 // Make a set of signals and remove these signals from the signal map
  94                 vector< shared_ptr<SignalBase> > group_sigs;
  95                 for (auto& channel : group->channels()) {
  96                         const auto iter = signal_map.find(channel);
  97
  98                         if (iter == signal_map.end())
  99                                 break;
 100
 101                         group_sigs.push_back((*iter).second);
 102                         signal_map.erase(iter);
 103                 }
 104
 105                 populate_group(group, group_sigs);
 106         }
 107
 108         // Make a vector of the remaining channels
 109         vector< shared_ptr<SignalBase> > global_analog_sigs, global_logic_sigs;
 110         for (auto& channel : device->channels()) {
 111                 const map<shared_ptr<Channel>, shared_ptr<SignalBase> >::
 112                         const_iterator iter = signal_map.find(channel);
 113
 114                 if (iter != signal_map.end()) {
 115                         const shared_ptr<SignalBase> signal = (*iter).second;
 116                         if (signal->type() == SignalBase::AnalogChannel)
 117                                 global_analog_sigs.push_back(signal);
 118                         else
 119                                 global_logic_sigs.push_back(signal);
 120                 }
 121         }
 122
 123         // Create the groups for the ungrouped channels
 124         populate_group(nullptr, global_logic_sigs);
 125         populate_group(nullptr, global_analog_sigs);
 126
 127         // Create the enable/disable all buttons
 128         connect(&enable_all_channels_, SIGNAL(clicked()), this, SLOT(enable_all_channels()));
 129         connect(&disable_all_channels_, SIGNAL(clicked()), this, SLOT(disable_all_channels()));
 130         connect(&enable_all_logic_channels_, SIGNAL(clicked()), this, SLOT(enable_all_logic_channels()));
 131         connect(&disable_all_logic_channels_, SIGNAL(clicked()), this, SLOT(disable_all_logic_channels()));
 132         connect(&enable_all_analog_channels_, SIGNAL(clicked()), this, SLOT(enable_all_analog_channels()));
 133         connect(&disable_all_analog_channels_, SIGNAL(clicked()), this, SLOT(disable_all_analog_channels()));
 134         connect(&enable_all_named_channels_, SIGNAL(clicked()), this, SLOT(enable_all_named_channels()));
 135         connect(&disable_all_unnamed_channels_, SIGNAL(clicked()), this, SLOT(disable_all_unnamed_channels()));
 136         connect(&enable_all_changing_channels_, SIGNAL(clicked()),
 137                 this, SLOT(enable_all_changing_channels()));
 138         connect(&disable_all_non_changing_channels_, SIGNAL(clicked()),
 139                 this, SLOT(disable_all_non_changing_channels()));
 140
 141         QLabel *label1 = new QLabel(tr("Disable: "));
 142         filter_buttons_bar_.addWidget(label1, 0, 0);
 143         filter_buttons_bar_.addWidget(&disable_all_channels_, 0, 1);
 144         filter_buttons_bar_.addWidget(&disable_all_logic_channels_, 0, 2);
 145         filter_buttons_bar_.addWidget(&disable_all_analog_channels_, 0, 3);
 146         filter_buttons_bar_.addWidget(&disable_all_unnamed_channels_, 0, 4);
 147         filter_buttons_bar_.addWidget(&disable_all_non_changing_channels_, 0, 5);
 148
 149         QLabel *label2 = new QLabel(tr("Enable: "));
 150         filter_buttons_bar_.addWidget(label2, 1, 0);
 151         filter_buttons_bar_.addWidget(&enable_all_channels_, 1, 1);
 152         filter_buttons_bar_.addWidget(&enable_all_logic_channels_, 1, 2);
 153         filter_buttons_bar_.addWidget(&enable_all_analog_channels_, 1, 3);
 154         filter_buttons_bar_.addWidget(&enable_all_named_channels_, 1, 4);
 155         filter_buttons_bar_.addWidget(&enable_all_changing_channels_, 1, 5);
 156
 157         layout_.addItem(new QSpacerItem(0, 15, QSizePolicy::Expanding, QSizePolicy::Expanding));
 158         layout_.addRow(&filter_buttons_bar_);
 159
 160         // Connect the check-box signal mapper
 161 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 162         connect(&check_box_mapper_, SIGNAL(mappedObject(QObject*)),
 163                 this, SLOT(on_channel_checked(QObject*)));
 164 #else
 165         connect(&check_box_mapper_, SIGNAL(mapped(QWidget*)),
 166                 this, SLOT(on_channel_checked(QWidget*)));
 167 #endif
 168 }
 169
 170 void Channels::set_all_channels(bool set)
 171 {
 172         updating_channels_ = true;
 173
 174         for (auto& entry : check_box_signal_map_) {
 175                 QCheckBox *cb = entry.first;
 176                 const shared_ptr<SignalBase> sig = entry.second;
 177                 assert(sig);
 178
 179                 sig->set_enabled(set);
 180                 cb->setChecked(set);
 181         }
 182
 183         updating_channels_ = false;
 184 }
 185
 186 void Channels::enable_channels_conditionally(
 187         function<bool (const shared_ptr<data::SignalBase>)> cond_func)
 188 {
 189         updating_channels_ = true;
 190
 191         for (auto& entry : check_box_signal_map_) {
 192                 QCheckBox *cb = entry.first;
 193                 const shared_ptr<SignalBase> sig = entry.second;
 194                 assert(sig);
 195
 196                 if (cond_func(sig)) {
 197                         sig->set_enabled(true);
 198                         cb->setChecked(true);
 199                 }
 200         }
 201
 202         updating_channels_ = false;
 203 }
 204
 205 void Channels::disable_channels_conditionally(
 206         function<bool (const shared_ptr<data::SignalBase>)> cond_func)
 207 {
 208         updating_channels_ = true;
 209
 210         for (auto& entry : check_box_signal_map_) {
 211                 QCheckBox *cb = entry.first;
 212                 const shared_ptr<SignalBase> sig = entry.second;
 213                 assert(sig);
 214
 215                 if (cond_func(sig)) {
 216                         sig->set_enabled(false);
 217                         cb->setChecked(false);
 218                 }
 219         }
 220
 221         updating_channels_ = false;
 222 }
 223
 224 void Channels::populate_group(shared_ptr<ChannelGroup> group,
 225         const vector< shared_ptr<SignalBase> > sigs)
 226 {
 227         using pv::binding::Device;
 228
 229         // Only bind options if this is a group. We don't do it for general
 230         // options, because these properties are shown in the device config
 231         // popup.
 232         shared_ptr<Device> binding;
 233         if (group)
 234                 binding = make_shared<Device>(group);
 235
 236         QHBoxLayout* group_layout = new QHBoxLayout();
 237         layout_.addRow(group_layout);
 238
 239         // Create a title if the group is going to have any content
 240         if ((!sigs.empty() || (binding && !binding->properties().empty())) && group)
 241         {
 242                 QLabel *label = new QLabel(
 243                         QString("<h3>%1</h3>").arg(group->name().c_str()));
 244                 group_layout->addWidget(label);
 245                 group_label_map_[group] = label;
 246         }
 247
 248         // Create the channel group grid
 249         int row = 0, col = 0;
 250         QGridLayout *const grid = new QGridLayout();
 251         vector<QCheckBox*> group_checkboxes, this_row;
 252
 253         for (const shared_ptr<SignalBase>& sig : sigs) {
 254                 assert(sig);
 255
 256                 QCheckBox *const checkbox = new QCheckBox(sig->display_name());
 257                 check_box_mapper_.setMapping(checkbox, checkbox);
 258                 connect(checkbox, SIGNAL(toggled(bool)), &check_box_mapper_, SLOT(map()));
 259
 260                 grid->addWidget(checkbox, row, col);
 261
 262                 group_checkboxes.push_back(checkbox);
 263                 this_row.push_back(checkbox);
 264
 265                 check_box_signal_map_[checkbox] = sig;
 266
 267                 weak_ptr<SignalBase> weak_sig(sig);
 268                 connect(checkbox, &QCheckBox::toggled,
 269                                 [weak_sig](bool state) {
 270                         auto sig = weak_sig.lock();
 271                         assert(sig);
 272                         sig->set_enabled(state);
 273                         });
 274
 275                 if ((++col >= 8 || &sig == &sigs.back())) {
 276                         // Show buttons if there's more than one row
 277                         if (sigs.size() > 8) {
 278                                 QPushButton *row_enable_button = new QPushButton(tr("All"), this);
 279                                 grid->addWidget(row_enable_button, row, 8);
 280                                 connect(row_enable_button, &QPushButton::clicked, row_enable_button,
 281                                         [this_row]() {
 282                                                 for (QCheckBox *box : this_row)
 283                                                         box->setChecked(true);
 284                                         });
 285
 286                                 QPushButton *row_disable_button = new QPushButton(tr("None"), this);
 287                                 connect(row_disable_button, &QPushButton::clicked, row_disable_button,
 288                                                 [this_row]() {
 289                                         for (QCheckBox *box : this_row)
 290                                                 box->setChecked(false);
 291                                         });
 292                                 grid->addWidget(row_disable_button, row, 9);
 293                         }
 294
 295                         this_row.clear();
 296                         col = 0, row++;
 297                 }
 298         }
 299         layout_.addRow(grid);
 300
 301         if (sigs.size() > 1) {
 302                 // Create enable all/none buttons
 303                 QPushButton *btn_enable_all, *btn_disable_all;
 304
 305                 btn_enable_all = new QPushButton(tr("All"));
 306                 btn_disable_all = new QPushButton(tr("None"));
 307                 group_layout->addWidget(btn_enable_all);
 308                 group_layout->addWidget(btn_disable_all);
 309
 310                 connect(btn_enable_all, &QPushButton::clicked, btn_enable_all,
 311                         [group_checkboxes](){
 312                                 for (QCheckBox *box: group_checkboxes)
 313                                         box->setChecked(true);
 314                         });
 315
 316                 connect(btn_disable_all, &QPushButton::clicked, btn_disable_all,
 317                         [group_checkboxes](){
 318                                 for (QCheckBox *box: group_checkboxes)
 319                                         box->setChecked(false);
 320                         });
 321         }
 322
 323         // Create the channel group options
 324         if (binding) {
 325                 binding->add_properties_to_form(&layout_, true);
 326                 group_bindings_.push_back(binding);
 327         }
 328 }
 329
 330 void Channels::showEvent(QShowEvent *event)
 331 {
 332         pv::widgets::Popup::showEvent(event);
 333
 334         const shared_ptr<sigrok::Device> device = session_.device()->device();
 335         assert(device);
 336
 337         // Update group labels
 338         for (auto& entry : device->channel_groups()) {
 339                 const shared_ptr<ChannelGroup> group = entry.second;
 340
 341                 if (group_label_map_.count(group) > 0) {
 342                         QLabel* label = group_label_map_[group];
 343                         label->setText(QString("<h3>%1</h3>").arg(group->name().c_str()));
 344                 }
 345         }
 346
 347         updating_channels_ = true;
 348
 349         for (auto& entry : check_box_signal_map_) {
 350                 QCheckBox *cb = entry.first;
 351                 const shared_ptr<SignalBase> sig = entry.second;
 352                 assert(sig);
 353
 354                 // Update the check box
 355                 cb->setChecked(sig->enabled());
 356                 cb->setText(sig->display_name());
 357         }
 358
 359         updating_channels_ = false;
 360 }
 361
 362 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 363 void Channels::on_channel_checked(QObject *widget)
 364 #else
 365 void Channels::on_channel_checked(QWidget *widget)
 366 #endif
 367 {
 368         if (updating_channels_)
 369                 return;
 370
 371         QCheckBox *const check_box = (QCheckBox*)widget;
 372         assert(check_box);
 373
 374         // Look up the signal of this check-box
 375         map< QCheckBox*, shared_ptr<SignalBase> >::const_iterator iter =
 376                 check_box_signal_map_.find((QCheckBox*)check_box);
 377         assert(iter != check_box_signal_map_.end());
 378
 379         const shared_ptr<SignalBase> s = (*iter).second;
 380         assert(s);
 381
 382         s->set_enabled(check_box->isChecked());
 383 }
 384
 385 void Channels::enable_all_channels()
 386 {
 387         set_all_channels(true);
 388 }
 389
 390 void Channels::disable_all_channels()
 391 {
 392         set_all_channels(false);
 393 }
 394
 395 void Channels::enable_all_logic_channels()
 396 {
 397         enable_channels_conditionally([](const shared_ptr<SignalBase> signal)
 398                 { return signal->type() == SignalBase::LogicChannel; });
 399 }
 400
 401 void Channels::disable_all_logic_channels()
 402 {
 403         disable_channels_conditionally([](const shared_ptr<SignalBase> signal)
 404                 { return signal->type() == SignalBase::LogicChannel; });
 405 }
 406
 407 void Channels::enable_all_analog_channels()
 408 {
 409         enable_channels_conditionally([](const shared_ptr<SignalBase> signal)
 410                 { return signal->type() == SignalBase::AnalogChannel; });
 411 }
 412
 413 void Channels::disable_all_analog_channels()
 414 {
 415         disable_channels_conditionally([](const shared_ptr<SignalBase> signal)
 416                 { return signal->type() == SignalBase::AnalogChannel; });
 417 }
 418
 419 void Channels::enable_all_named_channels()
 420 {
 421         enable_channels_conditionally([](const shared_ptr<SignalBase> signal)
 422                 { return signal->name() != signal->internal_name(); });
 423 }
 424
 425 void Channels::disable_all_unnamed_channels()
 426 {
 427         disable_channels_conditionally([](const shared_ptr<SignalBase> signal)
 428                 { return signal->name() == signal->internal_name(); });
 429 }
 430
 431 void Channels::enable_all_changing_channels()
 432 {
 433         enable_channels_conditionally([](const shared_ptr<SignalBase> signal)
 434                 {
 435                         // Never enable channels without sample data
 436                         if (!signal->has_samples())
 437                                 return false;
 438
 439                         // Non-logic channels are considered to always have a signal
 440                         if (signal->type() != SignalBase::LogicChannel)
 441                                 return true;
 442
 443                         const shared_ptr<Logic> logic = signal->logic_data();
 444                         assert(logic);
 445
 446                         // If any of the segments has edges, enable this channel
 447                         for (shared_ptr<LogicSegment> segment : logic->logic_segments()) {
 448                                 vector<LogicSegment::EdgePair> edges;
 449
 450                                 segment->get_subsampled_edges(edges,
 451                                         0, segment->get_sample_count() - 1,
 452                                         LogicSegment::MipMapScaleFactor,
 453                                         signal->index());
 454
 455                                 if (edges.size() > 2)
 456                                         return true;
 457                         }
 458
 459                         // No edges detected in any of the segments
 460                         return false;
 461                 });
 462 }
 463
 464 void Channels::disable_all_non_changing_channels()
 465 {
 466         disable_channels_conditionally([](const shared_ptr<SignalBase> signal)
 467                 {
 468                         // Always disable channels without sample data
 469                         if (!signal->has_samples())
 470                                 return true;
 471
 472                         // Non-logic channels are considered to always have a signal
 473                         if (signal->type() != SignalBase::LogicChannel)
 474                                 return false;
 475
 476                         const shared_ptr<Logic> logic = signal->logic_data();
 477                         assert(logic);
 478
 479                         // If any of the segments has edges, leave this channel enabled
 480                         for (shared_ptr<LogicSegment> segment : logic->logic_segments()) {
 481                                 vector<LogicSegment::EdgePair> edges;
 482
 483                                 segment->get_subsampled_edges(edges,
 484                                         0, segment->get_sample_count() - 1,
 485                                         LogicSegment::MipMapScaleFactor,
 486                                         signal->index());
 487
 488                                 if (edges.size() > 2)
 489                                         return false;
 490                         }
 491
 492                         // No edges detected in any of the segments
 493                         return true;
 494                 });
 495 }
 496
 497 }  // namespace popups
 498 }  // namespace pv