static void _fcitx_client_g_signal(GDBusProxy *proxy, gchar *sender_name, gchar *signal_name, GVariant *parameters, gpointer user_data) { FCITX_UNUSED(proxy); FCITX_UNUSED(sender_name); if (strcmp(signal_name, "EnableIM") == 0) { g_signal_emit(user_data, signals[ENABLE_IM_SIGNAL], 0); } else if (strcmp(signal_name, "CloseIM") == 0) { g_signal_emit(user_data, signals[CLOSE_IM_SIGNAL], 0); } else if (strcmp(signal_name, "CommitString") == 0) { const gchar* data = NULL; g_variant_get(parameters, "(s)", &data); if (data) { g_signal_emit(user_data, signals[COMMIT_STRING_SIGNAL], 0, data); } } else if (strcmp(signal_name, "ForwardKey") == 0) { guint32 key, state; gint32 type; g_variant_get(parameters, "(uui)", &key, &state, &type); g_signal_emit(user_data, signals[FORWARD_KEY_SIGNAL], 0, key, state, type); } else if (strcmp(signal_name, "DeleteSurroundingText") == 0) { guint32 nchar; gint32 offset; g_variant_get(parameters, "(iu)", &offset, &nchar); g_signal_emit(user_data, signals[DELETE_SURROUNDING_TEXT_SIGNAL], 0, offset, nchar); } else if (strcmp(signal_name, "UpdateClientSideUI") == 0) { const gchar* auxup, *auxdown, *preedit, *candidate, *imname; int cursor; g_variant_get(parameters, "(sssssi)", &auxup, &auxdown, &preedit, &candidate, &imname, &cursor); g_signal_emit(user_data, signals[UPDATE_CLIENT_SIDE_UI_SIGNAL], 0, auxup, auxdown, preedit, candidate, imname, cursor); } else if (strcmp(signal_name, "UpdateFormattedPreedit") == 0) { int cursor_pos; GPtrArray* array = g_ptr_array_new_with_free_func(_item_free); GVariantIter* iter; g_variant_get(parameters, "(a(si)i)", &iter, &cursor_pos); gchar* string; int type; while (g_variant_iter_next(iter, "(si)", &string, &type, NULL)) { FcitxPreeditItem* item = g_malloc0(sizeof(FcitxPreeditItem)); item->string = strdup(string); item->type = type; g_ptr_array_add(array, item); g_free(string); } g_variant_iter_free(iter); g_signal_emit(user_data, signals[UPDATED_FORMATTED_PREEDIT_SIGNAL], 0, array, cursor_pos); g_ptr_array_free(array, TRUE); } }
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 gboolean do_print_related (OstreeRepo *repo, const char *rev, const char *resolved_rev, GError **error) { gboolean ret = FALSE; const char *name; gs_unref_variant GVariant *csum_v = NULL; gs_unref_variant GVariant *variant = NULL; gs_unref_variant GVariant *related = NULL; GVariantIter *viter = NULL; if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, resolved_rev, &variant, error)) goto out; /* PARSE OSTREE_SERIALIZED_COMMIT_VARIANT */ related = g_variant_get_child_value (variant, 2); viter = g_variant_iter_new (related); while (g_variant_iter_loop (viter, "(&s@ay)", &name, &csum_v)) { gs_free char *checksum = ostree_checksum_from_bytes_v (csum_v); g_print ("%s %s\n", name, checksum); } csum_v = NULL; ret = TRUE; out: if (viter) g_variant_iter_free (viter); return ret; }
static Login1Seat * add_seat (Login1Service *service, const gchar *id, const gchar *path) { Login1Seat *seat; GVariant *result; GError *error = NULL; seat = g_object_new (LOGIN1_SEAT_TYPE, NULL); seat->priv->connection = g_object_ref (service->priv->connection); seat->priv->id = g_strdup (id); seat->priv->path = g_strdup (path); seat->priv->signal_id = g_dbus_connection_signal_subscribe (seat->priv->connection, LOGIN1_SERVICE_NAME, "org.freedesktop.DBus.Properties", "PropertiesChanged", path, "org.freedesktop.login1.Seat", G_DBUS_SIGNAL_FLAGS_NONE, seat_properties_changed_cb, g_object_ref (seat), g_object_unref); /* Get properties for this seat */ result = g_dbus_connection_call_sync (seat->priv->connection, LOGIN1_SERVICE_NAME, path, "org.freedesktop.DBus.Properties", "GetAll", g_variant_new ("(s)", "org.freedesktop.login1.Seat"), G_VARIANT_TYPE ("(a{sv})"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) g_warning ("Failed to get seat properties: %s", error->message); g_clear_error (&error); if (result) { GVariantIter *properties; const gchar *name; GVariant *value; g_variant_get (result, "(a{sv})", &properties); while (g_variant_iter_loop (properties, "{&sv}", &name, &value)) { if (strcmp (name, "CanGraphical") == 0 && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN)) seat->priv->can_graphical = g_variant_get_boolean (value); else if (strcmp (name, "CanMultiSession") == 0 && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN)) seat->priv->can_multi_session = g_variant_get_boolean (value); } g_variant_iter_free (properties); g_variant_unref (result); } service->priv->seats = g_list_append (service->priv->seats, seat); return seat; }
/** * tracker_miner_manager_get_running: * @manager: a #trackerMinerManager * * Returns a list of references for all active miners. Active miners * are miners which are running within a process. * * Returns: (transfer full) (element-type utf8): a #GSList which must * be freed with g_slist_free() and all contained data with g_free(). * Otherwise %NULL is returned if there are no miners. * * Since: 0.8 **/ GSList * tracker_miner_manager_get_running (TrackerMinerManager *manager) { TrackerMinerManagerPrivate *priv; GSList *list = NULL; GError *error = NULL; GVariant *v; GVariantIter *iter; const gchar *str = NULL; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), NULL); priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager); if (!priv->connection) { return NULL; } v = g_dbus_connection_call_sync (priv->connection, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames", NULL, G_VARIANT_TYPE ("(as)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_critical ("Could not get a list of names registered on the session bus, %s", error ? error->message : "no error given"); g_clear_error (&error); return NULL; } g_variant_get (v, "(as)", &iter); while (g_variant_iter_loop (iter, "&s", &str)) { if (!g_str_has_prefix (str, TRACKER_MINER_DBUS_NAME_PREFIX)) { continue; } /* Special case miner-fs which has * additional D-Bus interface. */ if (strcmp (str, "org.freedesktop.Tracker1.Miner.Files.Index") == 0) { continue; } list = g_slist_prepend (list, g_strdup (str)); } g_variant_iter_free (iter); g_variant_unref (v); list = g_slist_reverse (list); return list; }
void on_menu_changed(gpointer instance, GVariant *parameters, gpointer user_data) { WorkraveApplet *applet = WORKRAVE_APPLET(user_data); GVariantIter *iter; g_variant_get (parameters, "(a(sii))", &iter); char *text; int id; int flags; gboolean visible[sizeof(menu_data)/sizeof(struct Menuitems)]; for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++) { visible[i] = menu_data[i].visible_when_not_running; } while (g_variant_iter_loop(iter, "(sii)", &text, &id, &flags)) { int index = lookup_menu_index_by_id((enum MenuCommand)id); if (index == -1) { continue; } GAction *action = g_action_map_lookup_action(G_ACTION_MAP(applet->priv->action_group), menu_data[index].action); if (flags & MENU_ITEM_FLAG_SUBMENU_END || flags & MENU_ITEM_FLAG_SUBMENU_BEGIN) { continue; } visible[index] = TRUE; if (g_action_get_state_type(G_ACTION(action)) != NULL) { if (menu_data[index].state == NULL) { g_simple_action_set_state(G_SIMPLE_ACTION(action), g_variant_new_boolean(flags & MENU_ITEM_FLAG_ACTIVE)); } else { if (flags & MENU_ITEM_FLAG_ACTIVE) { g_simple_action_set_state(G_SIMPLE_ACTION(action), g_variant_new_string(menu_data[index].state)); } } } } g_variant_iter_free (iter); for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++) { GAction *action = g_action_map_lookup_action(G_ACTION_MAP(applet->priv->action_group), menu_data[i].action); g_simple_action_set_enabled(G_SIMPLE_ACTION(action), visible[i]); } }
GVariant* GnomeGrabber::Impl::onShellMethodCall(std::string const& method, GVariant* parameters) { LOG_DEBUG(logger) << "Called method '" << method << "'"; if (method == "GrabAccelerators") { if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(a(su))"))) { GVariant* variant; GVariantBuilder builder; GVariantIter* iterator; gchar const* accelerator; guint flags; g_variant_builder_init(&builder, G_VARIANT_TYPE("au")); g_variant_get(parameters, "(a(su))", &iterator); while (g_variant_iter_next(iterator, "(&su)", &accelerator, &flags)) g_variant_builder_add(&builder, "u", grabAccelerator(accelerator, flags)); g_variant_iter_free(iterator); variant = g_variant_builder_end(&builder); return g_variant_new_tuple(&variant, 1); } else LOG_WARN(logger) << "Expected arguments of type (a(su))"; } else if (method == "GrabAccelerator") { if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(su)"))) { GVariant* variant; gchar const* accelerator; guint flags; g_variant_get(parameters, "(&su)", &accelerator, &flags); variant = g_variant_new_uint32(grabAccelerator(accelerator, flags)); return g_variant_new_tuple(&variant, 1); } else LOG_WARN(logger) << "Expected arguments of type (su)"; } else if (method == "UngrabAccelerator") { if (g_variant_is_of_type(parameters, G_VARIANT_TYPE("(u)"))) { GVariant* variant; guint action; g_variant_get(parameters, "(u)", &action); variant = g_variant_new_boolean(removeAction(action)); return g_variant_new_tuple(&variant, 1); } else LOG_WARN(logger) << "Expected arguments of type (u)"; } return nullptr; }
void Peer::handle_property_change (const char *name, GVariant *property) { if (g_strcmp0(name, "State") == 0) { state_changed (g_variant_get_string (property, NULL)); } else if (g_strcmp0(name, "Name") == 0) { name_changed (g_variant_get_string (property, NULL)); } else if (g_strcmp0(name, "Services") == 0) { GVariantIter *service_array, *services; GVariant *spec_val; g_variant_get (property, "a(a{sv})", &service_array); while (g_variant_iter_loop (service_array, "(a{sv})", &services)) { const char *service_name; while (g_variant_iter_loop (services, "{sv}", &service_name, &spec_val)) { if (g_strcmp0 (service_name, "WiFiDisplayIEs") == 0) { uint8_t *bytes; gsize length; bytes = (uint8_t*)g_variant_get_fixed_array (spec_val, &length, 1); std::unique_ptr<P2P::InformationElementArray> array (new P2P::InformationElementArray(length, bytes)); ie_.reset(new P2P::InformationElement (array)); } } } g_variant_iter_free (service_array); } else if (g_strcmp0(name, "IPv4") == 0) { GVariantIter *ips; GVariant *spec_val; char *name; const char *remote = ""; const char *local = ""; g_variant_get (property, "a{sv}", &ips); while (g_variant_iter_loop (ips, "{sv}", &name, &spec_val)) { if (g_strcmp0 (name, "Remote") == 0) { remote = g_variant_get_string (spec_val, NULL); } else if (g_strcmp0 (name, "Local") == 0) { local = g_variant_get_string (spec_val, NULL); } } ips_changed (remote, local); g_variant_iter_free (ips); } }
gboolean login1_service_connect (Login1Service *service) { GVariant *result; GVariantIter *seat_iter; const gchar *id, *path; GError *error = NULL; g_return_val_if_fail (service != NULL, FALSE); if (service->priv->connected) return TRUE; service->priv->connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error); if (error) g_warning ("Failed to get system bus: %s", error->message); g_clear_error (&error); if (!service->priv->connection) return FALSE; service->priv->signal_id = g_dbus_connection_signal_subscribe (service->priv->connection, LOGIN1_SERVICE_NAME, LOGIN1_MANAGER_INTERFACE_NAME, NULL, LOGIN1_OBJECT_NAME, NULL, G_DBUS_SIGNAL_FLAGS_NONE, signal_cb, g_object_ref (service), g_object_unref); result = g_dbus_connection_call_sync (service->priv->connection, LOGIN1_SERVICE_NAME, LOGIN1_OBJECT_NAME, LOGIN1_MANAGER_INTERFACE_NAME, "ListSeats", g_variant_new ("()"), G_VARIANT_TYPE ("(a(so))"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) g_warning ("Failed to get list of logind seats: %s", error->message); g_clear_error (&error); if (!result) return FALSE; g_variant_get (result, "(a(so))", &seat_iter); while (g_variant_iter_loop (seat_iter, "(&s&o)", &id, &path)) add_seat (service, id, path); g_variant_iter_free (seat_iter); g_variant_unref (result); service->priv->connected = TRUE; return TRUE; }
static OlLyricSourceCandidate * ol_lyric_source_candidate_new_with_variant (GVariant *dict) { ol_log_func (); OlLyricSourceCandidate *candidate = NULL; GVariantIter *dictiter = NULL; gchar *key = NULL; gchar *title, *artist, *album, *comment, *sourceid; GVariant *downloadinfo = NULL; GVariant *value = NULL; title = artist = album = comment = sourceid = NULL; g_variant_get (dict, "a{sv}", &dictiter); while (g_variant_iter_loop (dictiter, "{sv}", &key, &value)) { if (strcmp (key, "title") == 0 && title == NULL) { title = g_variant_dup_string (value, NULL); } else if (strcmp (key, "artist") == 0 && artist == NULL) { artist = g_variant_dup_string (value, NULL); } else if (strcmp (key, "album") == 0 && album == NULL) { album = g_variant_dup_string (value, NULL); } else if (strcmp (key, "comment") == 0 && comment == NULL) { comment = g_variant_dup_string (value, NULL); } else if (strcmp (key, "sourceid") == 0 && sourceid == NULL) { sourceid = g_variant_dup_string (value, NULL); } else if (strcmp (key, "downloadinfo") == 0 && downloadinfo == NULL) { downloadinfo = g_variant_ref (value); } else { ol_errorf ("Unknown candidate key: %s\n", key); } } g_variant_iter_free (dictiter); candidate = ol_lyric_source_candidate_new (title, artist, album, comment, sourceid, downloadinfo); g_free (title); g_free (artist); g_free (album); g_free (comment); g_free (sourceid); g_variant_unref (downloadinfo); return candidate; }
static gboolean scan_commit_object (OtPullData *pull_data, const char *checksum, guint recursion_depth, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gs_unref_variant GVariant *commit = NULL; gs_unref_variant GVariant *tree_contents_csum = NULL; gs_unref_variant GVariant *tree_meta_csum = NULL; GVariantIter *iter = NULL; if (recursion_depth > OSTREE_MAX_RECURSION) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Exceeded maximum recursion"); goto out; } #ifdef HAVE_GPGME if (pull_data->gpg_verify) { if (!ostree_repo_verify_commit (pull_data->repo, checksum, NULL, NULL, cancellable, error)) goto out; } #endif if (!ostree_repo_load_variant (pull_data->repo, OSTREE_OBJECT_TYPE_COMMIT, checksum, &commit, error)) goto out; /* PARSE OSTREE_SERIALIZED_COMMIT_VARIANT */ g_variant_get_child (commit, 6, "@ay", &tree_contents_csum); g_variant_get_child (commit, 7, "@ay", &tree_meta_csum); if (!scan_one_metadata_object (pull_data, ostree_checksum_bytes_peek (tree_contents_csum), OSTREE_OBJECT_TYPE_DIR_TREE, recursion_depth + 1, cancellable, error)) goto out; if (!scan_one_metadata_object (pull_data, ostree_checksum_bytes_peek (tree_meta_csum), OSTREE_OBJECT_TYPE_DIR_META, recursion_depth + 1, cancellable, error)) goto out; ret = TRUE; out: if (iter) g_variant_iter_free (iter); return ret; }
static gboolean mtn_connman_initable_init_sync (GInitable *initable, GCancellable *cancellable, GError **error) { GInitableIface *iface_class, *parent_iface_class; GVariant *var, *value; GVariantIter *iter; char *key; MtnConnman *connman; connman = MTN_CONNMAN (initable); /* Chain up the old method */ iface_class = G_INITABLE_GET_IFACE (initable); parent_iface_class = g_type_interface_peek_parent (iface_class); if (!parent_iface_class->init (initable, cancellable, error)) { return FALSE; } g_signal_connect (connman, "notify::g-name-owner", G_CALLBACK (_name_owner_notify_cb), NULL); var = g_dbus_proxy_call_sync (G_DBUS_PROXY (connman), "GetProperties", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); if (!var) { return FALSE; } g_variant_get (var, "(a{sv})", &iter); while (g_variant_iter_next (iter, "{sv}", &key, &value)) { g_hash_table_insert (connman->priv->properties, key, value); } g_variant_iter_free (iter); g_variant_unref (var); var = g_dbus_proxy_call_sync (G_DBUS_PROXY (connman), "GetServices", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, error); if (!var) { return FALSE; } connman->priv->services = var; return TRUE; }
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; }
/** * fcitx_input_method_get_imlist_nofree: (rename-to fcitx_input_method_get_imlist) * @im: A #FcitxInputMethod * * Get Fcitx all im list * * Returns: (transfer full) (element-type FcitxIMItem): A #FcitxIMItem List * * Rename to: fcitx_input_method_get_imlist **/ FCITX_EXPORT_API GPtrArray* fcitx_input_method_get_imlist_nofree(FcitxInputMethod* im) { GPtrArray *array = NULL; GVariant* value; GVariantIter *iter; gchar *name, *unique_name, *langcode; gboolean enable; value = g_dbus_proxy_get_cached_property(G_DBUS_PROXY(im), "IMList"); if (value == NULL) { GError* error = NULL; GVariant* result = g_dbus_connection_call_sync(g_dbus_proxy_get_connection(G_DBUS_PROXY(im)), g_dbus_proxy_get_name(G_DBUS_PROXY(im)), FCITX_IM_DBUS_PATH, "org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", FCITX_IM_DBUS_INTERFACE, "IMList"), G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, -1, /* timeout */ NULL, &error); if (error) { g_warning("%s", error->message); g_error_free(error); } else if (result) { g_variant_get(result, "(v)", &value); g_variant_unref(result); } } if (value) { array = g_ptr_array_new(); g_variant_get(value, "a(sssb)", &iter); while (g_variant_iter_next(iter, "(sssb)", &name, &unique_name, &langcode, &enable, NULL)) { FcitxIMItem *item = g_slice_new(FcitxIMItem); item->name = name; item->unique_name = unique_name; item->langcode = langcode; item->enable = enable; g_ptr_array_add(array, item); } g_variant_iter_free(iter); g_variant_unref(value); } return array; }
gboolean set_fingerprint_label (GtkWidget *label1, GtkWidget *label2) { GDBusProxy *device; GVariant *result; GVariantIter *fingers; GError *error = NULL; if (manager == NULL) { create_manager (); if (manager == NULL) { return FALSE; } } device = get_first_device (); if (device == NULL) return FALSE; result = g_dbus_proxy_call_sync (device, "ListEnrolledFingers", g_variant_new ("(s)", ""), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (!result) { if (!g_dbus_error_is_remote_error (error) || strcmp (g_dbus_error_get_remote_error(error), "net.reactivated.Fprint.Error.NoEnrolledPrints") != 0) { g_object_unref (device); return FALSE; } } if (result && g_variant_is_of_type (result, G_VARIANT_TYPE ("(as)"))) g_variant_get (result, "(as)", &fingers); else fingers = NULL; if (fingers == NULL || g_variant_iter_n_children (fingers) == 0) { is_disable = FALSE; gtk_label_set_text (GTK_LABEL (label1), _("Disabled")); gtk_label_set_text (GTK_LABEL (label2), _("Disabled")); } else { is_disable = TRUE; gtk_label_set_text (GTK_LABEL (label1), _("Enabled")); gtk_label_set_text (GTK_LABEL (label2), _("Enabled")); } if (result != NULL) g_variant_unref (result); if (fingers != NULL) g_variant_iter_free (fingers); g_object_unref (device); return TRUE; }
void on_menu_changed(gpointer instance, GVariant *parameters, gpointer user_data) { WorkraveApplet *applet = (WorkraveApplet *)user_data; applet->inhibit++; GVariantIter *iter; g_variant_get (parameters, "(a(sii))", &iter); char *text; int id; int flags; gboolean visible[sizeof(menu_data)/sizeof(struct Menuitems)]; for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++) { visible[i] = menu_data[i].visible_when_not_running; } while (g_variant_iter_loop(iter, "(sii)", &text, &id, &flags)) { int index = lookup_menu_index_by_id((enum MenuCommand)id); if (index == -1) { continue; } GtkAction *action = gtk_action_group_get_action(applet->action_group, menu_data[index].action); if (flags & MENU_ITEM_FLAG_SUBMENU_END || flags & MENU_ITEM_FLAG_SUBMENU_BEGIN) { continue; } visible[index] = TRUE; if (GTK_IS_TOGGLE_ACTION(action)) { GtkToggleAction *toggle = GTK_TOGGLE_ACTION(action); gtk_toggle_action_set_active(toggle, flags & MENU_ITEM_FLAG_ACTIVE); } } g_variant_iter_free (iter); for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++) { GtkAction *action = gtk_action_group_get_action(applet->action_group, menu_data[i].action); gtk_action_set_visible(action, visible[i]); } applet->inhibit--; }
static void process_proplist(void *data, GVariant *props, void (*func)(void *data, const char *k, GVariant *val)) { GVariantIter *iter; const char *key; GVariant *value; g_variant_get (props, "(a{sv})", &iter); while (g_variant_iter_loop (iter, "{sv}", &key, &value)) { func(data, key, value); } g_variant_iter_free(iter); }
static void poll_with_variant (GPid pid, GVariant *info, GError *error, gpointer user_data) { StoragedLinuxVolumeGroupObject *object = user_data; StoragedDaemon *daemon; GVariantIter *iter; gboolean needs_polling; if (pid != object->poll_pid) { g_object_unref (object); return; } object->poll_pid = 0; if (error) { storaged_warning ("Failed to poll LVM volume group %s: %s", storaged_linux_volume_group_object_get_name (object), error->message); g_object_unref (object); return; } daemon = storaged_linux_volume_group_object_get_daemon (object); storaged_linux_volume_group_update (STORAGED_LINUX_VOLUME_GROUP (object->iface_volume_group), info, &needs_polling); if (g_variant_lookup (info, "lvs", "aa{sv}", &iter)) { GVariant *lv_info = NULL; while (g_variant_iter_loop (iter, "@a{sv}", &lv_info)) { const gchar *name; StoragedLinuxLogicalVolumeObject *volume; g_variant_lookup (lv_info, "name", "&s", &name); update_operations (daemon, name, lv_info, &needs_polling); volume = g_hash_table_lookup (object->logical_volumes, name); if (volume) storaged_linux_logical_volume_object_update (volume, lv_info, &needs_polling); } g_variant_iter_free (iter); } g_object_unref (object); }
static void list_seats (GDBusConnection *connection) { GDBusProxy *proxy; GError *error; GVariant *res; GVariantIter *iter; gchar *path = NULL; proxy = g_dbus_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, NULL, CK_NAME, CK_MANAGER_PATH, CK_MANAGER_INTERFACE, NULL, &error); if (proxy == NULL) { g_print ("error creating proxy, %s", error->message); g_clear_error (&error); return; } error = NULL; res = g_dbus_proxy_call_sync (proxy, "GetSeats", g_variant_new ("()"), G_DBUS_CALL_FLAGS_NONE, 6000, NULL, &error); if (res == NULL) { g_warning ("Failed to get list of seats: %s", error->message); g_clear_error (&error); goto out; } g_variant_get (res, "(ao)", &iter); while (g_variant_iter_next (iter, "o", &path)) { list_sessions (connection, path); } g_variant_iter_free (iter); g_variant_unref (res); out: g_object_unref (proxy); }
static void on_response_sap_transfer_apdu(GObject *source_object, GAsyncResult *res, gpointer user_data) { GError *error = NULL; GDBusConnection *conn = NULL; GVariant *dbus_result; GVariantIter *iter = NULL; GVariant *param_gv = NULL; GVariant *inner_gv = NULL; guchar rt_i; int i = 0; struct tapi_resp_data *evt_cb_data = user_data; TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK; TelSapApduData_t r_apdu; dbg("Func Entrance"); memset(&r_apdu, 0, sizeof(TelSapApduData_t)); conn = G_DBUS_CONNECTION (source_object); dbus_result = g_dbus_connection_call_finish(conn, res, &error); if (dbus_result) { /* dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/ g_variant_get(dbus_result, "(i@v)", &result, ¶m_gv); inner_gv = g_variant_get_variant(param_gv); g_variant_get(inner_gv, "ay", &iter); while (g_variant_iter_loop(iter, "y", &rt_i)) { r_apdu.apdu_data[i] = rt_i; i++; } r_apdu.apdu_len = (int) i; g_variant_iter_free(iter); g_variant_unref(inner_gv); g_variant_unref(param_gv); /* for(i=0; i < (int)r_apdu.apdu_len; i++) dbg("apdu[%d][0x%02x]",i, r_apdu.apdu_data[i]);*/ } else { result = TAPI_SIM_SAP_RESULT_CODE_DATA_NOT_AVAILABLE; dbg( "g_dbus_conn failed. error (%s)", error->message); g_error_free(error); } if (evt_cb_data->cb_fn) { evt_cb_data->cb_fn(evt_cb_data->handle, result, (void*)&r_apdu, evt_cb_data->user_data); } free(evt_cb_data); }
static GDBusProxy * login_dbus_proxy_new (void) { GError *error = NULL; GDBusProxy *dbus_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL /* GDBusInterfaceInfo */, "org.freedesktop.login1", "/org/freedesktop/login1", "org.freedesktop.login1.Manager", NULL /* GCancellable */, &error); if (error) { g_warning ("Error creating GDBusProxy: %s.", error->message); g_error_free (error); return NULL; } g_signal_connect (dbus_proxy, "g-signal", G_CALLBACK (record_login), NULL /* data */); GVariant *sessions = g_dbus_proxy_call_sync (dbus_proxy, "ListSessions", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_warning ("Error calling ListSessions: %s.", error->message); g_error_free (error); return NULL; } GVariantIter *session_iter; g_variant_get (sessions, "(a(susso))", &session_iter); const gchar *session_id; guint32 user_id; while (g_variant_iter_loop (session_iter, "(&suss&o)", &session_id, &user_id, NULL, NULL, NULL)) { add_session (session_id, user_id); } g_variant_iter_free (session_iter); g_variant_unref (sessions); return dbus_proxy; }
static void on_channel_update (GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, ReaderEngine *engine) { GVariantIter *iter1, *iter2; gchar *class_name; gint graph = 0, subject = 0, predicate = 0, object = 0; g_variant_get (parameters, "(&sa(iiii)a(iiii))", &class_name, &iter1, &iter2); while (g_variant_iter_loop (iter1, "(iiii)", &graph, &subject, &predicate, &object)) handle_channel_deletes (engine, subject); while (g_variant_iter_loop (iter2, "(iiii)", &graph, &subject, &predicate, &object)) handle_channel_inserts (engine, subject); g_variant_iter_free (iter1); g_variant_iter_free (iter2); }
deepin_workspace_overview_set_present_windows(DeepinWorkspaceOverview* self, GVariant* xids) { DeepinWorkspaceOverviewPrivate* priv = self->priv; if (xids) { priv->all_window_mode = TRUE; priv->present_xids = g_hash_table_new(g_direct_hash, g_direct_equal); guint32 xid; GVariantIter* vi = g_variant_iter_new(xids); while (g_variant_iter_next(vi, "u", &xid, NULL)) { g_hash_table_insert(priv->present_xids, GINT_TO_POINTER(xid), GINT_TO_POINTER(1)); meta_verbose("presenting xid %d\n", xid); } g_variant_iter_free(vi); } }
static void ol_config_proxy_value_changed_cb (OlConfigProxy *proxy, GVariant *parameters) { GVariantIter *iter = NULL; g_variant_get (parameters, "(as)", &iter); gchar *name = NULL; while (g_variant_iter_loop (iter, "s", &name)) { g_signal_emit (proxy, _signals[SIGNAL_CHANGED], g_quark_from_string (name), name); } g_variant_iter_free (iter); }
static void names_listed (GObject *object, GAsyncResult *result, gpointer user_data) { NamespaceWatcher *watcher; GError *error = NULL; GVariant *reply; GVariantIter *iter; const gchar *name; reply = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), result, &error); if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_error_free (error); return; } watcher = user_data; if (reply == NULL) { g_warning ("bus_watch_namespace: error calling org.freedesktop.DBus.ListNames: %s", error->message); g_error_free (error); return; } g_variant_get (reply, "(as)", &iter); while (g_variant_iter_next (iter, "&s", &name)) { if (dbus_name_has_namespace (name, watcher->name_space)) { GetNameOwnerData *data = g_slice_new (GetNameOwnerData); data->watcher = watcher; data->name = g_strdup (name); g_dbus_connection_call (watcher->connection, "org.freedesktop.DBus", "/", "org.freedesktop.DBus", "GetNameOwner", g_variant_new ("(s)", name), G_VARIANT_TYPE ("(s)"), G_DBUS_CALL_FLAGS_NONE, -1, watcher->cancellable, got_name_owner, data); } } g_variant_iter_free (iter); g_variant_unref (reply); }
static void poll_with_variant (GPid pid, GVariant *info, GError *error, gpointer user_data) { StorageVolumeGroup *self = user_data; GVariantIter *iter; gboolean needs_polling; if (pid != self->poll_pid) { g_object_unref (self); return; } self->poll_pid = 0; if (error) { g_message ("Failed to poll LVM volume group %s: %s", storage_volume_group_get_name (self), error->message); g_object_unref (self); return; } volume_group_update_props (self, info, &needs_polling); if (g_variant_lookup (info, "lvs", "aa{sv}", &iter)) { GVariant *lv_info = NULL; while (g_variant_iter_loop (iter, "@a{sv}", &lv_info)) { const gchar *name; StorageLogicalVolume *volume; g_variant_lookup (lv_info, "name", "&s", &name); update_operations (name, lv_info, &needs_polling); volume = g_hash_table_lookup (self->logical_volumes, name); if (volume) storage_logical_volume_update (volume, self, lv_info, &needs_polling); } g_variant_iter_free (iter); } g_object_unref (self); }
GHashTable * ot_util_variant_asv_to_hash_table (GVariant *variant) { GHashTable *ret; GVariantIter *viter; char *key; GVariant *value; ret = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)g_variant_unref); viter = g_variant_iter_new (variant); while (g_variant_iter_next (viter, "{s@v}", &key, &value)) g_hash_table_replace (ret, key, g_variant_ref_sink (value)); g_variant_iter_free (viter); return ret; }
static gchar * get_profile_for_window (GdkWindow *window) { GError *error = NULL; guint xid; gchar *icc_profile = NULL; GVariant *args = NULL; GVariant *response = NULL; GVariant *response_child = NULL; GVariantIter *iter = NULL; /* get color profile */ xid = GDK_WINDOW_XID (window); args = g_variant_new ("(u)", xid), response = g_dbus_connection_call_sync (connection, "org.gnome.ColorManager", "/org/gnome/ColorManager", "org.gnome.ColorManager", "GetProfileForWindow", args, G_VARIANT_TYPE ("(s)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (response == NULL) { /* not a warning, as GCM might not be installed / running */ g_debug ("The GetProfileForWindow request failed: %s", error->message); g_error_free (error); goto out; } /* get icc profile filename */ response_child = g_variant_get_child_value (response, 0); icc_profile = g_variant_dup_string (response_child, NULL); out: if (iter != NULL) g_variant_iter_free (iter); if (args != NULL) g_variant_unref (args); if (response != NULL) g_variant_unref (response); return icc_profile; }
static void ol_lyric_source_search_complete_cb (OlLyricSource *source, GVariant *parameters) { GVariantIter *iter = NULL; GVariant *dict = NULL; GList *result = NULL; gint taskid; gint statusid; OlLyricSourceTask *task; g_variant_get (parameters, "(iiaa{sv})", &taskid, &statusid, &iter); task = ol_lyric_source_get_search_task (source, taskid); if (task == NULL) { ol_errorf ("Search task %d not exist\n", taskid); return; } if (statusid < 0 || statusid > OL_LYRIC_SOURCE_STATUS_FALIURE) { ol_errorf ("Invalid search status %d\n", statusid); return; } while (g_variant_iter_loop (iter, "@a{sv}", &dict)) { OlLyricSourceCandidate *candidate; candidate = ol_lyric_source_candidate_new_with_variant (dict); result = g_list_prepend (result, candidate); } g_variant_iter_free (iter); result = g_list_reverse (result); g_signal_emit (task, _search_signals[SEARCH_SIGNAL_COMPLETE], 0, statusid, result); while (result) { OlLyricSourceCandidate *candidate = result->data; g_object_unref (candidate); result = g_list_delete_link (result, result); } ol_lyric_source_remove_search_task (source, taskid); }
static void xfpm_dump_remote (GDBusConnection *bus) { XfpmPowerManager *proxy; GError *error = NULL; GVariant *config; GVariantIter *iter; GHashTable *hash; gchar *key, *value; proxy = xfpm_power_manager_proxy_new_sync (bus, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, "org.xfce.PowerManager", "/org/xfce/PowerManager", NULL, NULL); xfpm_power_manager_call_get_config_sync (proxy, &config, NULL, &error); g_object_unref (proxy); if ( error ) { g_error ("%s", error->message); exit (EXIT_FAILURE); } hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); g_variant_get (config, "a{ss}", &iter); while (g_variant_iter_next (iter, "{ss}", &key, &value)) { g_hash_table_insert (hash, key, value); } g_variant_iter_free (iter); g_variant_unref (config); xfpm_dump (hash); g_hash_table_destroy (hash); }