shell/ev-metadata.c

   1 /* ev-metadata.c
   2  *  this file is part of evince, a gnome document viewer
   3  *
   4  * Copyright (C) 2009 Carlos Garcia Campos  <carlosgc@gnome.org>
   5  *
   6  * Evince is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Evince is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include <gio/gio.h>
  22 #include <string.h>
  23
  24 #include "ev-metadata.h"
  25
  26 struct _EvMetadata {
  27         GObject base;
  28
  29         GFile      *file;
  30         GHashTable *items;
  31 };
  32
  33 struct _EvMetadataClass {
  34         GObjectClass base_class;
  35 };
  36
  37 G_DEFINE_TYPE (EvMetadata, ev_metadata, G_TYPE_OBJECT)
  38
  39 #define EV_METADATA_NAMESPACE "metadata::evince"
  40
  41 static void
  42 ev_metadata_finalize (GObject *object)
  43 {
  44         EvMetadata *metadata = EV_METADATA (object);
  45
  46         if (metadata->items) {
  47                 g_hash_table_destroy (metadata->items);
  48                 metadata->items = NULL;
  49         }
  50
  51         if (metadata->file) {
  52                 g_object_unref (metadata->file);
  53                 metadata->file = NULL;
  54         }
  55
  56         G_OBJECT_CLASS (ev_metadata_parent_class)->finalize (object);
  57 }
  58
  59 static void
  60 ev_metadata_init (EvMetadata *metadata)
  61 {
  62         metadata->items = g_hash_table_new_full (g_str_hash,
  63                                                  g_str_equal,
  64                                                  g_free,
  65                                                  g_free);
  66 }
  67
  68 static void
  69 ev_metadata_class_init (EvMetadataClass *klass)
  70 {
  71         GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  72
  73         gobject_class->finalize = ev_metadata_finalize;
  74 }
  75
  76 static void
  77 ev_metadata_load (EvMetadata *metadata)
  78 {
  79         GFileInfo *info;
  80         gchar    **attrs;
  81         gint       i;
  82         GError    *error = NULL;
  83
  84         info = g_file_query_info (metadata->file, "metadata::*", 0, NULL, &error);
  85         if (!info) {
  86                 g_warning ("%s", error->message);
  87                 g_error_free (error);
  88
  89                 return;
  90         }
  91
  92         if (!g_file_info_has_namespace (info, "metadata")) {
  93                 g_object_unref (info);
  94
  95                 return;
  96         }
  97
  98         attrs = g_file_info_list_attributes (info, "metadata");
  99         for (i = 0; attrs[i]; i++) {
 100                 GFileAttributeType type;
 101                 gpointer           value;
 102                 const gchar       *key;
 103
 104                 if (!g_str_has_prefix (attrs[i], EV_METADATA_NAMESPACE))
 105                         continue;
 106
 107                 if (!g_file_info_get_attribute_data (info, attrs[i],
 108                                                      &type, &value, NULL)) {
 109                         continue;
 110                 }
 111
 112                 key = attrs[i] + strlen (EV_METADATA_NAMESPACE"::");
 113
 114                 if (type == G_FILE_ATTRIBUTE_TYPE_STRING) {
 115                         g_hash_table_insert (metadata->items,
 116                                              g_strdup (key),
 117                                              g_strdup (value));
 118                 }
 119         }
 120         g_strfreev (attrs);
 121         g_object_unref (info);
 122 }
 123
 124 EvMetadata *
 125 ev_metadata_new (GFile *file)
 126 {
 127         EvMetadata *metadata;
 128
 129         g_return_val_if_fail (G_IS_FILE (file), NULL);
 130
 131         metadata = EV_METADATA (g_object_new (EV_TYPE_METADATA, NULL));
 132         metadata->file = g_object_ref (file);
 133
 134         ev_metadata_load (metadata);
 135
 136         return metadata;
 137 }
 138
 139 gboolean
 140 ev_metadata_is_empty (EvMetadata *metadata)
 141 {
 142         return g_hash_table_size (metadata->items) == 0;
 143 }
 144
 145 gboolean
 146 ev_metadata_get_string (EvMetadata  *metadata,
 147                         const gchar *key,
 148                         gchar     **value)
 149 {
 150         gchar *v;
 151
 152         v = g_hash_table_lookup (metadata->items, key);
 153         if (!v)
 154                 return FALSE;
 155
 156         *value = v;
 157         return TRUE;
 158 }
 159
 160 static void
 161 metadata_set_callback (GObject      *file,
 162                        GAsyncResult *result,
 163                        EvMetadata   *metadata)
 164 {
 165         GError *error = NULL;
 166
 167         if (!g_file_set_attributes_finish (G_FILE (file), result, NULL, &error)) {
 168                 g_warning ("%s", error->message);
 169                 g_error_free (error);
 170         }
 171 }
 172
 173 gboolean
 174 ev_metadata_set_string (EvMetadata  *metadata,
 175                         const gchar *key,
 176                         const gchar *value)
 177 {
 178         GFileInfo *info;
 179         gchar     *gio_key;
 180
 181         info = g_file_info_new ();
 182
 183         gio_key = g_strconcat (EV_METADATA_NAMESPACE"::", key, NULL);
 184         if (value) {
 185                 g_file_info_set_attribute_string (info, gio_key, value);
 186         } else {
 187                 g_file_info_set_attribute (info, gio_key,
 188                                            G_FILE_ATTRIBUTE_TYPE_INVALID,
 189                                            NULL);
 190         }
 191         g_free (gio_key);
 192
 193         g_hash_table_insert (metadata->items, g_strdup (key), g_strdup (value));
 194         g_file_set_attributes_async (metadata->file,
 195                                      info,
 196                                      0,
 197                                      G_PRIORITY_DEFAULT,
 198                                      NULL,
 199                                      (GAsyncReadyCallback)metadata_set_callback,
 200                                      metadata);
 201         g_object_unref (info);
 202
 203         return TRUE;
 204 }
 205
 206 gboolean
 207 ev_metadata_get_int (EvMetadata  *metadata,
 208                      const gchar *key,
 209                      gint        *value)
 210 {
 211         gchar *string_value;
 212         gchar *endptr;
 213         gint   int_value;
 214
 215         if (!ev_metadata_get_string (metadata, key, &string_value))
 216                 return FALSE;
 217
 218         int_value = g_ascii_strtoull (string_value, &endptr, 0);
 219         if (int_value == 0 && string_value == endptr)
 220                 return FALSE;
 221
 222         *value = int_value;
 223         return TRUE;
 224 }
 225
 226 gboolean
 227 ev_metadata_set_int (EvMetadata  *metadata,
 228                      const gchar *key,
 229                      gint         value)
 230 {
 231         gchar string_value[32];
 232
 233         g_snprintf (string_value, sizeof (string_value), "%d", value);
 234
 235         return ev_metadata_set_string (metadata, key, string_value);
 236 }
 237
 238 gboolean
 239 ev_metadata_get_double (EvMetadata  *metadata,
 240                         const gchar *key,
 241                         gdouble     *value)
 242 {
 243         gchar  *string_value;
 244         gchar  *endptr;
 245         gdouble double_value;
 246
 247         if (!ev_metadata_get_string (metadata, key, &string_value))
 248                 return FALSE;
 249
 250         double_value = g_ascii_strtod (string_value, &endptr);
 251         if (double_value == 0. && string_value == endptr)
 252                 return FALSE;
 253
 254         *value = double_value;
 255         return TRUE;
 256 }
 257
 258 gboolean
 259 ev_metadata_set_double (EvMetadata  *metadata,
 260                         const gchar *key,
 261                         gdouble      value)
 262 {
 263         gchar string_value[G_ASCII_DTOSTR_BUF_SIZE];
 264
 265         g_ascii_dtostr (string_value, G_ASCII_DTOSTR_BUF_SIZE, value);
 266
 267         return ev_metadata_set_string (metadata, key, string_value);
 268 }
 269
 270 gboolean
 271 ev_metadata_get_boolean (EvMetadata  *metadata,
 272                          const gchar *key,
 273                          gboolean    *value)
 274 {
 275         gint int_value;
 276
 277         if (!ev_metadata_get_int (metadata, key, &int_value))
 278                 return FALSE;
 279
 280         *value = int_value;
 281         return TRUE;
 282 }
 283
 284 gboolean
 285 ev_metadata_set_boolean (EvMetadata  *metadata,
 286                          const gchar *key,
 287                          gboolean     value)
 288 {
 289         return ev_metadata_set_string (metadata, key, value ? "1" : "0");
 290 }
 291
 292 gboolean
 293 ev_is_metadata_supported_for_file (GFile *file)
 294 {
 295         GFileAttributeInfoList *namespaces;
 296         gint i;
 297         gboolean retval = FALSE;
 298
 299         namespaces = g_file_query_writable_namespaces (file, NULL, NULL);
 300         if (!namespaces)
 301                 return retval;
 302
 303         for (i = 0; i < namespaces->n_infos; i++) {
 304                 if (strcmp (namespaces->infos[i].name, "metadata") == 0) {
 305                         retval = TRUE;
 306                         break;
 307                 }
 308         }
 309
 310         g_file_attribute_info_list_unref (namespaces);
 311
 312         return retval;
 313 }