static GVariant * create_translation_dict (GHashTable * ht_strings, const gchar * en) { GVariantBuilder array; guint count = 0; GList *l; g_variant_builder_init (&array, G_VARIANT_TYPE_ARRAY); for (l = langs; l != NULL; l = l->next) { const gchar *trans, *lang; lang = (const gchar *) l->data; trans = g_hash_table_lookup (ht_strings, (gpointer) lang); if (trans != NULL && *trans != '\0' && strcmp (en, trans) != 0 && !skip_translation (ht_strings, lang, trans)) { /* g_print ("%s (%s) => %s\n", en, lang, trans); */ g_variant_builder_add_value (&array, g_variant_new_dict_entry (g_variant_new_string (lang), g_variant_new_string (trans))); ++count; } } if (count == 0) { g_variant_builder_clear (&array); return NULL; } return g_variant_builder_end (&array); }
static void write_translations_dictionary (GList * licenses, const gchar * dict_filename) { /* maps C string => (dictionary of: locale => translation) */ GVariantBuilder array; /* maps C string => boolean (if it's in the dictionary already */ GHashTable *translations; GVariant *var; GList *l; FILE *f; /* sort langs for prettiness / to make variant dumps easier to read */ langs = g_list_sort (langs, (GCompareFunc) strcmp); g_variant_builder_init (&array, G_VARIANT_TYPE_ARRAY); translations = g_hash_table_new (g_str_hash, g_str_equal); for (l = licenses; l != NULL; l = l->next) { const gchar *en; License *license; license = l->data; if (license->packed_into_source) continue; /* add title + translations */ en = g_hash_table_lookup (license->titles, "en"); g_assert (en != NULL); /* check if we already have added translations for this string */ if (!g_hash_table_lookup (translations, (gpointer) en)) { GVariant *trans; trans = create_translation_dict (license->titles, en); if (trans != NULL) { g_variant_builder_add_value (&array, g_variant_new_dict_entry (g_variant_new_string (en), trans)); g_hash_table_insert (translations, (gpointer) en, GINT_TO_POINTER (TRUE)); } } /* add description + translations */ if (license->descriptions == NULL) continue; en = g_hash_table_lookup (license->descriptions, "en"); g_assert (en != NULL); /* check if we already have added translations for this string */ if (!g_hash_table_lookup (translations, (gpointer) en)) { GVariant *trans; trans = create_translation_dict (license->descriptions, en); if (trans != NULL) { g_variant_builder_add_value (&array, g_variant_new_dict_entry (g_variant_new_string (en), trans)); g_hash_table_insert (translations, (gpointer) en, GINT_TO_POINTER (TRUE)); } } } var = g_variant_builder_end (&array); f = fopen (dict_filename, "wb"); if (fwrite (g_variant_get_data (var), g_variant_get_size (var), 1, f) != 1) { g_error ("failed to write dict to file: %s", g_strerror (errno)); } fclose (f); g_printerr ("Wrote dictionary to %s, size: %u, type: %s\n", dict_filename, (guint) g_variant_get_size (var), (gchar *) g_variant_get_type (var)); g_variant_unref (var); g_hash_table_destroy (translations); }
static void update_metadata (void * data, GObject * object) { char * title = NULL, * artist = NULL, * album = NULL, * file = NULL; int length = 0; int playlist = aud_playlist_get_playing (); int entry = (playlist >= 0) ? aud_playlist_get_position (playlist) : -1; if (entry >= 0) { aud_playlist_entry_describe (playlist, entry, & title, & artist, & album, TRUE); file = aud_playlist_entry_get_filename (playlist, entry); length = aud_playlist_entry_get_length (playlist, entry, TRUE); } /* pointer comparison works for pooled strings */ if (title == last_title && artist == last_artist && album == last_album && file == last_file && length == last_length) { str_unref (title); str_unref (artist); str_unref (album); str_unref (file); return; } if (file != last_file) { if (image_file) aud_art_unref (last_file); image_file = file ? aud_art_get_file (file) : NULL; } str_unref (last_title); str_unref (last_artist); str_unref (last_album); str_unref (last_file); last_title = title; last_artist = artist; last_album = album; last_file = file; last_length = length; GVariant * elems[7]; int nelems = 0; if (title) { GVariant * key = g_variant_new_string ("xesam:title"); GVariant * str = g_variant_new_string (title); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (artist) { GVariant * key = g_variant_new_string ("xesam:artist"); GVariant * str = g_variant_new_string (artist); GVariant * array = g_variant_new_array (G_VARIANT_TYPE_STRING, & str, 1); GVariant * var = g_variant_new_variant (array); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (album) { GVariant * key = g_variant_new_string ("xesam:album"); GVariant * str = g_variant_new_string (album); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (file) { GVariant * key = g_variant_new_string ("xesam:url"); GVariant * str = g_variant_new_string (file); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (length > 0) { GVariant * key = g_variant_new_string ("mpris:length"); GVariant * val = g_variant_new_int64 ((int64_t) length * 1000); GVariant * var = g_variant_new_variant (val); elems[nelems ++] = g_variant_new_dict_entry (key, var); } if (image_file) { GVariant * key = g_variant_new_string ("mpris:artUrl"); GVariant * str = g_variant_new_string (image_file); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); } GVariant * key = g_variant_new_string ("mpris:trackid"); GVariant * str = g_variant_new_string ("/org/mpris/MediaPlayer2/CurrentTrack"); GVariant * var = g_variant_new_variant (str); elems[nelems ++] = g_variant_new_dict_entry (key, var); if (! metadata_type) metadata_type = g_variant_type_new ("{sv}"); GVariant * array = g_variant_new_array (metadata_type, elems, nelems); g_object_set (object, "metadata", array, NULL); }
gboolean eject(gchar* drive_dbus_path) { g_type_init(); GDBusProxy* UD2_Drive_Proxy = NULL; GError* error=NULL; /* Is the drive ejectable? */ UD2_Drive_Proxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL, UD2_DBUS_NAME, drive_dbus_path, DBUS_PROP_IFACE, NULL, &error); if (!UD2_Drive_Proxy) { g_printerr("%s\n", error->message); g_error_free(error); } GVariant* UD2_Ejectable = g_dbus_proxy_call_sync( UD2_Drive_Proxy, (gchar*) "Get", g_variant_new( "(ss)", "org.freedesktop.UDisks2.Drive", "Ejectable" ), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (!UD2_Ejectable) { g_printerr("%s\n", error->message); g_error_free(error); } GVariant* ejectable; g_variant_get(UD2_Ejectable, "(v)", &ejectable); g_assert_cmpstr(g_variant_get_type_string(ejectable), ==, "b"); gboolean is_ejectable = g_variant_get_boolean(ejectable); g_variant_unref(ejectable); g_variant_unref(UD2_Ejectable); g_object_unref(UD2_Drive_Proxy); if (FALSE==is_ejectable) { g_printerr("%s is not an ejectable drive\n", drive_dbus_path); return FALSE; } /* Proceed with the actual ejection */ g_print("Ejecting %s\n", drive_dbus_path); GDBusProxy* FOO_PROXY= NULL; /* Attempt to get a DBus proxy for the drive's UDisks2.Drive iface */ FOO_PROXY= g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_NONE, NULL, UD2_DBUS_NAME, drive_dbus_path, UD2_DRIVE_IFACE, NULL, &error); if (!FOO_PROXY) { g_printerr("Couldn't get DBus proxy for %s:\n%s\n", drive_dbus_path, error->message); g_error_free(error); return FALSE; } /* We need to build a dictionary of options, albeit an empty one */ GVariant* dict_entry = g_variant_new_dict_entry( g_variant_new("s", "auth.no_user_interaction"), g_variant_new("b", TRUE)); GVariant* dict = g_variant_new_tuple(&dict_entry, 1); g_print("%s\n", g_variant_print(dict, TRUE)); g_print("%s\n", g_variant_get_type_string(dict)); GVariant* UD2_Eject_Success = g_dbus_proxy_call_sync( FOO_PROXY, (gchar*) "Eject", dict, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (!UD2_Eject_Success) { g_printerr("foo %s\n", error->message); g_error_free(error); } /* GVariant* version_string; g_variant_get(UD2_Eject_Success, "(v)", &version_string); */ /* version is allocated independently from the GVariants */ /* gchar* version=g_variant_dup_string(version_string, NULL); g_variant_unref(version_string); */ g_variant_unref(UD2_Eject_Success); g_object_unref(FOO_PROXY); return TRUE; }
static GVariant * parse_json_dictionary (JsonNode *node, const GVariantType *entry_type, GError **error) { const GVariantType *key_type; const GVariantType *value_type; GVariant *result = NULL; GPtrArray *children; JsonObject *object; JsonNode *key_node; GList *members = NULL; gboolean is_string; GVariant *value; GVariant *key; GVariant *child; GList *l; children = g_ptr_array_new (); if (!check_type (node, JSON_NODE_OBJECT, 0, error)) goto out; object = json_node_get_object (node); key_type = g_variant_type_key (entry_type); value_type = g_variant_type_value (entry_type); is_string = (g_variant_type_equal (key_type, G_VARIANT_TYPE_STRING) || g_variant_type_equal (key_type, G_VARIANT_TYPE_OBJECT_PATH) || g_variant_type_equal (key_type, G_VARIANT_TYPE_SIGNATURE)); members = json_object_get_members (object); for (l = members; l != NULL; l = g_list_next (l)) { if (is_string) { key_node = json_node_init_string (json_node_alloc (), l->data); } else { key_node = cockpit_json_parse (l->data, -1, NULL); if (key_node == NULL) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Unexpected key '%s' in JSON object", (gchar *)l->data); goto out; } } key = parse_json (key_node, key_type, error); json_node_free (key_node); if (!key) goto out; value = parse_json (json_object_get_member (object, l->data), value_type, error); if (!value) { g_variant_unref (key); goto out; } child = g_variant_new_dict_entry (key, value); g_ptr_array_add (children, child); } result = g_variant_new_array (entry_type, (GVariant *const *)children->pdata, children->len); children->len = 0; out: g_list_free (members); g_ptr_array_foreach (children, (GFunc)g_variant_unref, NULL); g_ptr_array_free (children, TRUE); return result; }