X-Git-Url: http://git.code-monkey.de/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fprop%2Fbinding%2Fdeviceoptions.cpp;h=8b38505c0bc15b24472366fd0d39c30fe7d19b3a;hp=b6f2f13605e54b15a34330637e0cf53cf82d44e7;hb=c1035a1452fa2aec5414975e83e531c10504b80c;hpb=3820592a018c777727a6e65bd754d113742f4462 diff --git a/pv/prop/binding/deviceoptions.cpp b/pv/prop/binding/deviceoptions.cpp index b6f2f13..8b38505 100644 --- a/pv/prop/binding/deviceoptions.cpp +++ b/pv/prop/binding/deviceoptions.cpp @@ -18,140 +18,171 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include +#include -#include "deviceoptions.h" +#include -#include +#include "deviceoptions.hpp" -using namespace boost; -using namespace std; +#include +#include +#include +#include + +#include + +using boost::optional; +using std::function; +using std::make_pair; +using std::pair; +using std::shared_ptr; +using std::string; +using std::vector; + +using sigrok::Capability; +using sigrok::Configurable; +using sigrok::ConfigKey; +using sigrok::Error; namespace pv { namespace prop { namespace binding { -DeviceOptions::DeviceOptions(struct sr_dev_inst *sdi) : - _sdi(sdi) +DeviceOptions::DeviceOptions(shared_ptr configurable) : + configurable_(configurable) { - const int *options; + assert(configurable); - if ((sr_config_list(sdi->driver, SR_CONF_DEVICE_OPTIONS, - (const void **)&options, sdi) != SR_OK) || !options) - /* Driver supports no device instance options. */ - return; + for (auto entry : configurable->config_keys(ConfigKey::DEVICE_OPTIONS)) { + auto key = entry.first; + auto capabilities = entry.second; - for (int cap = 0; options[cap]; cap++) { - const struct sr_config_info *const info = - sr_config_info_get(options[cap]); + Glib::VariantContainerBase gvar_list; - if (!info) + if (!capabilities.count(Capability::GET) || + !capabilities.count(Capability::SET)) continue; - switch(info->key) + if (capabilities.count(Capability::LIST)) + gvar_list = configurable->config_list(key); + + string name_str; + try { + name_str = key->description(); + } catch (Error e) { + name_str = key->name(); + } + + const QString name = QString::fromStdString(name_str); + + const Property::Getter get = [&, key]() { + return configurable_->config_get(key); }; + const Property::Setter set = [&, key](Glib::VariantBase value) { + configurable_->config_set(key, value); + config_changed(); + }; + + switch (key->id()) { - case SR_CONF_PATTERN_MODE: - bind_stropt(info, SR_CONF_PATTERN_MODE); + case SR_CONF_SAMPLERATE: + // Sample rate values are not bound because they are shown + // in the MainBar break; - case SR_CONF_BUFFERSIZE: - bind_buffer_size(info); + case SR_CONF_CAPTURE_RATIO: + bind_int(name, "%", pair(0, 100), + get, set); break; - case SR_CONF_TIMEBASE: - bind_time_base(info); + case SR_CONF_PATTERN_MODE: + case SR_CONF_BUFFERSIZE: + case SR_CONF_TRIGGER_SOURCE: + case SR_CONF_TRIGGER_SLOPE: + case SR_CONF_FILTER: + case SR_CONF_COUPLING: + case SR_CONF_CLOCK_EDGE: + bind_enum(name, gvar_list, get, set); break; - case SR_CONF_TRIGGER_SOURCE: - bind_stropt(info, SR_CONF_TRIGGER_SOURCE); + case SR_CONF_EXTERNAL_CLOCK: + case SR_CONF_RLE: + bind_bool(name, get, set); break; - case SR_CONF_FILTER: - bind_stropt(info, SR_CONF_FILTER); + case SR_CONF_TIMEBASE: + bind_enum(name, gvar_list, get, set, print_timebase); break; case SR_CONF_VDIV: - bind_vdiv(info); + bind_enum(name, gvar_list, get, set, print_vdiv); break; - case SR_CONF_COUPLING: - bind_stropt(info, SR_CONF_FILTER); + case SR_CONF_VOLTAGE_THRESHOLD: + bind_enum(name, gvar_list, get, set, print_voltage_threshold); + break; + + default: break; } } } -void DeviceOptions::expose_enum(const struct sr_config_info *info, - const vector< pair > &values, int key) +void DeviceOptions::bind_bool(const QString &name, + Property::Getter getter, Property::Setter setter) { - _properties.push_back(shared_ptr( - new Enum(QString(info->name), values, - function(), - bind(sr_config_set, _sdi, key, _1)))); + assert(configurable_); + properties_.push_back(shared_ptr(new Bool( + name, getter, setter))); } -void DeviceOptions::bind_stropt( - const struct sr_config_info *info, int key) +void DeviceOptions::bind_enum(const QString &name, + Glib::VariantContainerBase gvar_list, Property::Getter getter, + Property::Setter setter, function printer) { - const char **stropts; - if (sr_config_list(_sdi->driver, key, - (const void **)&stropts, _sdi) != SR_OK) - return; + Glib::VariantBase gvar; + vector< pair > values; + + assert(configurable_); - vector< pair > values; - for (int i = 0; stropts[i]; i++) - values.push_back(make_pair(stropts[i], stropts[i])); + Glib::VariantIter iter(gvar_list); + while ((iter.next_value(gvar))) + values.push_back(make_pair(gvar, printer(gvar))); - expose_enum(info, values, key); + properties_.push_back(shared_ptr(new Enum(name, values, + getter, setter))); } -void DeviceOptions::bind_buffer_size(const struct sr_config_info *info) +void DeviceOptions::bind_int(const QString &name, QString suffix, + optional< std::pair > range, + Property::Getter getter, Property::Setter setter) { - const uint64_t *sizes; - if (sr_config_list(_sdi->driver, SR_CONF_BUFFERSIZE, - (const void **)&sizes, _sdi) != SR_OK) - return; + assert(configurable_); - vector< pair > values; - for (int i = 0; sizes[i]; i++) - values.push_back(make_pair(sizes + i, - QString("%1").arg(sizes[i]))); - - expose_enum(info, values, SR_CONF_BUFFERSIZE); + properties_.push_back(shared_ptr(new Int(name, suffix, range, + getter, setter))); } -void DeviceOptions::bind_time_base(const struct sr_config_info *info) +QString DeviceOptions::print_timebase(Glib::VariantBase gvar) { - struct sr_rational *timebases; - if (sr_config_list(_sdi->driver, SR_CONF_TIMEBASE, - (const void **)&timebases, _sdi) != SR_OK) - return; - - vector< pair > values; - for (int i = 0; timebases[i].p && timebases[i].q; i++) - values.push_back(make_pair(timebases + i, - QString(sr_period_string( - timebases[i].p * timebases[i].q)))); - - expose_enum(info, values, SR_CONF_TIMEBASE); + uint64_t p, q; + g_variant_get(gvar.gobj(), "(tt)", &p, &q); + return QString::fromUtf8(sr_period_string(p * q)); } -void DeviceOptions::bind_vdiv(const struct sr_config_info *info) +QString DeviceOptions::print_vdiv(Glib::VariantBase gvar) { - struct sr_rational *vdivs; - if (sr_config_list(_sdi->driver, SR_CONF_VDIV, - (const void **)&vdivs, _sdi) != SR_OK) - return; - - vector< pair > values; - for (int i = 0; vdivs[i].p && vdivs[i].q; i++) - values.push_back(make_pair(vdivs + i, - QString(sr_voltage_string(vdivs + i)))); + uint64_t p, q; + g_variant_get(gvar.gobj(), "(tt)", &p, &q); + return QString::fromUtf8(sr_voltage_string(p, q)); +} - expose_enum(info, values, SR_CONF_VDIV); +QString DeviceOptions::print_voltage_threshold(Glib::VariantBase gvar) +{ + gdouble lo, hi; + g_variant_get(gvar.gobj(), "(dd)", &lo, &hi); + return QString("L<%1V H>%2V").arg(lo, 0, 'f', 1).arg(hi, 0, 'f', 1); } } // binding } // prop } // pv -