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;
}
