static GVariant * g_settings_set_mapping_float (const GValue *value, const GVariantType *expected_type) { GVariant *variant = NULL; gdouble d; gint64 l; if (G_VALUE_HOLDS_DOUBLE (value)) d = g_value_get_double (value); else return NULL; l = (gint64) d; if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16)) { if (G_MININT16 <= l && l <= G_MAXINT16) variant = g_variant_new_int16 ((gint16) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16)) { if (0 <= l && l <= G_MAXUINT16) variant = g_variant_new_uint16 ((guint16) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32)) { if (G_MININT32 <= l && l <= G_MAXINT32) variant = g_variant_new_int32 ((gint) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32)) { if (0 <= l && l <= G_MAXUINT32) variant = g_variant_new_uint32 ((guint) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64)) { if (G_MININT64 <= l && l <= G_MAXINT64) variant = g_variant_new_int64 ((gint64) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64)) { if (0 <= l && l <= G_MAXUINT64) variant = g_variant_new_uint64 ((guint64) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE)) { if (0 <= l && l <= G_MAXUINT32) variant = g_variant_new_handle ((guint) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double ((gdouble) d); return variant; }
static GVariant * g_settings_set_mapping_unsigned_int (const GValue *value, const GVariantType *expected_type) { GVariant *variant = NULL; guint64 u; if (G_VALUE_HOLDS_UINT (value)) u = g_value_get_uint (value); else if (G_VALUE_HOLDS_UINT64 (value)) u = g_value_get_uint64 (value); else return NULL; if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16)) { if (u <= G_MAXINT16) variant = g_variant_new_int16 ((gint16) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16)) { if (u <= G_MAXUINT16) variant = g_variant_new_uint16 ((guint16) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32)) { if (u <= G_MAXINT32) variant = g_variant_new_int32 ((gint) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32)) { if (u <= G_MAXUINT32) variant = g_variant_new_uint32 ((guint) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64)) { if (u <= G_MAXINT64) variant = g_variant_new_int64 ((gint64) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64)) { if (u <= G_MAXUINT64) variant = g_variant_new_uint64 ((guint64) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE)) { if (u <= G_MAXUINT32) variant = g_variant_new_handle ((guint) u); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double ((gdouble) u); return variant; }
GVariant* js_to_dbus(JSContextRef ctx, const JSValueRef jsvalue, const GVariantType* sig, JSValueRef *exception) { if (g_variant_type_is_array(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); if (g_variant_type_is_dict_entry(child_sig)) { const GVariantType* key_sig = g_variant_type_first(child_sig); const GVariantType* value_sig = g_variant_type_next(key_sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_function_child(ctx, jsvalue, i)) continue; g_variant_builder_open(&builder, child_sig); JSValueRef key = JSValueMakeString(ctx, JSPropertyNameArrayGetNameAtIndex(array, i)); JSValueRef value = JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL); g_variant_builder_add_value(&builder, js_to_dbus(ctx, key, key_sig, exception)); g_variant_builder_add_value(&builder, js_to_dbus(ctx, value, value_sig, exception)); g_variant_builder_close(&builder); } return g_variant_builder_end(&builder); } else { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) continue; g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), child_sig, exception)); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } } else if (g_variant_type_is_tuple(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* current_sig = g_variant_type_first(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) continue; g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), current_sig, exception)); current_sig = g_variant_type_next(current_sig); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } else { switch (g_variant_type_peek_string(sig)[0]) { case 'y': return g_variant_new_byte(JSValueToNumber(ctx, jsvalue, exception)); case 'n': return g_variant_new_int16(JSValueToNumber(ctx, jsvalue, exception)); case 'q': return g_variant_new_uint16(JSValueToNumber(ctx, jsvalue, exception)); case 'i': return g_variant_new_int32(JSValueToNumber(ctx, jsvalue, exception)); case 'u': return g_variant_new_uint32(JSValueToNumber(ctx, jsvalue, exception)); case 'x': return g_variant_new_int64(JSValueToNumber(ctx, jsvalue, exception)); case 't': return g_variant_new_uint64(JSValueToNumber(ctx, jsvalue, exception)); case 'd': return g_variant_new_double(JSValueToNumber(ctx, jsvalue, exception)); case 'h': return g_variant_new_handle(JSValueToNumber(ctx, jsvalue, exception)); case 'b': return g_variant_new_boolean(JSValueToBoolean(ctx, jsvalue)); case 's': { char* v = jsvalue_to_cstr(ctx, jsvalue); GVariant* r = g_variant_new_string(v); g_free(v); return r; } case 'v': { //TODO: /*g_variant_new_variant()*/ g_assert_not_reached(); } } } g_assert_not_reached(); }
int main (int argc, char *argv[]) { gint ret = 1; GError *error = NULL; gchar *s = NULL; GOptionContext *o = NULL; gint n; GSList *uris = NULL; GSList *l; bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); have_gtk = gtk_init_check (&argc, &argv); main_loop = g_main_loop_new (NULL, FALSE); udisks_client = udisks_client_new_sync (NULL, &error); if (udisks_client == NULL) { g_printerr (_("Error connecting to udisks daemon: %s (%s, %d)"), error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); goto out; } o = g_option_context_new (NULL); g_option_context_set_help_enabled (o, FALSE); g_option_context_set_summary (o, _("Attach and mount one or more disk image files.")); g_option_context_add_main_entries (o, opt_entries, GETTEXT_PACKAGE); if (!g_option_context_parse (o, &argc, &argv, NULL)) { s = g_option_context_get_help (o, FALSE, NULL); g_printerr ("%s", s); g_free (s); goto out; } if (argc > 1) { for (n = 1; n < argc; n++) uris = g_slist_prepend (uris, g_strdup (argv[n])); uris = g_slist_reverse (uris); } else { if (!have_gtk) { show_error ("No files given and GTK+ not available"); goto out; } else { uris = do_filechooser (); } } /* Files to attach are positional arguments */ for (l = uris; l != NULL; l = l->next) { const gchar *uri; gchar *filename; GUnixFDList *fd_list = NULL; GVariantBuilder options_builder; gint fd; gchar *loop_object_path = NULL; GFile *file; uri = l->data; file = g_file_new_for_commandline_arg (uri); filename = g_file_get_path (file); g_object_unref (file); if (filename == NULL) { show_error (_("Cannot open “%s” — maybe the volume isn’t mounted?"), uri); goto done_with_image; } fd = open (filename, opt_writable ? O_RDWR : O_RDONLY); if (fd == -1) { show_error (_("Error opening “%s”: %m"), filename); goto done_with_image; } g_variant_builder_init (&options_builder, G_VARIANT_TYPE_VARDICT); if (!opt_writable) g_variant_builder_add (&options_builder, "{sv}", "read-only", g_variant_new_boolean (TRUE)); fd_list = g_unix_fd_list_new_from_array (&fd, 1); /* adopts the fd */ /* Set up the disk image... */ error = NULL; if (!udisks_manager_call_loop_setup_sync (udisks_client_get_manager (udisks_client), g_variant_new_handle (0), g_variant_builder_end (&options_builder), fd_list, &loop_object_path, NULL, /* out_fd_list */ NULL, /* GCancellable */ &error)) { show_error (_("Error attaching disk image: %s (%s, %d)"), error->message, g_quark_to_string (error->domain), error->code); g_clear_error (&error); goto done_with_image; } /* Note that the desktop automounter is responsible for mounting, * unlocking etc. partitions etc. inside the image... */ done_with_image: g_clear_object (&fd_list); g_free (filename); g_free (loop_object_path); } /* for each image */ ret = 0; out: if (main_loop != NULL) g_main_loop_unref (main_loop); g_slist_free_full (uris, g_free); g_clear_object (&udisks_client); return ret; }
static GVariant * gconf_settings_backend_simple_gconf_value_type_to_gvariant (GConfValue *gconf_value, const GVariantType *expected_type) { /* Note: it's guaranteed that the types are compatible */ GVariant *variant = NULL; if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN)) variant = g_variant_new_boolean (gconf_value_get_bool (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE)) { int value = gconf_value_get_int (gconf_value); if (value < 0 || value > 255) return NULL; variant = g_variant_new_byte (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16)) { int value = gconf_value_get_int (gconf_value); if (value < G_MINSHORT || value > G_MAXSHORT) return NULL; variant = g_variant_new_int16 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16)) { int value = gconf_value_get_int (gconf_value); if (value < 0 || value > G_MAXUSHORT) return NULL; variant = g_variant_new_uint16 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32)) variant = g_variant_new_int32 (gconf_value_get_int (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_uint32 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64)) variant = g_variant_new_int64 ((gint64) gconf_value_get_int (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_uint64 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_handle (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double (gconf_value_get_float (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING)) variant = g_variant_new_string (gconf_value_get_string (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH)) variant = g_variant_new_object_path (gconf_value_get_string (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE)) variant = g_variant_new_signature (gconf_value_get_string (gconf_value)); return variant; }