43 #include <libsigrokcxx/libsigrokcxx.hpp>
45 using std::back_inserter;
51 using std::shared_ptr;
55 using sigrok::Capability;
56 using sigrok::ConfigKey;
58 using sigrok::InputFormat;
68 QToolBar(
"Sampling Bar", &main_window),
70 main_window_(main_window),
71 device_selector_(this, session.device_manager(),
72 main_window.action_connect()),
73 configure_button_(this),
74 configure_button_action_(nullptr),
75 channels_button_(this),
76 channels_button_action_(nullptr),
77 sample_count_(
" samples", this),
78 sample_rate_(
"Hz", this),
79 updating_sample_rate_(false),
80 updating_sample_count_(false),
81 sample_count_supported_(false),
82 icon_red_(
":/icons/status-red.svg"),
83 icon_green_(
":/icons/status-green.svg"),
84 icon_grey_(
":/icons/status-grey.svg"),
85 run_stop_button_(this),
86 run_stop_button_action_(nullptr),
89 setObjectName(QString::fromUtf8(
"MainBar"));
93 setContextMenuPolicy(Qt::PreventContextMenu);
96 QToolButton *
const open_button =
new QToolButton(
this);
102 SIGNAL(format_selected(std::shared_ptr<sigrok::InputFormat>)),
104 SLOT(import_file(std::shared_ptr<sigrok::InputFormat>)));
106 open_button->setMenu(import_menu);
107 open_button->setDefaultAction(main_window.
action_open());
108 open_button->setPopupMode(QToolButton::MenuButtonPopup);
111 QToolButton *
const save_button =
new QToolButton(
this);
113 vector<QAction *> open_actions;
121 SIGNAL(format_selected(std::shared_ptr<sigrok::OutputFormat>)),
123 SLOT(export_file(std::shared_ptr<sigrok::OutputFormat>)));
125 save_button->setMenu(export_menu);
127 save_button->setPopupMode(QToolButton::MenuButtonPopup);
135 QToolButton *add_decoder_button =
new QToolButton(
this);
136 add_decoder_button->setIcon(QIcon::fromTheme(
"add-decoder",
137 QIcon(
":/icons/add-decoder.svg")));
138 add_decoder_button->setPopupMode(QToolButton::InstantPopup);
139 add_decoder_button->setMenu(
main_window_.menu_decoder_add());
143 QMenu *
const menu =
new QMenu(
this);
145 QMenu *
const menu_view =
new QMenu;
146 menu_view->setTitle(tr(
"&View"));
148 menu_view->addSeparator();
151 QMenu *
const menu_help =
new QMenu;
152 menu_help->setTitle(tr(
"&Help"));
155 menu->addAction(menu_view->menuAction());
156 menu->addSeparator();
157 menu->addAction(menu_help->menuAction());
158 menu->addSeparator();
164 QIcon(
":/icons/menu.svg")));
167 addWidget(open_button);
168 addWidget(save_button);
190 QIcon(
":/icons/configure.png")));
193 QIcon(
":/icons/channels.svg")));
205 addWidget(add_decoder_button);
208 QWidget *
const spacer =
new QWidget();
209 spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
222 list< shared_ptr<devices::Device> > devs;
224 copy(mgr.
devices().begin(), mgr.
devices().end(), back_inserter(devs));
226 if (std::find(devs.begin(), devs.end(), selected_device) == devs.end())
227 devs.push_back(selected_device);
239 tr(
"Run") : tr(
"Stop"));
253 Glib::VariantContainerBase gvar_dict;
255 const uint64_t *elements =
nullptr;
257 map< const ConfigKey*, std::set<Capability> > keys;
264 const shared_ptr<devices::Device> device =
272 const shared_ptr<sigrok::Device> sr_dev = device->device();
274 if (sr_dev->config_check(ConfigKey::SAMPLERATE, Capability::LIST)) {
275 gvar_dict = sr_dev->config_list(ConfigKey::SAMPLERATE);
282 if ((gvar_list = g_variant_lookup_value(gvar_dict.gobj(),
283 "samplerate-steps", G_VARIANT_TYPE(
"at")))) {
284 elements = (
const uint64_t *)g_variant_get_fixed_array(
285 gvar_list, &num_elements,
sizeof(uint64_t));
287 const uint64_t min = elements[0];
288 const uint64_t max = elements[1];
289 const uint64_t step = elements[2];
291 g_variant_unref(gvar_list);
307 }
else if ((gvar_list = g_variant_lookup_value(gvar_dict.gobj(),
308 "samplerates", G_VARIANT_TYPE(
"at")))) {
309 elements = (
const uint64_t *)g_variant_get_fixed_array(
310 gvar_list, &num_elements,
sizeof(uint64_t));
312 g_variant_unref(gvar_list);
324 const shared_ptr<devices::Device> device =
330 auto gvar = device->device()->config_get(ConfigKey::SAMPLERATE);
331 uint64_t samplerate =
332 Glib::VariantBase::cast_dynamic<Glib::Variant<guint64>>(gvar).
get();
337 }
catch (Error error) {
338 qDebug() <<
"WARNING: Failed to get value of sample rate";
348 const shared_ptr<devices::Device> device =
353 const shared_ptr<sigrok::Device> sr_dev = device->device();
365 uint64_t min_sample_count = 0;
368 if (sample_count == 0)
371 if (sr_dev->config_check(ConfigKey::LIMIT_SAMPLES, Capability::LIST)) {
372 auto gvar = sr_dev->config_list(ConfigKey::LIMIT_SAMPLES);
374 g_variant_get(gvar.gobj(),
"(tt)",
375 &min_sample_count, &max_sample_count);
382 min_sample_count, max_sample_count);
384 if (sr_dev->config_check(ConfigKey::LIMIT_SAMPLES, Capability::GET)) {
385 auto gvar = sr_dev->config_get(ConfigKey::LIMIT_SAMPLES);
386 sample_count = g_variant_get_uint64(gvar.gobj());
387 if (sample_count == 0)
402 const shared_ptr<devices::Device> device =
415 const shared_ptr<sigrok::Device> sr_dev = device->device();
432 if (sr_dev->config_check(ConfigKey::LIMIT_SAMPLES, Capability::SET))
435 if (sr_dev->config_check(ConfigKey::LIMIT_FRAMES, Capability::SET)) {
436 sr_dev->config_set(ConfigKey::LIMIT_FRAMES,
437 Glib::Variant<guint64>::create(1));
443 connect(&opts->
binding(), SIGNAL(config_changed()),
453 uint64_t sample_count = 0;
455 const shared_ptr<devices::Device> device =
460 const shared_ptr<sigrok::Device> sr_dev = device->device();
465 sr_dev->config_set(ConfigKey::LIMIT_SAMPLES,
466 Glib::Variant<guint64>::create(sample_count));
468 }
catch (Error error) {
469 qDebug() <<
"Failed to configure sample count.";
482 uint64_t sample_rate = 0;
484 const shared_ptr<devices::Device> device =
489 const shared_ptr<sigrok::Device> sr_dev = device->device();
492 if (sample_rate == 0)
496 sr_dev->config_set(ConfigKey::SAMPLERATE,
497 Glib::Variant<guint64>::create(sample_rate));
499 }
catch (Error error) {
500 qDebug() <<
"Failed to configure samplerate.";
550 (event->type() == QEvent::ToolTip)) {
552 QHelpEvent *help_event =
static_cast<QHelpEvent*
>(event);
554 QString str = tr(
"Total sampling time: %1").arg(
556 QToolTip::showText(help_event->globalPos(), str);
bool sample_count_supported_
QAction * action_view_zoom_one_to_one() const
static const uint64_t MinSampleCount
void commit_sample_count()
pv::widgets::SweepTimingWidget sample_rate_
bool updating_sample_rate_
bool updating_sample_count_
MainBar(Session &session, pv::MainWindow &main_window)
QString format_time_si(const Timestamp &v, SIPrefix prefix, unsigned int precision, QString unit, bool sign)
const std::shared_ptr< sigrok::Context > & context() const
void select_device(std::shared_ptr< devices::Device > device)
QAction * configure_button_action_
const std::vector< std::shared_ptr< prop::Property > > & properties()
QAction * action_view_show_cursors() const
const std::list< std::shared_ptr< devices::HardwareDevice > > & devices() const
QAction * action_view_zoom_in() const
QAction * action_view_zoom_fit() const
void on_device_selected()
pv::widgets::PopupToolButton channels_button_
void commit_sample_rate()
QAction * action_save_selection_as() const
pv::widgets::SweepTimingWidget sample_count_
std::shared_ptr< devices::Device > device() const
QAction * run_stop_button_action_
bool eventFilter(QObject *watched, QEvent *event)
DeviceManager & device_manager()
MainWindow & main_window_
void set_capture_state(pv::Session::capture_state state)
void update_sample_rate_selector_value()
void update_sample_count_selector()
QAction * channels_button_action_
QAction * action_view_zoom_out() const
void update_device_config_widgets()
QAction * action_about() const
QAction * action_view_sticky_scrolling() const
QAction * action_save_as() const
pv::widgets::DeviceToolButton device_selector_
void on_sample_count_changed()
QAction * action_quit() const
void on_sample_rate_changed()
QToolButton run_stop_button_
boost::multiprecision::number< boost::multiprecision::cpp_dec_float< 24 >, boost::multiprecision::et_off > Timestamp
Timestamp type providing yoctosecond resolution.
static const uint64_t MaxSampleCount
pv::widgets::PopupToolButton configure_button_
void update_sample_rate_selector()
void update_device_list()
QAction * action_view_coloured_bg() const
static const uint64_t DefaultSampleCount
QAction * action_open() const