Example #1
0
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 */
}
Example #2
0
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);
}
Example #5
0
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);
}
Example #7
0
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);
}
Example #9
0
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));
	}
}
Example #10
0
static String truthStringFromVariant(GVariant* variant)
{
    if (g_variant_get_boolean(variant))
        return String("true");

    return String("false");
}
Example #11
0
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));
  }
}
Example #12
0
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;
}
Example #13
0
/**
 * 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;
        }
    }
Example #14
0
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;
    }
  }
}
Example #15
0
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;
}
Example #21
0
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);
}
Example #22
0
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;
}
Example #23
0
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);
}
Example #24
0
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;
}
Example #26
0
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));
}
Example #27
0
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;
}
Example #28
0
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);
	}
}
Example #29
0
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);
}