]> www.fi.muni.cz Git - evince.git/blob - shell/ev-metadata.c
Updated list of documenters in about dialog
[evince.git] / 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 }