void activate_action_string(GmpvApplication *app, const gchar *str)
{
GActionMap *map = G_ACTION_MAP(app);
GAction *action = NULL;
gchar *name = NULL;
GVariant *param = NULL;
gboolean param_match = FALSE;
g_action_parse_detailed_name(str, &name, ¶m, NULL);
if(name)
{
const GVariantType *action_ptype;
const GVariantType *given_ptype;
action = g_action_map_lookup_action(map, name);
action_ptype = g_action_get_parameter_type(action);
given_ptype = param?g_variant_get_type(param):NULL;
param_match = (action_ptype == given_ptype) ||
g_variant_type_is_subtype_of
(action_ptype, given_ptype);
}
if(action && param_match)
{
g_debug("Activating action %s", str);
g_action_activate(action, param);
}
else
{
g_warning("Failed to activate action \"%s\"", str);
}
}
static void
bluez_handle_disconnect(GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
// check if parameter is valid and is the parameter we were looking for
if( !(g_variant_type_equal(g_variant_get_type(parameters), "(sv)") &&
g_variant_n_children(parameters) == 2) )
return;
GVariant* name = g_variant_get_child_value(parameters, 0);
GVariant* value = g_variant_get_variant(g_variant_get_child_value(parameters, 1));
if( !(g_strcmp0(g_variant_get_string(name, NULL), "Connected") == 0 &&
g_variant_type_equal(g_variant_get_type(value), G_VARIANT_TYPE_BOOLEAN) ) )
return;
gboolean connected = g_variant_get_boolean(value);
g_printf("Connected: %d\n", connected);
if(!connected)
{
gchar* device_path = (gchar*)user_data;
gchar* service_path = g_strconcat(device_path, "/service0007", NULL);
bluez_unregister_watcher(connection, service_path);
bluez_register_watcher(connection, service_path);
}
}
// Simple wrapper for a common D-Bus pattern.
GVariant * g_dbus_simple_send(GDBusConnection *bus, GDBusMessage *msg, const gchar *type)
{
GDBusMessage *reply;
GVariant *body;
gchar *fmt;
if (!(reply = g_dbus_send(bus, msg, 0, -1, 0, 0, 0))) {
g_object_unref(msg);
return NULL;
}
body = g_dbus_message_get_body(reply);
fmt = g_dbus_message_print(reply, 0);
g_variant_ref(body);
if (g_strcmp0(g_variant_type_peek_string(g_variant_get_type(body)), type) != 0) {
g_message("body type %s does not match expected type %s, message: %s",
g_variant_type_peek_string(g_variant_get_type(body)),
type,
fmt);
g_variant_unref(body);
// return error
body = NULL;
}
g_free(fmt);
g_object_unref(reply);
g_object_unref(msg);
return body;
}
gboolean
variantIsValidForCCSType (GVariant *gsettingsValue,
CCSSettingType settingType)
{
gboolean valid = FALSE;
switch (settingType)
{
case TypeString:
case TypeMatch:
case TypeColor:
case TypeKey:
case TypeButton:
case TypeEdge:
valid = (g_variant_type_is_subtype_of (G_VARIANT_TYPE_STRING, g_variant_get_type (gsettingsValue)));
break;
case TypeInt:
valid = (g_variant_type_is_subtype_of (G_VARIANT_TYPE_INT32, g_variant_get_type (gsettingsValue)));
break;
case TypeBool:
case TypeBell:
valid = (g_variant_type_is_subtype_of (G_VARIANT_TYPE_BOOLEAN, g_variant_get_type (gsettingsValue)));
break;
case TypeFloat:
valid = (g_variant_type_is_subtype_of (G_VARIANT_TYPE_DOUBLE, g_variant_get_type (gsettingsValue)));
break;
case TypeList:
valid = (g_variant_type_is_array (g_variant_get_type (gsettingsValue)));
break;
default:
break;
}
return valid;
}
unsigned char bluez_characteristic_extract_value(GVariant* variant)
{
GVariant* var_array = g_variant_get_child_value(variant, 0);
for(unsigned int i = 0; i < g_variant_n_children(var_array); i++)
{
GVariant* var_child = g_variant_get_child_value(var_array, i);
if(g_variant_n_children(var_child) == 2)
{
GVariant* var_id = g_variant_get_child_value(var_child, 0);
if(g_variant_type_equal(g_variant_get_type(var_id), G_VARIANT_TYPE_STRING) &&
g_strcmp0(g_variant_get_string(var_id, NULL), "Value") == 0)
{
GVariant* inner_var = g_variant_get_child_value(var_child, 1);
if( g_variant_type_equal(g_variant_get_type(inner_var), G_VARIANT_TYPE_VARIANT) )
{
GVariant* var_value = g_variant_get_variant(inner_var);
if( g_variant_type_equal(g_variant_get_type(var_value), G_VARIANT_TYPE_BYTESTRING) )
{
GVariant* var_byte = g_variant_get_child_value(var_value, 0);
return g_variant_get_byte(var_byte);
}
}
}
}
g_variant_unref(var_child);
}
return 0;
}
boost::shared_ptr<AuthProvider> createSignonAuthProvider(const InitStateString &username,
const InitStateString &password)
{
// Expected content of parameter GVariant.
boost::shared_ptr<GVariantType> hashtype(g_variant_type_new("a{sv}"), g_variant_type_free);
// 'username' is the part after signon: which we can parse directly.
GErrorCXX gerror;
GVariantCXX parametersVar(g_variant_parse(hashtype.get(), username.c_str(), NULL, NULL, gerror),
TRANSFER_REF);
if (!parametersVar) {
gerror.throwError(SE_HERE, "parsing 'signon:' username");
}
GHashTableCXX parameters(Variant2HashTable(parametersVar));
// Extract the values that we expect in the parameters hash.
guint32 signonID;
const char *method;
const char *mechanism;
GVariant *value;
value = (GVariant *)g_hash_table_lookup(parameters, "identity");
if (!value ||
!g_variant_type_equal(G_VARIANT_TYPE_UINT32, g_variant_get_type(value))) {
SE_THROW("need 'identity: <numeric ID>' in 'signon:' parameters");
}
signonID = g_variant_get_uint32(value);
value = (GVariant *)g_hash_table_lookup(parameters, "method");
if (!value ||
!g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) {
SE_THROW("need 'method: <string>' in 'signon:' parameters");
}
method = g_variant_get_string(value, NULL);
value = (GVariant *)g_hash_table_lookup(parameters, "mechanism");
if (!value ||
!g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) {
SE_THROW("need 'mechanism: <string>' in 'signon:' parameters");
}
mechanism = g_variant_get_string(value, NULL);
value = (GVariant *)g_hash_table_lookup(parameters, "session");
if (!value ||
!g_variant_type_equal(hashtype.get(), g_variant_get_type(value))) {
SE_THROW("need 'session: <hash>' in 'signon:' parameters");
}
GHashTableCXX sessionData(Variant2HashTable(value));
SE_LOG_DEBUG(NULL, "using identity %u, method %s, mechanism %s",
signonID, method, mechanism);
SignonIdentityCXX identity(signon_identity_new_from_db(signonID), TRANSFER_REF);
SE_LOG_DEBUG(NULL, "using signond identity %d", signonID);
SignonAuthSessionCXX authSession(signon_identity_create_session(identity, method, gerror), TRANSFER_REF);
boost::shared_ptr<AuthProvider> provider(new SignonAuthProvider(authSession, sessionData, mechanism));
return provider;
}
static GError *
_stmt_apply_GV_parameter_simple(sqlite3_stmt *stmt, int pos, GVariant *p)
{
int rc;
gsize slen = 0;
const gchar *s;
switch (*((gchar*)g_variant_get_type(p))) {
case 'b':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_boolean(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'i':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int32(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'n':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int16(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'q':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint16(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 's':
s = g_variant_get_string(p, &slen);
rc = sqlite3_bind_text(stmt, pos, s, slen, NULL);
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 't':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint64(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'u':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_uint32(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'x':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_int64(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
case 'y':
rc = sqlite3_bind_int64(stmt, pos, g_variant_get_byte(p));
EXTRA_ASSERT(rc == SQLITE_OK);
return NULL;
/* XXX TODO manage the G_VARIANT_UNIT associtaed to NULL'd fields */
default:
return NEWERROR(CODE_BAD_REQUEST, "Unexpected parameter at position %d ('%s')",
pos, (gchar*)g_variant_get_type(p));
}
(void) rc;
}
TYPE get_numeric_value(GVariant *variant_, const char *type_str, const char *fallback_type_str)
{
GTYPE value = 0;
if (!variant_)
return static_cast<TYPE>(value);
if (g_variant_is_of_type(variant_, G_VARIANT_TYPE(type_str)))
{
g_variant_get(variant_, type_str, &value);
}
else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE(fallback_type_str)))
{
g_variant_get(variant_, fallback_type_str, &value);
}
else
{
auto const& variant = get_variant(variant_);
if (variant)
return get_numeric_value<TYPE, GTYPE>(static_cast<GVariant*>(variant), type_str, fallback_type_str);
LOG_ERROR(logger) << "You're trying to extract a '" << type_str << "'"
<< " from a variant which is of type '"
<< g_variant_type_peek_string(g_variant_get_type(variant_))
<< "'";
}
return static_cast<TYPE>(value);
}
std::string Variant::GetString() const
{
const gchar *result = nullptr;
if (!variant_)
return "";
if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_STRING))
{
// g_variant_get_string doesn't duplicate the string
result = g_variant_get_string(variant_, nullptr);
}
else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(s)")))
{
// As we're using the '&' prefix we don't need to free the string!
g_variant_get(variant_, "(&s)", &result);
}
else
{
auto const& variant = get_variant(variant_);
if (variant)
return variant.GetString();
LOG_ERROR(logger) << "You're trying to extract a 's' from a variant which is of type '"
<< g_variant_type_peek_string(g_variant_get_type(variant_)) << "'";
}
return result ? result : "";
}
static GError *
_stmt_apply_GV_parameter(sqlite3_stmt *stmt, int pos, GVariant *p)
{
if (g_variant_is_of_type(p, G_VARIANT_TYPE_UNIT)) {
sqlite3_bind_null(stmt, pos);
return NULL;
}
if (g_variant_is_of_type(p, G_VARIANT_TYPE_BASIC)) {
return _stmt_apply_GV_parameter_simple(stmt, pos, p);
}
if (g_variant_is_of_type(p, G_VARIANT_TYPE_UNIT)) {
sqlite3_bind_null(stmt, pos);
return NULL;
}
if (g_variant_is_of_type(p, G_VARIANT_TYPE_BYTESTRING)) {
sqlite3_bind_blob(stmt, pos, g_variant_get_data(p),
g_variant_get_size(p), NULL);
return NULL;
}
return NEWERROR(CODE_BAD_REQUEST, "Unexpected parameter at position %d (type '%s')",
pos, (gchar*)g_variant_get_type(p));
}
static void
services_changed(GVariant *params)
{
connman_service_t *prev = NULL, *cs;
GVariant *del = g_variant_get_child_value(params, 1);
for(int i = 0, n = g_variant_n_children(del); i < n; i++) {
GVariant *v = g_variant_get_child_value(del, i);
if(g_variant_type_equal(g_variant_get_type(v),
G_VARIANT_TYPE_OBJECT_PATH)) {
const char *name = g_variant_get_string(v, NULL);
TRACE(TRACE_DEBUG, "CONNMAN", "Deleted network %s", name);
if((cs = connman_service_find(name)) != NULL)
connman_service_destroy(cs);
}
}
GVariant *add = g_variant_get_child_value(params, 0);
for(int i = 0, n = g_variant_n_children(add); i < n; i++) {
GVariant *v = g_variant_get_child_value(add, i);
const char *id =
g_variant_get_string(g_variant_get_child_value(v, 0), NULL);
cs = update_service(g_variant_get_child_value(v, 1), id, prev);
if(cs != NULL)
prev = cs;
}
}
static void
g_simple_action_set_state (GAction *action,
GVariant *value)
{
GSimpleAction *simple = G_SIMPLE_ACTION (action);
g_return_if_fail (value != NULL);
{
const GVariantType *state_type;
state_type = simple->priv->state ?
g_variant_get_type (simple->priv->state) : NULL;
g_return_if_fail (state_type != NULL);
g_return_if_fail (g_variant_is_of_type (value, state_type));
}
g_variant_ref_sink (value);
if (!g_variant_equal (simple->priv->state, value))
{
if (simple->priv->state)
g_variant_unref (simple->priv->state);
simple->priv->state = g_variant_ref (value);
g_object_notify (G_OBJECT (simple), "state");
}
g_variant_unref (value);
}
static void
gb_color_picker_prefs_palette_row_activate (GbColorPickerPrefsPaletteRow *self)
{
g_autoptr (GVariant) value = NULL;
g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self));
g_assert (self->target != NULL);
if (!gtk_widget_get_sensitive (GTK_WIDGET (self)) || self->settings == NULL || self->updating)
return;
value = g_settings_get_value (self->settings, self->key);
if (g_variant_is_of_type (value, g_variant_get_type (self->target)))
{
if (!g_variant_equal (value, self->target))
{
self->updating = TRUE;
g_settings_set_value (self->settings, self->key, self->target);
gtk_widget_set_visible (GTK_WIDGET (self->image), TRUE);
self->updating = FALSE;
}
}
else
g_warning ("Value and target must be of the same type");
}
static void
gb_color_picker_prefs_palette_row_changed (GbColorPickerPrefsPaletteRow *self,
const gchar *key,
GSettings *settings)
{
g_autoptr (GVariant) value = NULL;
gboolean active;
g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self));
g_assert (key != NULL);
g_assert (G_IS_SETTINGS (settings));
if (self->target == NULL)
{
gtk_widget_set_visible (GTK_WIDGET (self->image), FALSE);
return;
}
if (self->updating == TRUE)
return;
value = g_settings_get_value (settings, key);
if (g_variant_is_of_type (value, g_variant_get_type (self->target)))
{
active = (g_variant_equal (value, self->target));
gtk_widget_set_visible (GTK_WIDGET (self->image), active);
}
else
g_warning ("Value and target must be of the same type");
}
bool QGSettings::trySetValue(const QString &key, const QVariant &value)
{
Q_D(QGSettings);
if (!d->valid)
return false;
gchar *keyName = Utils::fromCamelCase(key);
// Since gio crashes when setting a key that doesn't exist,
// we better check here and return false
if (!keys().contains(key))
return false;
bool result = false;
// It might be hard to detect the right GVariant type from
// complext QVariant types such as string lists or more detailed
// types such as integers (GVariant has different sizes),
// therefore we get the current value for the key and convert
// to QVariant using the GVariant type
GVariant *oldValue = g_settings_get_value(d->settings, keyName);
GVariant *newValue = Utils::toGVariant(g_variant_get_type(oldValue), value);
if (newValue)
result = g_settings_set_value(d->settings, keyName, newValue);
g_free(keyName);
g_variant_unref(oldValue);
return result;
}
SR_PRIV int sr_variant_type_check(uint32_t key, GVariant *value)
{
const struct sr_key_info *info;
const GVariantType *type, *expected;
char *expected_string, *type_string;
info = sr_key_info_get(SR_KEY_CONFIG, key);
if (!info)
return SR_OK;
expected = sr_variant_type_get(info->datatype);
type = g_variant_get_type(value);
if (!g_variant_type_equal(type, expected)
&& !g_variant_type_is_subtype_of(type, expected)) {
expected_string = g_variant_type_dup_string(expected);
type_string = g_variant_type_dup_string(type);
sr_err("Wrong variant type for key '%s': expected '%s', got '%s'",
info->name, expected_string, type_string);
g_free(expected_string);
g_free(type_string);
return SR_ERR_ARG;
}
return SR_OK;
}
static gboolean
iter_get_fields (GVariant *variant,
gulong attr_type,
GckBuilder *builder)
{
GString *result;
const gchar *key, *value;
GVariantIter iter;
g_assert (variant != NULL);
g_assert (builder != NULL);
g_return_val_if_fail (g_variant_type_is_array (g_variant_get_type (variant)), FALSE);
result = g_string_new ("");
g_variant_iter_init (&iter, variant);
while (g_variant_iter_next (&iter, "{&s&s}", &key, &value)) {
/* Key */
g_string_append (result, key);
g_string_append_c (result, '\0');
/* Value */
g_string_append (result, value);
g_string_append_c (result, '\0');
}
gck_builder_add_data (builder, attr_type, (const guchar *)result->str, result->len);
g_string_free (result, TRUE);
return TRUE;
}
static void
handle_method_call (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
if(g_strcmp0(method_name, "ValueChanged") == 0)
{
for(unsigned int j = 0; j < g_variant_n_children(parameters); j++)
{
GVariant* var_child = g_variant_get_child_value(parameters, j);
if( g_variant_type_equal(g_variant_get_type(var_child), G_VARIANT_TYPE_OBJECT_PATH) )
g_printf("%s\n", g_variant_get_string(var_child, NULL));
else if( g_variant_type_equal(g_variant_get_type(var_child), "ay") )
{
BLEThread* thread = (BLEThread*)user_data;
GVariant* var_state = g_variant_get_child_value(var_child, 0);
thread->setState(g_variant_get_byte(var_state));
for(unsigned int i = 0; i < g_variant_n_children(var_child); i++)
{
GVariant* var_inner_child = g_variant_get_child_value(var_child, i);
if( g_variant_type_equal(g_variant_get_type(var_inner_child), G_VARIANT_TYPE_BYTE) )
g_printf("%02x ", g_variant_get_byte(var_inner_child));
}
g_printf("\n");
}
g_variant_unref(var_child);
}
}
else
{
g_printf("Received method with name %s\n", method_name);
}
}
static const GVariantType *
g_simple_action_get_state_type (GAction *action)
{
GSimpleAction *simple = G_SIMPLE_ACTION (action);
if (simple->priv->state != NULL)
return g_variant_get_type (simple->priv->state);
else
return NULL;
}
static void
conf_tray_settings_cb (GSettings *settings, guint cnxn_id, gchar *key, gpointer user_data)
{
GVariant *gv;
if (key) {
gv = g_settings_get_value (settings, key);
if (gv && g_variant_get_type(gv) == G_VARIANT_TYPE_BOOLEAN)
ui_tray_enable (g_settings_get_boolean (settings,key));
}
}
static gboolean
type_uint32 (GSettings *settings,
const gchar *key)
{
const GVariantType *type;
GVariant *value;
value = g_settings_get_value (settings, key);
type = g_variant_get_type (value);
g_variant_unref (value);
return g_variant_type_equal (type, G_VARIANT_TYPE_UINT32);
}
/**
* workman_attribute_set_value:
* @attr: a #WorkmanAttribute
* @value: (transfer floating): the attribute %G_VARIANT_TYPE_MAYBE value to set
* @error: (allow-none): return location for a #GError, or %NULL
*
* Returns: %TRUE if the operation succeeded
*/
gboolean
workman_attribute_set_value(WorkmanAttribute *attr,
GVariant *value,
GError **error)
{
g_return_val_if_fail(value != NULL, FALSE);
if (attr->priv->value) {
const GVariantType *old_type = g_variant_get_type(attr->priv->value);
const GVariantType *new_type = g_variant_get_type(value);
g_return_val_if_fail(g_variant_type_equal(old_type, new_type),
FALSE);
g_variant_unref(attr->priv->value);
}
attr->priv->value = value;
g_variant_ref_sink(attr->priv->value);
return TRUE;
}
void
prop_set_from_gvariant(GVariant *v, prop_t *p)
{
const GVariantType *T = g_variant_get_type(v);
if(g_variant_type_equal(T, G_VARIANT_TYPE_BOOLEAN)) {
prop_set_int(p, g_variant_get_boolean(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_BYTE)) {
prop_set_int(p, g_variant_get_byte(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT16)) {
prop_set_int(p, g_variant_get_int16(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT16)) {
prop_set_int(p, g_variant_get_uint16(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT32)) {
prop_set_int(p, g_variant_get_int32(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT32)) {
prop_set_int(p, g_variant_get_uint32(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT64)) {
int64_t val = g_variant_get_int64(v);
if(val <= INT_MAX)
prop_set_int(p, val);
else
prop_set_float(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT64)) {
uint64_t val = g_variant_get_uint64(v);
if(val <= INT_MAX)
prop_set_int(p, val);
else
prop_set_float(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_STRING) ||
g_variant_type_equal(T, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_type_equal(T, G_VARIANT_TYPE_SIGNATURE)) {
const gchar *val = g_variant_get_string(v, NULL);
prop_set_string(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_VARDICT)) {
prop_void_childs(p);
prop_set_from_vardict(v, p);
} else if(g_variant_type_is_array(T)) {
int num = g_variant_n_children(v);
prop_destroy_childs(p);
for(int i = 0; i < num; i++) {
prop_set_from_gvariant(g_variant_get_child_value(v, i),
prop_create(p, NULL));
}
} else {
fprintf(stderr,
"%s(): can't deal with type %s\n",
__FUNCTION__, g_variant_get_type_string(v));
}
}
static void
settings_changed (GSettings *settings,
gchar *key,
gpointer data)
{
GVariant *value;
const GVariantType *type;
MetaEnumPreference *cursor;
gboolean found_enum;
/* String array, handled separately */
if (strcmp (key, KEY_WORKSPACE_NAMES) == 0)
{
if (update_workspace_names ());
queue_changed (META_PREF_WORKSPACE_NAMES);
return;
}
value = g_settings_get_value (settings, key);
type = g_variant_get_type (value);
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
handle_preference_update_bool (settings, key);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
handle_preference_update_int (settings, key);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
cursor = preferences_enum;
found_enum = FALSE;
while (cursor->base.key != NULL)
{
if (strcmp (key, cursor->base.key) == 0)
found_enum = TRUE;
cursor++;
}
if (found_enum)
handle_preference_update_enum (settings, key);
else
handle_preference_update_string (settings, key);
}
else
/* Someone added a preference of an unhandled type */
g_assert_not_reached ();
g_variant_unref (value);
}
/**
* Convert a g_variant to a Scheme return value.
*/
static Scheme_Object *
g_variant_to_scheme_result (GVariant *gv)
{
const GVariantType *type; // The type of the GVariant
// Special case: Singleton tuple.
type = g_variant_get_type (gv);
if ( (g_variant_type_is_tuple (type))
&& (g_variant_n_children (gv) == 1) )
return g_variant_to_scheme_object (g_variant_get_child_value (gv, 0));
// Normal case
else
return g_variant_to_scheme_object (gv);
} // g_variant_to_scheme_result
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();
}
static gboolean
g_settings_get_mapping_unsigned_int (GValue *value,
GVariant *variant)
{
const GVariantType *type;
guint64 u;
type = g_variant_get_type (variant);
if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
u = g_variant_get_uint16 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
u = g_variant_get_uint32 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
u = g_variant_get_uint64 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
u = g_variant_get_handle (variant);
else
return FALSE;
if (G_VALUE_HOLDS_INT (value))
{
g_value_set_int (value, u);
return (u <= G_MAXINT32);
}
else if (G_VALUE_HOLDS_UINT (value))
{
g_value_set_uint (value, u);
return (u <= G_MAXUINT32);
}
else if (G_VALUE_HOLDS_INT64 (value))
{
g_value_set_int64 (value, u);
return (u <= G_MAXINT64);
}
else if (G_VALUE_HOLDS_UINT64 (value))
{
g_value_set_uint64 (value, u);
return (u <= G_MAXUINT64);
}
else if (G_VALUE_HOLDS_DOUBLE (value))
{
g_value_set_double (value, u);
return TRUE;
}
return FALSE;
}
static gboolean
check_value_type (const char *key,
GVariant *value,
const GVariantType *type,
GError **error)
{
if (g_variant_is_of_type (value, type))
return TRUE;
g_set_error (error,
XDG_DESKTOP_PORTAL_ERROR,
XDG_DESKTOP_PORTAL_ERROR_INVALID_ARGUMENT,
"expected type for key %s is %s, found %s",
key, (const char *)type, (const char *)g_variant_get_type (value));
return FALSE;
}
Variant Variant::GetVariant() const
{
Variant value;
if (!variant_)
return value;
value = get_variant(variant_);
if (!value)
{
LOG_ERROR(logger) << "You're trying to extract a 'v' from a variant which is of type '"
<< g_variant_type_peek_string(g_variant_get_type(variant_)) << "'";
}
return value;
}
static void
_compare_key_value(
gchar *key,
GVariant *value,
Data *user_data)
{
GVariant *value2 = (GVariant *)g_hash_table_lookup (user_data->table, key);
if (value2 && g_variant_get_size (value) == g_variant_get_size (value2)
&& memcmp (g_variant_get_data(value2),
g_variant_get_data(value),
g_variant_get_size(value2)) == 0
&& g_variant_is_of_type(value2, g_variant_get_type (value))) {
return;
}
user_data->status = 0;
}
