X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fprop%2Fbinding%2Fdeviceoptions.cpp;h=c995ea697c01e6980adaefd9c0efa0676b36d35d;hp=90f474f24935c04616a6871c1dec89df176d17b2;hb=7c65709437184b09753d1bcacc02467b8f6171f1;hpb=4d5d5d6aeb7d936fb6b939f6c6531b3f054dac1f diff --git a/pv/prop/binding/deviceoptions.cpp b/pv/prop/binding/deviceoptions.cpp index 90f474f2..c995ea69 100644 --- a/pv/prop/binding/deviceoptions.cpp +++ b/pv/prop/binding/deviceoptions.cpp @@ -18,211 +18,171 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include +#include #include -#include -#include +#include "deviceoptions.hpp" + +#include +#include +#include +#include -#include "deviceoptions.h" +#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 namespace boost; -using namespace std; +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) { - GVariant *gvar_opts, *gvar_list; - gsize num_opts; + assert(configurable); - if ((sr_config_list(sdi->driver, SR_CONF_DEVICE_OPTIONS, - &gvar_opts, sdi) != SR_OK)) - /* Driver supports no device instance options. */ - return; + for (auto entry : configurable->config_keys(ConfigKey::DEVICE_OPTIONS)) { + auto key = entry.first; + auto capabilities = entry.second; - const int *const options = (const int32_t *)g_variant_get_fixed_array( - gvar_opts, &num_opts, sizeof(int32_t)); - for (unsigned int i = 0; i < num_opts; i++) { - const struct sr_config_info *const info = - sr_config_info_get(options[i]); + Glib::VariantContainerBase gvar_list; - const int key = info->key; - - if (!info || sr_config_list(_sdi->driver, key, - &gvar_list, _sdi) != SR_OK) + if (!capabilities.count(Capability::GET) || + !capabilities.count(Capability::SET)) continue; - const QString name(info->name); + 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) + switch (key->id()) { case SR_CONF_SAMPLERATE: - bind_samplerate(name, gvar_list); + // Sample rate values are not bound because they are shown + // in the MainBar + break; + + case SR_CONF_CAPTURE_RATIO: + bind_int(name, "%", pair(0, 100), + get, set); break; 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: - bind_enum(name, key, gvar_list); + case SR_CONF_CLOCK_EDGE: + bind_enum(name, gvar_list, get, set); + break; + + case SR_CONF_EXTERNAL_CLOCK: + case SR_CONF_RLE: + bind_bool(name, get, set); break; case SR_CONF_TIMEBASE: - bind_enum(name, key, gvar_list, print_timebase); + bind_enum(name, gvar_list, get, set, print_timebase); break; case SR_CONF_VDIV: - bind_enum(name, key, gvar_list, print_vdiv); + bind_enum(name, gvar_list, get, set, print_vdiv); break; - } - g_variant_unref(gvar_list); - } - g_variant_unref(gvar_opts); -} + case SR_CONF_VOLTAGE_THRESHOLD: + bind_enum(name, gvar_list, get, set, print_voltage_threshold); + break; -GVariant* DeviceOptions::config_getter( - const struct sr_dev_inst *sdi, int key) -{ - GVariant *data = NULL; - if (sr_config_get(sdi->driver, key, &data, sdi) != SR_OK) { - qDebug() << - "WARNING: Failed to get value of config id" << key; - return NULL; + default: + break; + } } - return data; } -void DeviceOptions::config_setter( - const struct sr_dev_inst *sdi, int key, GVariant* value) +void DeviceOptions::bind_bool(const QString &name, + Property::Getter getter, Property::Setter setter) { - if (sr_config_set(sdi, key, value) != SR_OK) - qDebug() << "WARNING: Failed to set value of sample rate"; + assert(configurable_); + properties_.push_back(shared_ptr(new Bool( + name, getter, setter))); } -void DeviceOptions::bind_enum(const QString &name, int key, - GVariant *const gvar_list, function printer) +void DeviceOptions::bind_enum(const QString &name, + Glib::VariantContainerBase gvar_list, Property::Getter getter, + Property::Setter setter, function printer) { - GVariant *gvar; - GVariantIter iter; - vector< pair > values; + Glib::VariantBase gvar; + vector< pair > values; - g_variant_iter_init (&iter, gvar_list); - while ((gvar = g_variant_iter_next_value (&iter))) - values.push_back(make_pair(gvar, printer(gvar))); + assert(configurable_); - _properties.push_back(shared_ptr( - new Enum(name, values, - bind(config_getter, _sdi, key), - bind(config_setter, _sdi, key, _1)))); -} - -QString DeviceOptions::print_gvariant(GVariant *const gvar) -{ - QString s; - - if (g_variant_is_of_type(gvar, G_VARIANT_TYPE("s"))) - s = QString(g_variant_get_string(gvar, NULL)); - else - { - gchar *const text = g_variant_print(gvar, FALSE); - s = QString(text); - g_free(text); - } - - return s; -} - -void DeviceOptions::bind_samplerate(const QString &name, - GVariant *const gvar_list) -{ - GVariant *gvar_list_samplerates; - - if ((gvar_list_samplerates = g_variant_lookup_value(gvar_list, - "samplerate-steps", G_VARIANT_TYPE("at")))) - { - gsize num_elements; - const uint64_t *const elements = - (const uint64_t *)g_variant_get_fixed_array( - gvar_list_samplerates, &num_elements, sizeof(uint64_t)); - - assert(num_elements == 3); - - _properties.push_back(shared_ptr( - new Double(name, 0, QObject::tr("Hz"), - make_pair((double)elements[0], (double)elements[1]), - (double)elements[2], - bind(samplerate_double_getter, _sdi), - bind(samplerate_double_setter, _sdi, _1)))); - - g_variant_unref(gvar_list_samplerates); - } - else if ((gvar_list_samplerates = g_variant_lookup_value(gvar_list, - "samplerates", G_VARIANT_TYPE("at")))) - { - bind_enum(name, SR_CONF_SAMPLERATE, - gvar_list_samplerates, print_samplerate); - g_variant_unref(gvar_list_samplerates); - } -} + Glib::VariantIter iter(gvar_list); + while ((iter.next_value(gvar))) + values.push_back(make_pair(gvar, printer(gvar))); -QString DeviceOptions::print_samplerate(GVariant *const gvar) -{ - char *const s = sr_samplerate_string( - g_variant_get_uint64(gvar)); - const QString qstring(s); - g_free(s); - return qstring; + properties_.push_back(shared_ptr(new Enum(name, values, + getter, setter))); } -GVariant* DeviceOptions::samplerate_double_getter( - const struct sr_dev_inst *sdi) +void DeviceOptions::bind_int(const QString &name, QString suffix, + optional< std::pair > range, + Property::Getter getter, Property::Setter setter) { - GVariant *const gvar = config_getter(sdi, SR_CONF_SAMPLERATE); - - if(!gvar) - return NULL; - - GVariant *const gvar_double = g_variant_new_double( - g_variant_get_uint64(gvar)); + assert(configurable_); - g_variant_unref(gvar); - - return gvar_double; + properties_.push_back(shared_ptr(new Int(name, suffix, range, + getter, setter))); } -void DeviceOptions::samplerate_double_setter( - struct sr_dev_inst *sdi, GVariant *value) +QString DeviceOptions::print_timebase(Glib::VariantBase gvar) { - GVariant *const gvar = g_variant_new_uint64( - g_variant_get_double(value)); - config_setter(sdi, SR_CONF_SAMPLERATE, gvar); + uint64_t p, q; + g_variant_get(gvar.gobj(), "(tt)", &p, &q); + return QString::fromUtf8(sr_period_string(p * q)); } -QString DeviceOptions::print_timebase(GVariant *const gvar) +QString DeviceOptions::print_vdiv(Glib::VariantBase gvar) { uint64_t p, q; - g_variant_get(gvar, "(tt)", &p, &q); - return QString(sr_period_string(p * q)); + g_variant_get(gvar.gobj(), "(tt)", &p, &q); + return QString::fromUtf8(sr_voltage_string(p, q)); } -QString DeviceOptions::print_vdiv(GVariant *const gvar) +QString DeviceOptions::print_voltage_threshold(Glib::VariantBase gvar) { - uint64_t p, q; - g_variant_get(gvar, "(tt)", &p, &q); - return QString(sr_voltage_string(p, q)); + 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 -