static void _dbus_geany_dbus_application_open_documents (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
GError* error;
char** filenames = NULL;
int filenames_length1;
GVariant* _tmp1_;
char** _tmp2_;
int _tmp2__length;
int _tmp2__size;
int _tmp2__length1;
GVariantIter _tmp3_;
GVariant* _tmp4_;
GVariantIter _arguments_iter;
GVariant* _reply;
GVariantBuilder _reply_builder;
error = NULL;
g_variant_iter_init (&_arguments_iter, parameters);
filenames_length1 = 0;
_tmp1_ = g_variant_iter_next_value (&_arguments_iter);
_tmp2_ = g_new (char*, 5);
_tmp2__length = 0;
_tmp2__size = 4;
_tmp2__length1 = 0;
g_variant_iter_init (&_tmp3_, _tmp1_);
for (; _tmp4_ = g_variant_iter_next_value (&_tmp3_); _tmp2__length1++) {
if (_tmp2__size == _tmp2__length) {
_tmp2__size = 2 * _tmp2__size;
_tmp2_ = g_renew (char*, _tmp2_, _tmp2__size + 1);
}
_tmp2_[_tmp2__length++] = g_variant_dup_string (_tmp4_, NULL);
g_variant_unref (_tmp4_);
}
static void _dbus_steadyflow_iapp_service_set_visible (SteadyflowIAppService* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
GError* error = NULL;
GVariantIter _arguments_iter;
gboolean visible = FALSE;
GVariant* _tmp1_;
GDBusMessage* _reply_message;
GVariant* _reply;
GVariantBuilder _reply_builder;
g_variant_iter_init (&_arguments_iter, parameters);
_tmp1_ = g_variant_iter_next_value (&_arguments_iter);
visible = g_variant_get_boolean (_tmp1_);
g_variant_unref (_tmp1_);
steadyflow_iapp_service_set_visible (self, visible, &error);
if (error) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
_reply = g_variant_builder_end (&_reply_builder);
g_dbus_message_set_body (_reply_message, _reply);
g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
g_object_unref (invocation);
g_object_unref (_reply_message);
}
gboolean
storage_remove_crypto_config (UDisksBlock *block,
GError **error)
{
GVariant *conf = udisks_block_get_configuration (block);
GVariantIter iter;
GVariant *item;
g_variant_iter_init (&iter, conf);
while ((item = g_variant_iter_next_value (&iter)))
{
const gchar *type;
g_variant_get (item, "(&s*)", &type, NULL);
if (strcmp (type, "crypttab") == 0)
{
if (!udisks_block_call_remove_configuration_item_sync (block,
item,
g_variant_new ("a{sv}", NULL),
NULL,
error))
{
g_variant_unref (item);
return FALSE;
}
g_variant_unref (item);
}
}
return TRUE;
}
static
void
mms_ofono_manager_set_modems(
MMSOfonoManager* ofono,
GVariant* modems)
{
GVariantIter iter;
GVariant* child;
MMS_DEBUG("%u modem(s) found", (guint)g_variant_n_children(modems));
g_hash_table_remove_all(ofono->modems);
for (g_variant_iter_init(&iter, modems);
(child = g_variant_iter_next_value(&iter)) != NULL;
g_variant_unref(child)) {
MMSOfonoModem* modem;
const char* path = NULL;
GVariant* properties = NULL;
g_variant_get(child, "(&o@a{sv})", &path, &properties);
MMS_ASSERT(path);
MMS_ASSERT(properties);
modem = mms_ofono_modem_new(ofono->bus, path, properties);
if (modem) g_hash_table_replace(ofono->modems, modem->path, modem);
g_variant_unref(properties);
}
}
GVariant *
g_variant_lookup_value (GVariant *dictionary,
const gchar *key,
const GVariantType *expected_type)
{
GVariantIter iter;
GVariant *entry;
GVariant *value;
g_return_val_if_fail (g_variant_is_of_type (dictionary,
G_VARIANT_TYPE ("a{s*}")) ||
g_variant_is_of_type (dictionary,
G_VARIANT_TYPE ("a{o*}")),
NULL);
g_variant_iter_init (&iter, dictionary);
while ((entry = g_variant_iter_next_value (&iter)))
{
GVariant *entry_key;
gboolean matches;
entry_key = g_variant_get_child_value (entry, 0);
matches = strcmp (g_variant_get_string (entry_key, NULL), key) == 0;
g_variant_unref (entry_key);
if (matches)
break;
g_variant_unref (entry);
}
if (entry == NULL)
return NULL;
value = g_variant_get_child_value (entry, 1);
g_variant_unref (entry);
if (g_variant_is_of_type (value, G_VARIANT_TYPE_VARIANT))
{
GVariant *tmp;
tmp = g_variant_get_variant (value);
g_variant_unref (value);
if (expected_type && !g_variant_is_of_type (tmp, expected_type))
{
g_variant_unref (tmp);
tmp = NULL;
}
value = tmp;
}
g_return_val_if_fail (expected_type == NULL || value == NULL ||
g_variant_is_of_type (value, expected_type), NULL);
return value;
}
static void
update_failures (EmpathyWebcredentialsMonitor *self)
{
GVariant *failures, *f;
GVariantIter iter;
GList *new_list = NULL;
guint i;
failures = g_dbus_proxy_get_cached_property (self->priv->proxy,
FAILURES_PROP);
if (failures == NULL)
{
g_debug ("Does not implement Failures property");
return;
}
g_variant_iter_init (&iter, failures);
while ((f = g_variant_iter_next_value (&iter)) != NULL)
{
guint32 id;
AgAccount *account;
id = g_variant_get_uint32 (f);
account = ag_manager_get_account (self->priv->manager, id);
if (account == NULL)
continue;
/* Pass ownership of 'account' to the list */
new_list = g_list_append (new_list, account);
if (!tp_g_ptr_array_contains (self->priv->failures, account))
{
g_ptr_array_add (self->priv->failures, g_object_ref (account));
g_signal_emit (self, signals[SIG_FAILURE_ADDED], 0, account);
}
g_variant_unref (f);
}
g_variant_unref (failures);
for (i = 0; i < self->priv->failures->len; i++)
{
AgAccount *account = g_ptr_array_index (self->priv->failures, i);
if (g_list_find (new_list, account) == NULL)
{
g_object_ref (account);
g_ptr_array_remove (self->priv->failures, account);
g_signal_emit (self, signals[SIG_FAILURE_REMOVED], 0, account);
g_object_unref (account);
}
}
g_list_free_full (new_list, g_object_unref);
}
static PPDName *
get_ppd_item_from_output (GVariant *output)
{
GVariant *array;
PPDName *ppd_item = NULL;
gint j;
static const char * const match_levels[] = {
"exact-cmd",
"exact",
"close",
"generic",
"none"};
if (output)
{
g_variant_get (output, "(@a(ss))", &array);
if (array)
{
GVariantIter *iter;
GVariant *item;
gchar *driver;
gchar *match;
for (j = 0; j < G_N_ELEMENTS (match_levels) && !ppd_item; j++)
{
g_variant_get (array, "a(ss)", &iter);
while ((item = g_variant_iter_next_value (iter)) && !ppd_item)
{
g_variant_get (item, "(ss)", &driver, &match);
if (g_str_equal (match, match_levels[j]))
{
ppd_item = g_new0 (PPDName, 1);
ppd_item->ppd_name = g_strdup (driver);
if (g_strcmp0 (match, "exact-cmd") == 0)
ppd_item->ppd_match_level = PPD_EXACT_CMD_MATCH;
else if (g_strcmp0 (match, "exact") == 0)
ppd_item->ppd_match_level = PPD_EXACT_MATCH;
else if (g_strcmp0 (match, "close") == 0)
ppd_item->ppd_match_level = PPD_CLOSE_MATCH;
else if (g_strcmp0 (match, "generic") == 0)
ppd_item->ppd_match_level = PPD_GENERIC_MATCH;
else if (g_strcmp0 (match, "none") == 0)
ppd_item->ppd_match_level = PPD_NO_MATCH;
}
g_free (driver);
g_free (match);
g_variant_unref (item);
}
}
g_variant_unref (array);
}
}
return ppd_item;
}
static void
storage_remove_config (StorageProvider *provider,
UDisksBlock *block,
GVariant *config)
{
GVariantIter iter;
GVariant *item;
GError *error = NULL;
gs_unref_object UDisksBlock *block_to_use = NULL;
if (block == NULL)
{
/* Any block can be used to add/remove any configuration item.
Let's hope we have at least one...
XXX - UDisks should offer a method for manipulating fstab and
crypttab on the Manager.
*/
UDisksClient *client = storage_provider_get_udisks_client (provider);
GDBusObjectManager *manager = udisks_client_get_object_manager (client);
GList *objects = g_dbus_object_manager_get_objects (manager);
for (GList *l = objects; l; l = l->next)
{
UDisksObject *object = l->data;
block_to_use = udisks_object_get_block (object);
if (block_to_use)
break;
}
g_list_free_full (objects, g_object_unref);
if (block_to_use == NULL)
{
g_warning ("Can't remove config: no block object found.");
return;
}
}
else
block_to_use = g_object_ref (block);
g_variant_iter_init (&iter, config);
while ((item = g_variant_iter_next_value (&iter)) != NULL)
{
if (!udisks_block_call_remove_configuration_item_sync (block_to_use,
item,
g_variant_new ("a{sv}", NULL),
NULL,
&error))
{
gs_free gchar *config_text = g_variant_print (config, FALSE);
g_warning ("Can't remove storage configuration '%s': %s",
config_text, error->message);
g_clear_error (&error);
}
}
}
static int
korva_control_list_devices (KorvaController1 *proxy)
{
GVariant *devices, *dict, *value;
char *key;
GVariantIter *outer, *inner;
GError *error = NULL;
korva_controller1_call_get_devices_sync (proxy,
&devices,
NULL,
&error);
if (error != NULL) {
g_print ("Could not get device list: %s\n", error->message);
g_error_free (error);
return 1;
}
outer = g_variant_iter_new (devices);
dict = g_variant_iter_next_value (outer);
while (dict != NULL) {
g_print ("Device:\n");
inner = g_variant_iter_new (dict);
while (g_variant_iter_next (inner, "{sv}", &key, &value)) {
if (strcmp (key, "UID") == 0 ||
strcmp (key, "DisplayName") == 0) {
g_print (" %s: %s\n", key, g_variant_get_string (value, NULL));
}
g_free (key);
g_variant_unref (value);
}
g_variant_iter_free (inner);
g_variant_unref (dict);
dict = g_variant_iter_next_value (outer);
}
g_variant_iter_free (outer);
return 0;
}
void preferences_load (Preferences* self) {
IBusConfig* _tmp0_;
GVariant* _tmp1_ = NULL;
GVariant* _tmp2_;
GVariant* values;
GVariant* _tmp3_;
g_return_if_fail (self != NULL);
_tmp0_ = self->priv->config;
_tmp1_ = ibus_config_get_values (_tmp0_, "engine/skk");
_tmp2_ = _g_variant_ref0 (_tmp1_);
values = _tmp2_;
_tmp3_ = values;
if (_tmp3_ != NULL) {
GVariant* _tmp4_;
GVariantIter* _tmp5_ = NULL;
GVariantIter* iter;
GVariant* entry;
_tmp4_ = values;
_tmp5_ = g_variant_iter_new (_tmp4_);
iter = _tmp5_;
entry = NULL;
while (TRUE) {
GVariantIter* _tmp6_;
GVariant* _tmp7_ = NULL;
GVariant* _tmp8_;
gchar* name = NULL;
GVariant* value = NULL;
GVariant* _tmp9_;
GeeMap* _tmp10_;
const gchar* _tmp11_;
GVariant* _tmp12_;
_tmp6_ = iter;
_tmp7_ = g_variant_iter_next_value (_tmp6_);
_g_variant_unref0 (entry);
entry = _tmp7_;
_tmp8_ = entry;
if (!(_tmp8_ != NULL)) {
break;
}
_tmp9_ = entry;
g_variant_get (_tmp9_, "{sv}", &name, &value, NULL);
_tmp10_ = self->priv->current;
_tmp11_ = name;
_tmp12_ = value;
gee_map_set (_tmp10_, _tmp11_, _tmp12_);
_g_variant_unref0 (value);
_g_free0 (name);
}
_g_variant_unref0 (entry);
_g_variant_iter_free0 (iter);
}
_g_variant_unref0 (values);
}
static void
on_flash_progress(GDBusConnection* connection,
const gchar* sender_name,
const gchar* object_path,
const gchar* interface_name,
const gchar* signal_name,
GVariant* parameters,
gpointer user_data)
{
Flash *flash = object_get_flash((Object*)user_data);
object_get_shared_resource((Object*)user_data);
GVariantIter *iter = g_variant_iter_new(parameters);
g_variant_iter_next_value(iter);
GVariant* v_progress = g_variant_iter_next_value(iter);
uint8_t progress = g_variant_get_byte(v_progress);
gchar *s;
s = g_strdup_printf("Flashing: %d%%",progress);
flash_set_status(flash,s);
g_free(s);
}
static gboolean
x11_fd_dispatch(GSource* source, GSourceFunc callback, gpointer user_data)
{
Display *dpy = ((x11_source_t*)source)->dpy;
XEvent e;
while (XPending(dpy))
{
XNextEvent(dpy, &e);
if (e.type == KeyPress)
{
// g_print("KeyPress!!!\n");
static const gchar *names[64] = {0};
names[0] = "xkb:us::eng";
static int inited = 0;
if (!inited)
{
IBusConfig *config = ibus_bus_get_config (bus);
GVariant *engines = ibus_config_get_value (config, "general", "preload-engines");
if (!engines)
continue;
int i = 1;
GVariantIter iter;
GVariant *child;
g_variant_iter_init (&iter, engines);
while ((child = g_variant_iter_next_value (&iter)) != NULL) {
const gchar *engine_name = g_variant_get_string (child, NULL);
// g_print("engine_name %s\n", engine_name);
names[i] = engine_name;
i++;
g_variant_unref (child);
}
inited = 1;
}
static int n = 0;
n = n==0? 1 : 0;
ibus_bus_set_global_engine(bus, names[n]);
}
}
return TRUE;
}
static GVariant *
_get_session_property (
GDBusProxy *proxy,
const gchar *object_path,
const gchar *prop_key)
{
GError *error = NULL;
GVariant *result = NULL;
GVariant *prop_value = NULL;
result = g_dbus_connection_call_sync (
g_dbus_proxy_get_connection (proxy),
g_dbus_proxy_get_name (proxy),
object_path,
"org.freedesktop.DBus.Properties",
"GetAll",
g_variant_new ("(s)", "org.freedesktop.login1.Session"),
G_VARIANT_TYPE ("(a{sv})"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error) {
printf ("Failed with error %d:%s", error->code, error->message);
g_error_free (error);
error = NULL;
return NULL;
}
if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(a{sv})"))) {
GVariantIter *iter = NULL;
GVariant *item = NULL;
g_variant_get (result, "(a{sv})", &iter);
while ((item = g_variant_iter_next_value (iter))) {
gchar *key;
GVariant *value;
g_variant_get (item, "{sv}", &key, &value);
if (g_strcmp0 (key, prop_key) == 0) {
prop_value = value;
g_free (key); key = NULL;
break;
}
g_free (key); key = NULL;
g_variant_unref (value); value = NULL;
}
}
g_variant_unref (result);
return prop_value;
}
static void
gvariant_foreach (GVariant *variant,
GVariantForeachFunc func,
gpointer user_data)
{
GVariantIter iter;
GVariant *variant_child;
g_variant_iter_init (&iter, variant);
while ((variant_child = g_variant_iter_next_value (&iter)) != NULL)
{
func (variant_child, user_data);
g_variant_unref (variant_child);
}
}
static void
get_missing_executables_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *output;
IMEData *data = (IMEData *) user_data;
GError *error = NULL;
GList *executables = NULL;
GList *item;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
&error);
if (output)
{
GVariant *array;
g_variant_get (output, "(@as)", &array);
if (array)
{
GVariantIter *iter;
GVariant *item;
gchar *executable;
g_variant_get (array, "as", &iter);
while ((item = g_variant_iter_next_value (iter)))
{
g_variant_get (item, "s", &executable);
executables = g_list_append (executables, executable);
g_variant_unref (item);
}
g_variant_unref (array);
}
g_variant_unref (output);
}
else if (error->domain == G_DBUS_ERROR &&
(error->code == G_DBUS_ERROR_SERVICE_UNKNOWN ||
error->code == G_DBUS_ERROR_UNKNOWN_METHOD))
{
g_warning ("Install system-config-printer which provides \
DBus method \"MissingExecutables\" to find missing executables and filters.");
g_error_free (error);
}
/* ---------------------------------------------------------------------------------------------------- */
int get_object(GDBusProxy *proxy, GPIO* gpio, object_info* obj_info)
{
g_print("Checking Presence: %s\n",gpio->name);
GError *error;
GVariant *parm;
GVariant *result;
error = NULL;
parm = g_variant_new("(ss)","GPIO_PRESENT",gpio->name);
result = g_dbus_proxy_call_sync (proxy,
"getObjectFromId",
parm,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
g_assert_no_error (error);
const gchar* bus_name;
const gchar* obj_path;
gsize bus_name_size;
gsize obj_path_size;
GVariantIter *iter = g_variant_iter_new(result);
GVariant* dict = g_variant_iter_next_value(iter);
GVariant* b = g_variant_lookup_value(dict,"bus_name",(const GVariantType *) "s");
bus_name = g_variant_get_string(b,&bus_name_size);
GVariant* o = g_variant_lookup_value(dict,"obj_path",(const GVariantType *) "s");
obj_path = g_variant_get_string(o,&obj_path_size);
int rc = 0;
if (bus_name_size == 0 || obj_path_size == 0) {
g_print("ERROR: gpio %s not found in lookup\n",gpio->name);
rc = 1;
} else {
obj_info->bus_name = bus_name;
obj_info->path = obj_path;
}
g_variant_unref(b);
g_variant_unref(o);
g_variant_unref(dict);
g_variant_unref(result);
return rc;
}
static void
build_json_dictionary (JsonBuilder *builder,
const GVariantType *entry_type,
GVariant *dict)
{
const GVariantType *key_type;
GVariantIter iter;
GVariant *child;
GVariant *key;
GVariant *value;
gboolean is_string;
gchar *key_string;
json_builder_begin_object (builder);
key_type = g_variant_type_key (entry_type);
is_string = (g_variant_type_equal (key_type, G_VARIANT_TYPE_STRING) ||
g_variant_type_equal (key_type, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_type_equal (key_type, G_VARIANT_TYPE_SIGNATURE));
g_variant_iter_init (&iter, dict);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
key = g_variant_get_child_value (child, 0);
value = g_variant_get_child_value (child, 1);
if (is_string)
{
json_builder_set_member_name (builder, g_variant_get_string (key, NULL));
}
else
{
key_string = g_variant_print (key, FALSE);
json_builder_set_member_name (builder, key_string);
g_free (key_string);
}
build_json (builder, value);
g_variant_unref (key);
g_variant_unref (value);
}
json_builder_end_object (builder);
}
void DeviceOptions::bind_enum(const QString &name, int key,
GVariant *const gvar_list, boost::function<QString (GVariant*)> printer)
{
GVariant *gvar;
GVariantIter iter;
vector< pair<GVariant*, QString> > values;
assert(gvar_list);
g_variant_iter_init (&iter, gvar_list);
while ((gvar = g_variant_iter_next_value (&iter)))
values.push_back(make_pair(gvar, printer(gvar)));
_properties.push_back(boost::shared_ptr<Property>(
new Enum(name, values,
bind(config_getter, _sdi, key),
bind(config_setter, _sdi, key, _1))));
}
static void
build_json_array_or_tuple (JsonBuilder *builder,
GVariant *value)
{
GVariantIter iter;
GVariant *child;
json_builder_begin_array (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
build_json (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
}
static void _dbus_geany_dbus_application_open_document (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
GError* error;
char* filename = NULL;
GVariant* _tmp0_;
gboolean result;
GVariantIter _arguments_iter;
GVariant* _reply;
GVariantBuilder _reply_builder;
error = NULL;
g_variant_iter_init (&_arguments_iter, parameters);
_tmp0_ = g_variant_iter_next_value (&_arguments_iter);
filename = g_variant_dup_string (_tmp0_, NULL);
g_variant_unref (_tmp0_);
result = geany_dbus_application_open_document (self, filename);
g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
_g_free0 (filename);
g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
_reply = g_variant_builder_end (&_reply_builder);
g_dbus_method_invocation_return_value (invocation, _reply);
}
void
gsearchtool_set_columns_order (GtkTreeView * treeview)
{
GtkTreeViewColumn * last = NULL;
GSettings * settings;
GVariant * value;
settings = g_settings_new ("org.mate.search-tool");
value = g_settings_get_value (settings, "columns-order");
if (value) {
GVariantIter *iter;
GVariant *item;
g_variant_get (value, "ai", &iter);
while ((item = g_variant_iter_next_value (iter))) {
GtkTreeViewColumn * cur;
gint id;
g_variant_get (item, "i", &id);
if (id >= 0 && id < NUM_COLUMNS) {
cur = gsearchtool_gtk_tree_view_get_column_with_sort_column_id (treeview, id);
if (cur && cur != last) {
gtk_tree_view_move_column_after (treeview, cur, last);
last = cur;
}
}
g_variant_unref (item);
}
g_variant_iter_free (iter);
g_variant_unref (value);
}
g_object_unref (settings);
}
void DeviceOptions::bind_enum(const QString &name, int key,
GVariant *const gvar_list, Property::Getter getter,
Property::Setter setter, function<QString (GVariant*)> printer)
{
GVariant *gvar;
GVariantIter iter;
vector< pair<GVariant*, QString> > values;
assert(_dev_inst);
if (!gvar_list) {
qDebug() << "Config key " << key << " was listed, but no "
"options were given";
return;
}
g_variant_iter_init (&iter, gvar_list);
while ((gvar = g_variant_iter_next_value (&iter)))
values.push_back(make_pair(gvar, printer(gvar)));
_properties.push_back(shared_ptr<Property>(new Enum(name, values,
getter, setter)));
}
gboolean
_g_dbus_gvariant_to_dbus_1 (DBusMessage *message,
GVariant *value,
GError **error)
{
gboolean ret;
guint n;
ret = FALSE;
if (value != NULL)
{
DBusMessageIter iter;
GVariantIter gv_iter;
GVariant *item;
dbus_message_iter_init_append (message, &iter);
g_variant_iter_init (&gv_iter, value);
n = 0;
while ((item = g_variant_iter_next_value (&gv_iter)))
{
if (!dconf_dbus_from_gv (&iter, item, error))
{
g_prefix_error (error,
_("Error encoding in-arg %d: "),
n);
goto out;
}
n++;
}
}
ret = TRUE;
out:
return ret;
}
QVariantList QGSettings::choices(const QString &key) const
{
Q_D(const QGSettings);
QVariantList choices;
if (!d->valid)
return choices;
gchar *keyName = Utils::fromCamelCase(key);
GSettingsSchemaKey *schemaKey = g_settings_schema_get_key(d->schema, keyName);
GVariant *range = g_settings_schema_key_get_range(schemaKey);
g_settings_schema_key_unref(schemaKey);
g_free(keyName);
if (!range)
return choices;
const gchar *type;
GVariant *value;
g_variant_get(range, "(&sv)", &type, &value);
if (g_str_equal(type, "enum")) {
GVariantIter iter;
g_variant_iter_init(&iter, value);
GVariant *child;
while ((child = g_variant_iter_next_value(&iter))) {
choices.append(Utils::toQVariant(child));
g_variant_unref(child);
}
}
g_variant_unref(value);
g_variant_unref(range);
return choices;
}
static void
on_connection_signal (GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
CockpitDBusJson *self = user_data;
gs_unref_object JsonBuilder *builder = prepare_builder ("interface-signal");
GVariantIter iter;
GVariant *child;
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "objpath");
json_builder_add_string_value (builder, object_path);
json_builder_set_member_name (builder, "iface_name");
json_builder_add_string_value (builder, interface_name);
json_builder_set_member_name (builder, "signal_name");
json_builder_add_string_value (builder, signal_name);
json_builder_set_member_name (builder, "args");
json_builder_begin_array (builder);
g_variant_iter_init (&iter, parameters);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
build_json (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
json_builder_end_object (builder);
write_builder (self, builder);
}
static void
on_interface_proxy_signal (GDBusObjectManager *manager,
GDBusObjectProxy *object_proxy,
GDBusProxy *interface_proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
CockpitDBusJson1 *self = user_data;
cleanup_unref_object JsonBuilder *builder = prepare_builder ("interface-signal");
GVariantIter iter;
GVariant *child;
json_builder_begin_object (builder);
json_builder_set_member_name (builder, "objpath");
json_builder_add_string_value (builder, g_dbus_object_get_object_path (G_DBUS_OBJECT (object_proxy)));
json_builder_set_member_name (builder, "iface_name");
json_builder_add_string_value (builder, g_dbus_proxy_get_interface_name (interface_proxy));
json_builder_set_member_name (builder, "signal_name");
json_builder_add_string_value (builder, signal_name);
json_builder_set_member_name (builder, "args");
json_builder_begin_array (builder);
g_variant_iter_init (&iter, parameters);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
json_builder_end_object (builder);
write_builder (self, builder);
}
/**
* cockpit_fake_manager_scrape:
* @self: a fake manager
* @variant: a variant to scrape
*
* Get all object paths out of the variant in question
* (which is usually the parameters to a signal) and
* try and poke those object paths.
*/
void
cockpit_fake_manager_scrape (CockpitFakeManager *self,
GVariant *variant)
{
GVariantIter iter;
GVariant *child;
const gchar *path;
if (g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH))
{
path = g_variant_get_string (variant, NULL);
if (!g_str_equal (path, "/"))
cockpit_fake_manager_poke (self, path);
}
else if (g_variant_is_container (variant))
{
g_variant_iter_init (&iter, variant);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
cockpit_fake_manager_scrape (self, child);
g_variant_unref (child);
}
}
}
void
rpmostree_print_package_diffs (GVariant *variant)
{
GQueue queue = G_QUEUE_INIT;
GVariantIter iter;
GVariant *child;
/* GVariant format should be a(sua{sv}) */
g_return_if_fail (variant != NULL);
g_variant_iter_init (&iter, variant);
/* Queue takes ownership of the child variant. */
while ((child = g_variant_iter_next_value (&iter)) != NULL)
g_queue_insert_sorted (&queue, child, pkg_diff_variant_compare, NULL);
while (!g_queue_is_empty (&queue))
{
child = g_queue_pop_head (&queue);
pkg_diff_variant_print (child);
g_variant_unref (child);
}
}
static JsonBuilder *
_json_builder_add_gvariant (JsonBuilder *builder,
GVariant *value)
{
g_return_val_if_fail (JSON_IS_BUILDER (builder), builder);
g_variant_ref_sink (value);
switch (g_variant_classify (value))
{
case G_VARIANT_CLASS_BOOLEAN:
json_builder_add_boolean_value (builder, g_variant_get_boolean (value));
break;
case G_VARIANT_CLASS_BYTE:
json_builder_add_int_value (builder, g_variant_get_byte (value));
break;
case G_VARIANT_CLASS_INT16:
json_builder_add_int_value (builder, g_variant_get_int16 (value));
break;
case G_VARIANT_CLASS_UINT16:
json_builder_add_int_value (builder, g_variant_get_uint16 (value));
break;
case G_VARIANT_CLASS_INT32:
json_builder_add_int_value (builder, g_variant_get_int32 (value));
break;
case G_VARIANT_CLASS_UINT32:
json_builder_add_int_value (builder, g_variant_get_uint32 (value));
break;
case G_VARIANT_CLASS_INT64:
json_builder_add_int_value (builder, g_variant_get_int64 (value));
break;
case G_VARIANT_CLASS_UINT64:
json_builder_add_int_value (builder, g_variant_get_uint64 (value));
break;
case G_VARIANT_CLASS_HANDLE:
json_builder_add_int_value (builder, g_variant_get_handle (value));
break;
case G_VARIANT_CLASS_DOUBLE:
json_builder_add_double_value (builder, g_variant_get_double (value));
break;
case G_VARIANT_CLASS_STRING: /* explicit fall-through */
case G_VARIANT_CLASS_OBJECT_PATH: /* explicit fall-through */
case G_VARIANT_CLASS_SIGNATURE:
json_builder_add_string_value (builder, g_variant_get_string (value, NULL));
break;
/* TODO: */
case G_VARIANT_CLASS_VARIANT:
{
GVariant *child;
child = g_variant_get_variant (value);
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
break;
case G_VARIANT_CLASS_MAYBE:
g_assert_not_reached ();
break;
case G_VARIANT_CLASS_ARRAY:
{
const GVariantType *type;
const GVariantType *element_type;
type = g_variant_get_type (value);
element_type = g_variant_type_element (type);
if (g_variant_type_is_dict_entry (element_type))
{
GVariantIter iter;
GVariant *child;
json_builder_begin_object (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_object (builder);
}
else
{
GVariantIter iter;
GVariant *child;
json_builder_begin_array (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
}
}
break;
case G_VARIANT_CLASS_TUPLE:
{
GVariantIter iter;
GVariant *child;
json_builder_begin_array (builder);
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
_json_builder_add_gvariant (builder, child);
g_variant_unref (child);
}
json_builder_end_array (builder);
}
break;
case G_VARIANT_CLASS_DICT_ENTRY:
{
GVariant *dict_key;
GVariant *dict_value;
gchar *dict_key_string;
dict_key = g_variant_get_child_value (value, 0);
dict_value = g_variant_get_child_value (value, 1);
if (g_variant_is_of_type (dict_key, G_VARIANT_TYPE("s")))
dict_key_string = g_variant_dup_string (dict_key, NULL);
else
dict_key_string = g_variant_print (dict_key, FALSE);
json_builder_set_member_name (builder, dict_key_string);
_json_builder_add_gvariant (builder, dict_value);
g_free (dict_key_string);
g_variant_unref (dict_key);
g_variant_unref (dict_value);
}
break;
}
g_variant_unref (value);
return builder;
}
/* Returns a new floating variant (essentially a fixed-up copy of @value) */
static GVariant *
_my_replace (GVariant *value)
{
GVariant *ret;
const gchar *dbus_type;
if (g_variant_is_of_type (value, G_VARIANT_TYPE_VARDICT) &&
g_variant_lookup (value, "_dbus_type", "&s", &dbus_type))
{
GVariant *passed_value;
passed_value = g_variant_lookup_value (value, "value", NULL);
if (passed_value != NULL)
{
JsonNode *serialized;
GError *error;
serialized = json_gvariant_serialize (passed_value);
error = NULL;
ret = json_gvariant_deserialize (serialized,
dbus_type,
&error);
json_node_free (serialized);
if (ret == NULL)
{
/*
* HACK: Work around bug in JSON-glib, see:
* https://bugzilla.gnome.org/show_bug.cgi?id=724319
*/
if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_INVALID_DATA &&
g_variant_is_of_type (passed_value, G_VARIANT_TYPE_INT64) &&
g_strcmp0 (dbus_type, "d") == 0)
{
ret = g_variant_new_double (g_variant_get_int64 (passed_value));
g_clear_error (&error);
}
else
{
g_warning ("Error converting JSON to requested type %s: %s (%s, %d)",
dbus_type,
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
ret = g_variant_ref (value);
}
}
}
else
{
g_warning ("Malformed _dbus_type vardict");
ret = g_variant_ref (value);
}
}
else if (g_variant_is_container (value))
{
GVariantBuilder builder;
GVariantIter iter;
GVariant *child;
g_variant_builder_init (&builder, g_variant_get_type (value));
g_variant_iter_init (&iter, value);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
g_variant_builder_add_value (&builder, _my_replace (child));
g_variant_unref (child);
}
ret = g_variant_builder_end (&builder);
}
else
{
ret = g_variant_ref (value);
}
return ret;
}
