static gboolean set_prop_handler( GDBusConnection *connection, const gchar *sender, const gchar *object_path, const gchar *interface_name, const gchar *property_name, GVariant *value, GError **error, gpointer data ) { mpris *inst = data; if(g_strcmp0(property_name, "Fullscreen") == 0 && g_variant_get_boolean(value) != inst->gmpv_ctx->gui->fullscreen) { toggle_fullscreen(inst->gmpv_ctx); } else { g_hash_table_replace( ((mpris *) data)->base_prop_table, g_strdup(property_name), g_variant_ref(value) ); } return TRUE; /* This function should always succeed */ }
static void on_activate_toggle (GSimpleAction *action, GVariant *parameter, gpointer data) { GVariant *state = g_action_get_state (G_ACTION (action)); g_action_change_state (G_ACTION (action), g_variant_new_boolean (!g_variant_get_boolean (state))); g_variant_unref (state); }
void gkd_secret_objects_emit_collection_locked (GkdSecretObjects *self, GckObject *collection) { gchar *collection_path; GkdExportedCollection *skeleton; GVariant *value; GError *error = NULL; collection_path = object_path_for_collection (collection); gkd_secret_objects_foreach_item (self, NULL, collection_path, on_each_item_emit_locked, NULL); skeleton = g_hash_table_lookup (self->collections_to_skeletons, collection_path); if (skeleton == NULL) { g_warning ("setting locked state on collection %s, but no skeleton found", collection_path); return; } value = object_property_get (self, collection, "Locked", &error); if (!value) { g_warning ("setting locked state on item %s, but no property value: %s", collection_path, error->message); g_error_free (error); return; } gkd_exported_collection_set_locked (skeleton, g_variant_get_boolean (value)); g_variant_unref (value); gkd_secret_service_emit_collection_changed (self->service, collection_path); g_free (collection_path); }
static void update_location_label (CcPrivacyPanel *self) { CcPrivacyPanelPrivate *priv = self->priv; gboolean in_use = FALSE, on; const gchar *label; if (priv->gclue_manager != NULL) { GVariant *variant; variant = g_dbus_proxy_get_cached_property (priv->gclue_manager, "InUse"); if (variant != NULL) { in_use = g_variant_get_boolean (variant); g_variant_unref (variant); } } if (in_use) { gtk_label_set_label (GTK_LABEL (priv->location_label), _("In use")); return; } on = g_settings_get_boolean (priv->location_settings, LOCATION_ENABLED); label = on ? C_("Location services status", "On") : C_("Location services status", "Off"); gtk_label_set_label (GTK_LABEL (priv->location_label), label); }
static int dev_open(struct sr_dev_inst *sdi) { struct dev_context *devc; struct sr_scpi_dev_inst *scpi; GVariant *beeper; if (sdi->status != SR_ST_ACTIVE) return SR_ERR; scpi = sdi->conn; if (sr_scpi_open(scpi) < 0) return SR_ERR; sdi->status = SR_ST_ACTIVE; scpi_cmd(sdi, SCPI_CMD_REMOTE); devc = sdi->priv; devc->beeper_was_set = FALSE; if (scpi_cmd_resp(sdi, &beeper, G_VARIANT_TYPE_BOOLEAN, SCPI_CMD_BEEPER) == SR_OK) { if (g_variant_get_boolean(beeper)) { devc->beeper_was_set = TRUE; scpi_cmd(sdi, SCPI_CMD_BEEPER_DISABLE); } g_variant_unref(beeper); } return SR_OK; }
static void on_each_item_emit_locked (GkdSecretObjects *self, const gchar *path, GckObject *object, gpointer user_data) { GkdExportedItem *skeleton; GVariant *value; GError *error = NULL; skeleton = g_hash_table_lookup (self->items_to_skeletons, path); if (skeleton == NULL) { g_warning ("setting locked state on item %s, but no skeleton found", path); return; } value = object_property_get (self, object, "Locked", &error); if (!value) { g_warning ("setting locked state on item %s, but no property value: %s", path, error->message); g_error_free (error); return; } gkd_exported_item_set_locked (skeleton, g_variant_get_boolean (value)); g_variant_unref (value); gkd_secret_objects_emit_item_changed (self, object); }
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 void adapter5_on_acquired (GObject *object, GAsyncResult *res, NMBluezDevice *self) { NMBluezDevicePrivate *priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self); GError *error; GVariant *v; priv->adapter5 = g_dbus_proxy_new_for_bus_finish (res, &error); if (!priv->adapter5) { nm_log_warn (LOGD_BT, "bluez[%s] failed to acquire adapter proxy: %s.", priv->path, error->message); g_clear_error (&error); g_signal_emit (self, signals[INITIALIZED], 0, FALSE); } else { g_signal_connect (priv->adapter5, "g-properties-changed", G_CALLBACK (adapter5_on_properties_changed), self); /* Check adapter's powered state */ v = g_dbus_proxy_get_cached_property (priv->adapter5, "Powered"); priv->adapter_powered = VARIANT_IS_OF_TYPE_BOOLEAN (v) ? g_variant_get_boolean (v) : FALSE; if (v) g_variant_unref (v); priv->initialized = TRUE; g_signal_emit (self, signals[INITIALIZED], 0, TRUE); check_emit_usable (self); } g_object_unref (self); }
static void auto_spell_cb (GSimpleAction *action, GVariant *state, gpointer data) { GeditSpellPlugin *plugin = GEDIT_SPELL_PLUGIN (data); GeditSpellPluginPrivate *priv = plugin->priv; GeditView *view; gboolean active; gedit_debug (DEBUG_PLUGINS); active = g_variant_get_boolean (state); gedit_debug_message (DEBUG_PLUGINS, active ? "Auto Spell activated" : "Auto Spell deactivated"); view = gedit_window_get_active_view (priv->window); if (view != NULL) { GeditDocument *doc; doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view))); gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_SPELL_ENABLED, active ? "1" : NULL, NULL); set_auto_spell (priv->window, view, active); g_simple_action_set_state (action, g_variant_new_boolean (active)); } }
static String truthStringFromVariant(GVariant* variant) { if (g_variant_get_boolean(variant)) return String("true"); return String("false"); }
void ibus_rime_load_settings(IBusConfig* config) { //g_debug("ibus_rime_load_settings"); GVariant* value; value = ibus_config_get_value(config, "engine/Rime", "embed_preedit_text"); if (!value) { value = ibus_config_get_value(config, "general", "embed_preedit_text"); } if (value && g_variant_classify(value) == G_VARIANT_CLASS_BOOLEAN) { g_ibus_rime_settings.embed_preedit_text = g_variant_get_boolean(value); } value = ibus_config_get_value(config, "engine/Rime", "lookup_table_orientation"); if (!value) { value = ibus_config_get_value(config, "panel", "lookup_table_orientation"); } if (value && g_variant_classify(value) == G_VARIANT_CLASS_INT32) { g_ibus_rime_settings.lookup_table_orientation = g_variant_get_int32(value); } value = ibus_config_get_value(config, "engine/Rime", "color_scheme"); if (value && g_variant_classify(value) == G_VARIANT_CLASS_STRING) { ibus_rime_select_color_scheme(g_variant_get_string(value, NULL)); } }
gboolean go_conf_load_bool (GOConfNode *node, gchar const *key, gboolean default_val) { gboolean res; GVariant *val = NULL; if (node) { if (key && !strchr (key, '/') && !strchr (key, '.')) val = go_conf_get (node, key, G_VARIANT_TYPE_BOOLEAN); else if (node->key) val = go_conf_get (node, node->key, G_VARIANT_TYPE_BOOLEAN); } 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_BOOLEAN): NULL; go_conf_free_node (real_node); } if (val != NULL) { res = g_variant_get_boolean (val); g_variant_unref (val); } else { d (g_warning ("Using default value '%s'", default_val ? "true" : "false")); return default_val; } return res; }
/** * 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 ibus_rime_config_value_changed_cb(IBusConfig* config, const gchar* section, const gchar* name, GVariant* value, gpointer unused) { //g_debug("ibus_rime_config_value_changed_cb [%s/%s]", section, name); if (!strcmp("general", section)) { if (!strcmp("embed_preedit_text", name) && value && g_variant_classify(value) == G_VARIANT_CLASS_BOOLEAN) { g_ibus_rime_settings.embed_preedit_text = g_variant_get_boolean(value); return; } } else if (!strcmp("panel", section)) { if (!strcmp("lookup_table_orientation", name) && value && g_variant_classify(value) == G_VARIANT_CLASS_INT32) { g_ibus_rime_settings.lookup_table_orientation = g_variant_get_int32(value); return; } } else if (!strcmp("engine/Rime", section)) { if (!strcmp("embed_preedit_text", name) && value && g_variant_classify(value) == G_VARIANT_CLASS_BOOLEAN) { GVariant* overridden = ibus_config_get_value(config, "engine/Rime", "embed_preedit_text"); if (!overridden) { g_ibus_rime_settings.embed_preedit_text = g_variant_get_boolean(value); } return; } if (!strcmp("lookup_table_orientation", name) && value && g_variant_classify(value) == G_VARIANT_CLASS_INT32) { GVariant* overridden = ibus_config_get_value(config, "engine/Rime", "lookup_table_orientation"); if (!overridden) { g_ibus_rime_settings.lookup_table_orientation = g_variant_get_int32(value); } return; } if (!strcmp("color_scheme", name) && value && g_variant_classify(value) == G_VARIANT_CLASS_STRING) { ibus_rime_select_color_scheme(g_variant_get_string(value, NULL)); return; } } }
static void photos_searchbar_action_state_changed (PhotosSearchbar *self, const gchar *action_name, GVariant *value) { if (g_variant_get_boolean (value)) photos_searchbar_show (self); else photos_searchbar_hide (self); }
BT_EXPORT_API int bluetooth_telephony_is_nrec_enabled(gboolean *status) { GVariant *reply = NULL; GError *err = NULL; GVariantIter *reply_iter; GDBusConnection *connection; GVariant *value; gchar *key; GHashTable *list_hash = NULL; BT_DBG("+"); BT_TELEPHONY_CHECK_INITIALIZED(); BT_TELEPHONY_CHECK_ENABLED(); connection = _bt_init_system_gdbus_conn(); if (status == NULL) return BLUETOOTH_TELEPHONY_ERROR_INVALID_PARAM; reply = g_dbus_connection_call_sync(connection, HFP_AGENT_SERVICE, HFP_AGENT_PATH, HFP_AGENT_INTERFACE, "GetProperties", NULL, G_VARIANT_TYPE("(a{sv})"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err); if (err) { BT_ERR("GetProperties GDBus error: %s", err->message); g_clear_error(&err); return BLUETOOTH_TELEPHONY_ERROR_INTERNAL; } if (!reply) { BT_ERR("Error returned in method call\n"); return BLUETOOTH_TELEPHONY_ERROR_INTERNAL; } g_variant_get(reply, "(a{sv})", &reply_iter); list_hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL); while (g_variant_iter_next(reply_iter, "{sv}", &key, &value)) { BT_DBG("key is %s", key); g_hash_table_insert(list_hash, key, value); } value = g_hash_table_lookup(list_hash, "nrec"); if (value != NULL) { *status = g_variant_get_boolean(value); BT_DBG("NREC status = [%d]", *status); } g_hash_table_destroy(list_hash); BT_DBG("-"); return BLUETOOTH_TELEPHONY_ERROR_NONE; }
static void _add_entry(GHashTable *entry) { Elm_Object_Item *glit; GVariant *val; int received = 0, answered = 0; val = g_hash_table_lookup(entry, "Direction"); if (val) { const char *dir = g_variant_get_string(val, NULL); if (!strcmp(dir, "in")) { received = 1; } } else { g_warning("ignoring call without Direction field!!"); return; } val = g_hash_table_lookup(entry, "Answered"); if (val) { if (g_variant_get_boolean(val)) { answered = 1; } } glit = elm_genlist_item_append(view.list_all, &itc, g_hash_table_ref(entry), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); val = g_variant_new_int32(GPOINTER_TO_INT(glit)); g_hash_table_insert(entry, "_item_all", g_variant_ref_sink(val)); if (received) { if (answered) { glit = elm_genlist_item_append(view.list_in, &itc, g_hash_table_ref(entry), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); val = g_variant_new_int32(GPOINTER_TO_INT(glit)); g_hash_table_insert(entry, "_item_in", g_variant_ref_sink(val)); } else { glit = elm_genlist_item_append(view.list_missed, &itc, g_hash_table_ref(entry), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); val = g_variant_new_int32(GPOINTER_TO_INT(glit)); g_hash_table_insert(entry, "_item_missed", g_variant_ref_sink(val)); } } else { glit = elm_genlist_item_append(view.list_out, &itc, g_hash_table_ref(entry), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); val = g_variant_new_int32(GPOINTER_TO_INT(glit)); g_hash_table_insert(entry, "_item_out", g_variant_ref_sink(val)); } }
static gboolean abrt_label_mapping_get (GValue *value, GVariant *variant, gpointer user_data) { g_value_set_string (value, g_variant_get_boolean (variant) ? _("Automatic") : _("Manual")); return TRUE; }
static void fsearch_window_action_show_modified_column (GSimpleAction *action, GVariant *variant, gpointer user_data) { FsearchApplicationWindow *self = user_data; g_simple_action_set_state (action, variant); gboolean value = g_variant_get_boolean (variant); GtkTreeView *list = GTK_TREE_VIEW (fsearch_application_window_get_listview (self)); if (value == FALSE) { listview_remove_column (list, LIST_MODEL_COL_CHANGED); } else { listview_add_column (list, LIST_MODEL_COL_CHANGED, 75, 4); } FsearchConfig *config = fsearch_application_get_config (FSEARCH_APPLICATION_DEFAULT); config->show_modified_column = g_variant_get_boolean (variant); }
static gboolean on_off_label_mapping_get (GValue *value, GVariant *variant, gpointer user_data) { g_value_set_string (value, g_variant_get_boolean (variant) ? _("On") : _("Off")); return TRUE; }
void on_feedlist_reduced_activate (GSimpleAction *action, GVariant *parameter, gpointer user_data) { GVariant *state = g_action_get_state (G_ACTION (action)); gboolean val = !g_variant_get_boolean (state); feed_list_view_set_reduce_mode (val); g_simple_action_set_state (action, g_variant_new_boolean (val)); g_object_unref (state); }
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; }
static void photos_searchbar_change_state (PhotosSearchbar *self, GVariant *value) { g_simple_action_set_state (G_SIMPLE_ACTION (self->priv->search), value); if (g_variant_get_boolean (value)) photos_searchbar_show (self); else photos_searchbar_hide (self); }
G_MODULE_EXPORT void show_preview_action_cb(GSimpleAction *action, GVariant *value, signal_user_data_t *ud) { gboolean state = g_variant_get_boolean(value); g_simple_action_set_state(action, value); ghb_preview_set_visible(ud, state); update_preview_labels(ud, state); }
static void test_getservers_slmock_none (void) { DbusTestService * service = dbus_test_service_new(NULL); /* RLS */ DbusTestProcess * rls = dbus_test_process_new(REMOTE_LOGON_SERVICE); dbus_test_process_append_param(rls, "--config-file=" SLMOCK_CONFIG_FILE); dbus_test_service_add_task(service, DBUS_TEST_TASK(rls)); /* Dummy */ DbusTestTask * dummy = dbus_test_task_new(); dbus_test_task_set_wait_for(dummy, "org.ArcticaProject.RemoteLogon"); dbus_test_service_add_task(service, dummy); /* Get RLS up and running and us on that bus */ dbus_test_service_start_tasks(service); GDBusConnection * session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL); g_dbus_connection_set_exit_on_close(session, FALSE); GVariant * retval = g_dbus_connection_call_sync(session, "org.ArcticaProject.RemoteLogon", "/org/ArcticaProject/RemoteLogon", "org.ArcticaProject.RemoteLogon", "GetServersForLogin", g_variant_new("(sssb)", "https://slmock.com/", "Baduser", "Badpass", TRUE), /* params */ G_VARIANT_TYPE("(bsa(sssba(sbva{sv})a(si)))"), /* ret type */ G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL); g_assert(retval != NULL); g_assert(g_variant_n_children(retval) == 3); GVariant * loggedin = g_variant_get_child_value(retval, 0); g_assert(!g_variant_get_boolean(loggedin)); g_variant_unref(loggedin); loggedin = NULL; GVariant * array = g_variant_get_child_value(retval, 2); g_assert(g_variant_n_children(array) == 0); g_variant_unref(array); g_variant_unref(retval); g_object_unref(session); g_object_unref(rls); g_object_unref(service); return; }
static void fr_application_activate_view_sidebar (GSimpleAction *action, GVariant *parameter, gpointer user_data) { FrApplication *application = user_data; GSettings *settings; settings = fr_application_get_settings (application, FILE_ROLLER_SCHEMA_UI); g_settings_set_boolean (settings, PREF_UI_VIEW_SIDEBAR, g_variant_get_boolean (parameter)); }
gboolean accounts_user_get_automatic_login (AccountsUser *user) { GVariant *value; gboolean ret; g_return_val_if_fail (ACCOUNTS_IS_USER (user), FALSE); value = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (user), "AutomaticLogin"); ret = g_variant_get_boolean (value); g_variant_unref (value); return ret; }
static void assign_current_cellular_service(struct ofono_wan_data *od, const gchar *path, GVariant *properties) { GVariant *property = 0, *prop_name = 0, *prop_value = 0; gsize n = 0; const gchar *name = 0; bool favorite = false; if (!path) { if (od->current_service_watch) g_signal_handler_disconnect(od->current_service_proxy, od->current_service_watch); if (od->current_service_proxy) g_object_unref(od->current_service_proxy); od->current_service_path = NULL; od->current_service_proxy = 0; od->current_service_watch = 0; return; } od->current_service_path = g_strdup(path); od->current_service_proxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL, "net.connman", path, "net.connman.Service", NULL, NULL); od->current_service_watch = g_signal_connect(od->current_service_proxy, "g-signal", G_CALLBACK(current_service_signal_cb), od); for (n = 0; n < g_variant_n_children(properties); n++) { property = g_variant_get_child_value(properties, n); prop_name = g_variant_get_child_value(property, 0); prop_value = g_variant_get_child_value(property, 1); name = g_variant_get_string(prop_name, NULL); if (g_strcmp0(name, "Favorite") == 0) { favorite = g_variant_get_boolean(g_variant_get_variant(prop_value)); if (!favorite) { g_message("[WAN] Found a not yet configured cellular service; connecting to it for the first time"); switch_current_service_state(od, true, cellular_service_setup_cb, od); } } handle_current_service_property(od, name, prop_value); } }
gboolean network_get_connected(Network *self, GError **error) { g_assert(NETWORK_IS(self)); g_assert(self->priv->properties != NULL); GVariant *prop = properties_get(self->priv->properties, NETWORK_DBUS_INTERFACE, "Connected", error); if(prop == NULL) return FALSE; gboolean ret = g_variant_get_boolean(prop); g_variant_unref(prop); return ret; }
static void action_toggle_state_cb (GSimpleAction *saction, GVariant *parameter, gpointer user_data) { GAction *action = G_ACTION (saction); GVariant *state = g_action_get_state (action); g_action_change_state (action, g_variant_new_boolean (!g_variant_get_boolean (state))); g_variant_unref (state); }