static int config_set(uint32_t key, GVariant *data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
double dblval;
(void)cg;
switch (key) {
case SR_CONF_VOLTAGE_TARGET:
dblval = g_variant_get_double(data);
if ((dblval < 0.0) || (dblval > 35.0)) {
sr_err("Voltage out of range (0 - 35.0)!");
return SR_ERR_ARG;
}
return send_msg1(sdi, 'V', (int) (dblval * 10 + 0.5));
case SR_CONF_CURRENT_LIMIT:
dblval = g_variant_get_double(data);
if ((dblval < 0.00) || (dblval > 2.55)) {
sr_err("Current out of range (0 - 2.55)!");
return SR_ERR_ARG;
}
return send_msg1(sdi, 'C', (int) (dblval * 100 + 0.5));
case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
if (g_variant_get_boolean(data))
return send_msg1(sdi, 'V', 900);
else /* Constant current mode */
return send_msg1(sdi, 'V', 901);
default:
return SR_ERR_NA;
}
return SR_OK;
}
MMLocationGpsRaw *
mm_location_gps_raw_new_from_dictionary (GVariant *dictionary,
GError **error)
{
GError *inner_error = NULL;
MMLocationGpsRaw *self;
GVariantIter iter;
gchar *key;
GVariant *value;
self = mm_location_gps_raw_new ();
if (!dictionary)
return self;
if (!g_variant_is_of_type (dictionary, G_VARIANT_TYPE ("a{sv}"))) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_INVALID_ARGS,
"Cannot create GPS RAW location from dictionary: "
"invalid variant type received");
g_object_unref (self);
return NULL;
}
g_variant_iter_init (&iter, dictionary);
while (!inner_error &&
g_variant_iter_next (&iter, "{sv}", &key, &value)) {
if (g_str_equal (key, PROPERTY_UTC_TIME))
self->priv->utc_time = g_variant_dup_string (value, NULL);
else if (g_str_equal (key, PROPERTY_LONGITUDE))
self->priv->longitude = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_LATITUDE))
self->priv->latitude = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_ALTITUDE))
self->priv->altitude = g_variant_get_double (value);
g_free (key);
g_variant_unref (value);
}
/* If any of the mandatory parameters is missing, cleanup */
if (!self->priv->utc_time ||
self->priv->longitude == MM_LOCATION_LONGITUDE_UNKNOWN ||
self->priv->latitude == MM_LOCATION_LATITUDE_UNKNOWN) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_INVALID_ARGS,
"Cannot create GPS RAW location from dictionary: "
"mandatory parameters missing "
"(utc-time: %s, longitude: %s, latitude: %s)",
self->priv->utc_time ? "yes" : "missing",
(self->priv->longitude != MM_LOCATION_LONGITUDE_UNKNOWN) ? "yes" : "missing",
(self->priv->latitude != MM_LOCATION_LATITUDE_UNKNOWN) ? "yes" : "missing");
g_clear_object (&self);
}
return self;
}
static int config_set(uint32_t key, GVariant *data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
struct dev_context *devc;
gboolean bval;
gdouble dval;
(void)cg;
devc = sdi->priv;
switch (key) {
case SR_CONF_LIMIT_MSEC:
case SR_CONF_LIMIT_SAMPLES:
return sr_sw_limits_config_set(&devc->limits, key, data);
case SR_CONF_VOLTAGE_TARGET:
dval = g_variant_get_double(data);
if (dval < devc->model->voltage[0] || dval > devc->voltage_max_device)
return SR_ERR_ARG;
if ((hcs_send_cmd(sdi->conn, "VOLT%03.0f\r",
(dval / devc->model->voltage[2])) < 0) ||
(hcs_read_reply(sdi->conn, 1, devc->buf, sizeof(devc->buf)) < 0))
return SR_ERR;
devc->voltage_max = dval;
break;
case SR_CONF_CURRENT_LIMIT:
dval = g_variant_get_double(data);
if (dval < devc->model->current[0] || dval > devc->current_max_device)
return SR_ERR_ARG;
if ((hcs_send_cmd(sdi->conn, "CURR%03.0f\r",
(dval / devc->model->current[2])) < 0) ||
(hcs_read_reply(sdi->conn, 1, devc->buf, sizeof(devc->buf)) < 0))
return SR_ERR;
devc->current_max = dval;
break;
case SR_CONF_ENABLED:
bval = g_variant_get_boolean(data);
if (hcs_send_cmd(sdi->conn, "SOUT%1d\r", !bval) < 0) {
sr_err("Could not send SR_CONF_ENABLED command.");
return SR_ERR;
}
if (hcs_read_reply(sdi->conn, 1, devc->buf, sizeof(devc->buf)) < 0) {
sr_err("Could not read SR_CONF_ENABLED reply.");
return SR_ERR;
}
devc->output_enabled = bval;
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
/* Handle position change callbacks */
static void
geoclue_client_signal_cb(GDBusProxy *client, gchar *sender_name,
gchar *signal_name, GVariant *parameters,
gpointer user_data)
{
location_geoclue2_state_t *state = user_data;
/* Only handle LocationUpdated signals */
if (g_strcmp0(signal_name, "LocationUpdated") != 0) {
return;
}
/* Obtain location path */
const gchar *location_path;
g_variant_get_child(parameters, 1, "&o", &location_path);
/* Obtain location */
GError *error = NULL;
GDBusProxy *location = g_dbus_proxy_new_sync(
g_dbus_proxy_get_connection(client),
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.GeoClue2",
location_path,
"org.freedesktop.GeoClue2.Location",
NULL, &error);
if (location == NULL) {
g_printerr(_("Unable to obtain location: %s.\n"),
error->message);
g_error_free(error);
mark_error(state);
return;
}
g_mutex_lock(&state->lock);
/* Read location properties */
GVariant *lat_v = g_dbus_proxy_get_cached_property(
location, "Latitude");
state->latitude = g_variant_get_double(lat_v);
GVariant *lon_v = g_dbus_proxy_get_cached_property(
location, "Longitude");
state->longitude = g_variant_get_double(lon_v);
state->available = 1;
g_mutex_unlock(&state->lock);
pipeutils_signal(state->pipe_fd_write);
}
void
cd_sensor_set_options_async (CdSensor *sensor,
GHashTable *options,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
CdSensorDummyPrivate *priv = cd_sensor_dummy_get_private (sensor);
GList *l;
const gchar *key_name;
GVariant *value;
g_autoptr(GTask) task = NULL;
g_autoptr(GList) keys = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
task = g_task_new (sensor, cancellable, callback, user_data);
/* look for any keys we recognise */
keys = g_hash_table_get_keys (options);
for (l = keys; l != NULL; l = l->next) {
key_name = (const gchar *) l->data;
value = g_hash_table_lookup (options, key_name);
if (g_strcmp0 (g_variant_get_type_string (value), "d") != 0) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"unexpected type '%s' not supported",
g_variant_get_type_string (value));
return;
}
if (g_strcmp0 (key_name, "sample[red]") == 0) {
priv->sample_fake.R = g_variant_get_double (value);
} else if (g_strcmp0 (key_name, "sample[green]") == 0) {
priv->sample_fake.G = g_variant_get_double (value);
} else if (g_strcmp0 (key_name, "sample[blue]") == 0) {
priv->sample_fake.B = g_variant_get_double (value);
} else {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"option '%s' is not supported",
key_name);
return;
}
}
/* success */
g_task_return_boolean (task, TRUE);
}
static void
volume_widget_property_update( DbusmenuMenuitem* item, gchar* property,
GVariant* value, gpointer userdata)
{
g_return_if_fail (IS_VOLUME_WIDGET(userdata));
VolumeWidget* mitem = VOLUME_WIDGET(userdata);
VolumeWidgetPrivate * priv = VOLUME_WIDGET_GET_PRIVATE(mitem);
if(g_ascii_strcasecmp(DBUSMENU_VOLUME_MENUITEM_LEVEL, property) == 0){
g_return_if_fail (g_variant_is_of_type (value, G_VARIANT_TYPE_DOUBLE) );
if(priv->grabbed == FALSE){
GtkWidget *slider = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_volume_slider);
GtkRange *range = (GtkRange*)slider;
gdouble update = g_variant_get_double (value);
gtk_range_set_value(range, update);
/*
g_debug ("volume-widget::volume_widget_property_update - volume - value %f", update);
*/
update_accessible_desc(update/**priv->indicator*/);
}
}
else if(g_ascii_strcasecmp(DBUSMENU_VOLUME_MENUITEM_MUTE, property) == 0){
g_return_if_fail (g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN));
if(priv->grabbed == FALSE){
GtkWidget *slider = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_volume_slider);
GtkRange *range = (GtkRange*)slider;
gboolean update = g_variant_get_boolean (value);
gdouble level;
if (update == TRUE){
level = 0;
}
else{
GVariant* variant = dbusmenu_menuitem_property_get_variant (priv->twin_item,
DBUSMENU_VOLUME_MENUITEM_LEVEL);
/*
g_debug ("variant for the volume - is it null = %i", variant == NULL);
*/
g_return_if_fail (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE) );
level = g_variant_get_double (variant);
}
/*
g_debug ("volume-widget::volume_widget_property_update - mute - value %i and level = %f", update, level);
*/
gtk_range_set_value(range, level);
}
}
}
static gboolean
_set_player_property_cb (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *property_name,
GVariant *value,
GError **error,
gpointer user_data)
{
MexMprisPluginPrivate *priv = MEX_MPRIS_PLUGIN (user_data)->priv;
/* Currently unsupported properties */
if (g_strcmp0 (property_name, "LoopStatus") == 0 ||
g_strcmp0 (property_name, "Rate") == 0 ||
g_strcmp0 (property_name, "Shuffle") == 0)
return FALSE;
if (g_strcmp0 (property_name, "Volume") == 0)
{
clutter_media_set_audio_volume (priv->media, g_variant_get_double (value));
return TRUE;
}
g_set_error (error,
G_DBUS_ERROR,
G_DBUS_ERROR_NOT_SUPPORTED,
"Property %s.%s not supported",
interface_name,
property_name);
return FALSE;
}
static int config_set(uint32_t key, GVariant *data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
struct dev_context *devc;
int ret;
(void)cg;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
ret = SR_OK;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
return sr_sw_limits_config_set(&devc->limits, key, data);
case SR_CONF_ENABLED:
ret = reloadpro_set_on_off(sdi, g_variant_get_boolean(data));
break;
case SR_CONF_CURRENT_LIMIT:
ret = reloadpro_set_current_limit(sdi,
g_variant_get_double(data));
break;
default:
ret = SR_ERR_NA;
}
return ret;
}
static void onPropertiesChanged(GDBusProxy *proxy,
GVariant *changed_properties,
const gchar* const *invalidated_properties,
gpointer pp)
{
if (g_variant_n_children(changed_properties) > 0) {
GVariantIter *iter;
gchar *key;
GVariant *value;
debug(" *** Properties Changed:\n");
g_variant_get(changed_properties, "a{sv}", &iter);
while (g_variant_iter_loop (iter, "{&sv}", &key, &value)) {
gchar *value_str;
value_str = g_variant_print(value, TRUE);
g_print(" %s -> %s\n", key, value_str);
g_free(value_str);
if (strncmp(key, "Metadata",8) == 0) {
trackChanged(value);
} else if (strcmp(key, "PlaybackStatus") == 0) {
playbackChanged(g_variant_dup_string(value, NULL));
} else if (strcmp(key, "LoopStatus") == 0) {
loopChanged(g_variant_dup_string(value, NULL));
} else if (strcmp(key, "Shuffle") == 0) {
shuffleChanged(g_variant_get_boolean(value));
} else if (strcmp(key, "Position") == 0) {
positionChanged(g_variant_get_int64(value));
} else if (strcmp(key, "Volume") == 0) {
volumeChanged(g_variant_get_double(value));
}
}
g_variant_iter_free (iter);
}
}
static gdouble
_tp_variant_convert_double (GVariant *variant,
gboolean *valid)
{
*valid = TRUE;
switch (g_variant_classify (variant))
{
case G_VARIANT_CLASS_DOUBLE:
return g_variant_get_double (variant);
case G_VARIANT_CLASS_BYTE:
return g_variant_get_byte (variant);
case G_VARIANT_CLASS_UINT32:
return g_variant_get_uint32 (variant);
case G_VARIANT_CLASS_INT32:
return g_variant_get_int32 (variant);
case G_VARIANT_CLASS_INT64:
return g_variant_get_int64 (variant);
case G_VARIANT_CLASS_UINT64:
return g_variant_get_uint64 (variant);
default:
break;
}
*valid = FALSE;
return 0.0;
}
void DeviceOptions::samplerate_double_setter(
struct sr_dev_inst *sdi, GVariant *value)
{
GVariant *const gvar = g_variant_new_uint64(
g_variant_get_double(value));
config_setter(sdi, SR_CONF_SAMPLERATE, gvar);
}
gdouble
go_conf_load_double (GOConfNode *node, gchar const *key,
gdouble minima, gdouble maxima, gdouble default_val)
{
gdouble res = -1;
GVariant *val = NULL;
if (node) {
if (key && !strchr (key, '/') && !strchr (key, '.'))
val = go_conf_get (node, key, G_VARIANT_TYPE_DOUBLE);
else if (node->key)
val = go_conf_get (node, node->key, G_VARIANT_TYPE_DOUBLE);
}
if (val == NULL) {
GOConfNode *real_node = go_conf_get_node (node, key);
val = real_node? go_conf_get (real_node, real_node->key, G_VARIANT_TYPE_DOUBLE): NULL;
go_conf_free_node (real_node);
}
if (val != NULL) {
res = g_variant_get_double (val);
g_variant_unref (val);
if (res < minima || maxima < res) {
g_warning ("Invalid value '%g' for %s. If should be >= %g and <= %g",
res, key, minima, maxima);
val = NULL;
}
} else {
d (g_warning ("Using default value '%g'", default_val));
return default_val;
}
return res;
}
/* Handle position change callbacks */
static void
geoclue_client_signal_cb(GDBusProxy *client, gchar *sender_name,
gchar *signal_name, GVariant *parameters,
gpointer *user_data)
{
get_location_data_t *data = (get_location_data_t *)user_data;
/* Only handle LocationUpdated signals */
if (g_strcmp0(signal_name, "LocationUpdated") != 0) {
return;
}
/* Obtain location path */
const gchar *location_path;
g_variant_get_child(parameters, 1, "&o", &location_path);
/* Obtain location */
GError *error = NULL;
GDBusProxy *location =
g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.GeoClue2",
location_path,
"org.freedesktop.GeoClue2.Location",
NULL, &error);
if (location == NULL) {
g_printerr(_("Unable to obtain location: %s.\n"),
error->message);
g_error_free(error);
return;
}
/* Read location properties */
GVariant *lat_v = g_dbus_proxy_get_cached_property(location,
"Latitude");
data->latitude = g_variant_get_double(lat_v);
GVariant *lon_v = g_dbus_proxy_get_cached_property(location,
"Longitude");
data->longitude = g_variant_get_double(lon_v);
data->available = 1;
/* Return from main loop */
g_main_loop_quit(data->loop);
}
/**
* json_gvariant_serialize:
* @variant: A #GVariant to convert
*
* Converts @variant to a JSON tree.
*
* Return value: (transfer full): A #JsonNode representing the root of the
* JSON data structure obtained from @variant
*
* Since: 0.14
*/
JsonNode *
json_gvariant_serialize (GVariant *variant)
{
JsonNode *json_node = NULL;
GVariantClass class;
g_return_val_if_fail (variant != NULL, NULL);
class = g_variant_classify (variant);
if (! g_variant_is_container (variant))
{
json_node = json_node_new (JSON_NODE_VALUE);
switch (class)
{
case G_VARIANT_CLASS_BOOLEAN:
json_node_set_boolean (json_node, g_variant_get_boolean (variant));
break;
case G_VARIANT_CLASS_BYTE:
json_node_set_int (json_node, g_variant_get_byte (variant));
break;
case G_VARIANT_CLASS_INT16:
json_node_set_int (json_node, g_variant_get_int16 (variant));
break;
case G_VARIANT_CLASS_UINT16:
json_node_set_int (json_node, g_variant_get_uint16 (variant));
break;
case G_VARIANT_CLASS_INT32:
json_node_set_int (json_node, g_variant_get_int32 (variant));
break;
case G_VARIANT_CLASS_UINT32:
json_node_set_int (json_node, g_variant_get_uint32 (variant));
break;
case G_VARIANT_CLASS_INT64:
json_node_set_int (json_node, g_variant_get_int64 (variant));
break;
case G_VARIANT_CLASS_UINT64:
json_node_set_int (json_node, g_variant_get_uint64 (variant));
break;
case G_VARIANT_CLASS_HANDLE:
json_node_set_int (json_node, g_variant_get_handle (variant));
break;
case G_VARIANT_CLASS_DOUBLE:
json_node_set_double (json_node, g_variant_get_double (variant));
break;
case G_VARIANT_CLASS_STRING:
case G_VARIANT_CLASS_OBJECT_PATH:
case G_VARIANT_CLASS_SIGNATURE:
json_node_set_string (json_node, g_variant_get_string (variant, NULL));
break;
default:
break;
}
}
void channel1_update(SooshiState *state, SooshiNode *node, gpointer user_data)
{
AppState *s = (AppState*)user_data;
gchar *str = g_strdup_printf("%fA", g_variant_get_double(node->value));
gtk_label_set_text(GTK_LABEL(s->channel1), str);
g_free(str);
}
static gboolean
consume_variant (MMSignal *self,
const gchar *key,
GVariant *value,
GError **error)
{
if (g_str_equal (key, PROPERTY_RSSI))
self->priv->rssi = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_ECIO))
self->priv->ecio = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_SINR))
self->priv->sinr = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_IO))
self->priv->io = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_RSRP))
self->priv->rsrp = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_RSRQ))
self->priv->rsrq = g_variant_get_double (value);
else if (g_str_equal (key, PROPERTY_SNR))
self->priv->snr = g_variant_get_double (value);
else {
/* Set error */
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_INVALID_ARGS,
"Invalid signal dictionary, unexpected key '%s'",
key);
return FALSE;
}
return TRUE;
}
static void
on_pad_knob_change (GSimpleAction *action,
GVariant *parameter,
DrawingArea *area)
{
gdouble value = g_variant_get_double (parameter);
area->brush_size = value;
}
void updateVolumeProperty() {
GVariant * volume = updateProperty(mpris_data->player, "Volume");
if (volume == NULL) {
return;
}
volumeChanged(g_variant_get_double(volume));
g_variant_unref(volume);
}
gdouble
volume_widget_get_current_volume ( GtkWidget *widget )
{
VolumeWidget* mitem = VOLUME_WIDGET(widget);
VolumeWidgetPrivate * priv = VOLUME_WIDGET_GET_PRIVATE(mitem);
gdouble vol = g_variant_get_double( dbusmenu_menuitem_property_get_variant( priv->twin_item,
DBUSMENU_VOLUME_MENUITEM_LEVEL));
return vol;
}
void battery_update(SooshiState *state, SooshiNode *node, gpointer user_data)
{
AppState *s = (AppState*)user_data;
float voltage = g_variant_get_double(node->value);
gtk_level_bar_set_value(GTK_LEVEL_BAR(s->battery_level), voltage - 2.0);
gchar *str = g_strdup_printf("%.1f%%", (voltage - 2.0) * 100.0);
gtk_label_set_text(GTK_LABEL(s->battery_level_str), str);
g_free(str);
}
static int config_set(int key, GVariant *data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
int ret;
double dblval;
(void)cg;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
ret = SR_OK;
switch (key) {
case SR_CONF_OUTPUT_VOLTAGE:
dblval = g_variant_get_double(data);
if ((dblval < 0.0) || (dblval > 35.0)) {
sr_err("Voltage out of range (0 - 35.0)!");
return SR_ERR_ARG;
}
ret = send_msg1(sdi, 'V', (int) (dblval * 10 + 0.5));
break;
case SR_CONF_OUTPUT_CURRENT:
dblval = g_variant_get_double(data);
if ((dblval < 0.01) || (dblval > 2.55)) {
sr_err("Current out of range (0 - 2.55)!");
return SR_ERR_ARG;
}
ret = send_msg1(sdi, 'C', (int) (dblval * 100 + 0.5));
break;
/* No SR_CONF_OUTPUT_ENABLED :-( . */
case SR_CONF_OVER_CURRENT_PROTECTION:
if (g_variant_get_boolean(data))
ret = send_msg1(sdi, 'V', 900);
else /* Constant current mode */
ret = send_msg1(sdi, 'V', 901);
break;
default:
ret = SR_ERR_NA;
}
return ret;
}
static void
on_location_proxy_ready (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GDBusProxy *manager = G_DBUS_PROXY (user_data);
GDBusProxy *location = G_DBUS_PROXY (source_object);
GVariant *value;
gdouble latitude, longitude, accuracy;
const char *desc;
gsize desc_len;
GError *error = NULL;
location = g_dbus_proxy_new_for_bus_finish (res, &error);
if (error != NULL) {
g_critical ("Failed to connect to GeoClue2 service: %s", error->message);
exit (-5);
}
value = g_dbus_proxy_get_cached_property (location, "Latitude");
latitude = g_variant_get_double (value);
value = g_dbus_proxy_get_cached_property (location, "Longitude");
longitude = g_variant_get_double (value);
value = g_dbus_proxy_get_cached_property (location, "Accuracy");
accuracy = g_variant_get_double (value);
g_print ("Latitude: %f\nLongitude: %f\nAccuracy (in meters): %f\n",
latitude,
longitude,
accuracy);
value = g_dbus_proxy_get_cached_property (location, "Description");
desc = g_variant_get_string (value, &desc_len);
if (desc_len > 0)
g_print ("Description: %s\n", desc);
g_object_unref (location);
g_object_unref (manager);
g_main_loop_quit (main_loop);
}
static gboolean
actual_slide (gpointer user_data)
{
Action *slide_action = user_data;
g_simple_action_set_state(G_SIMPLE_ACTION(slide_action->action), slide_action->value);
g_message ("sliding %f", g_variant_get_double(slide_action->value));
free(slide_action);
return FALSE;
}
static gboolean
get_large_text_mapping (GValue *value,
GVariant *variant,
gpointer user_data)
{
gdouble factor;
factor = g_variant_get_double (variant);
g_value_set_boolean (value, is_large_factor (factor));
return TRUE;
}
void change_slider (GSimpleAction *action,
GVariant *value,
gpointer user_data)
{
IndicatorTestService *indicator = user_data;
Action* slide_action = malloc(sizeof(Action));
slide_action->action = action;
slide_action->value = g_variant_ref(value);
g_timeout_add(indicator->action_delay, actual_slide, slide_action);
g_message ("slide delay %f", g_variant_get_double(value));
}
static int init(struct sr_transform *t, GHashTable *options)
{
struct context *ctx;
if (!t || !t->sdi || !options)
return SR_ERR_ARG;
t->priv = ctx = g_malloc0(sizeof(struct context));
ctx->factor = g_variant_get_double(g_hash_table_lookup(options, "factor"));
return SR_OK;
}
QVariant gvariantToQVariant(GVariant *value)
{
GVariantClass c = g_variant_classify(value);
if(c == G_VARIANT_CLASS_BOOLEAN)
return QVariant((bool) g_variant_get_boolean(value));
else if(c == G_VARIANT_CLASS_BYTE)
return QVariant((char) g_variant_get_byte(value));
else if(c == G_VARIANT_CLASS_INT16)
return QVariant((int) g_variant_get_int16(value));
else if(c == G_VARIANT_CLASS_UINT16)
return QVariant((unsigned int) g_variant_get_uint16(value));
else if(c == G_VARIANT_CLASS_INT32)
return QVariant((int) g_variant_get_int32(value));
else if(c == G_VARIANT_CLASS_UINT32)
return QVariant((unsigned int) g_variant_get_uint32(value));
else if(c == G_VARIANT_CLASS_INT64)
return QVariant((long long) g_variant_get_int64(value));
else if(c == G_VARIANT_CLASS_UINT64)
return QVariant((unsigned long long) g_variant_get_uint64(value));
else if(c == G_VARIANT_CLASS_DOUBLE)
return QVariant(g_variant_get_double(value));
else if(c == G_VARIANT_CLASS_STRING)
return QVariant(g_variant_get_string(value, NULL));
else if(c == G_VARIANT_CLASS_ARRAY)
{
gsize dictsize = g_variant_n_children(value);
QVariantList list;
for (int i=0;i<dictsize;i++)
{
GVariant *childvariant = g_variant_get_child_value(value,i);
GVariant *innervariant = g_variant_get_variant(childvariant);
list.append(gvariantToQVariant(innervariant));
}
return list;
}
else
return QVariant::Invalid;
}
static gboolean
get_large_text_mapping (GValue *value,
GVariant *variant,
gpointer user_data)
{
gdouble factor;
gboolean large;
factor = g_variant_get_double (variant);
large = factor > DPI_FACTOR_NORMAL;
g_value_set_boolean (value, large);
return TRUE;
}
std::string StringFromVariant(GVariant* variant)
{
std::stringstream ss;
const GVariantType* info_hint_type = g_variant_get_type(variant);
if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_BOOLEAN))
{
ss << g_variant_get_int16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT16))
{
ss << g_variant_get_int16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT16))
{
ss << g_variant_get_uint16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT32))
{
ss << g_variant_get_int32(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT32))
{
ss << g_variant_get_uint32(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT64))
{
ss << g_variant_get_int64(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT64))
{
ss << g_variant_get_uint64(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_DOUBLE))
{
ss << g_variant_get_double(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_STRING))
{
std::string str = g_variant_get_string(variant, NULL);
ss << str;
}
else
{
ss << "unknown value";
}
return ss.str();
}
void channel2_update(SooshiState *state, SooshiNode *node, gpointer user_data)
{
AppState *s = (AppState*)user_data;
double value = g_variant_get_double(node->value);
gchar *unit = "V";
if (ABS(value) < 1.0)
{
value *= 1000.0;
unit = "mV";
}
gchar *str = g_strdup_printf("%f %s", value, unit);
gtk_label_set_text(GTK_LABEL(s->channel2), str);
g_free(str);
}
