]> www.fi.muni.cz Git - evince.git/blob - libdocument/ev-document-factory.c
e7c76b905f8ae1472643746d43e2c3225527c250
[evince.git] / libdocument / ev-document-factory.c
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
2 /*
3  *  Copyright (C) 2005, Red Hat, Inc. 
4  *
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License as published by
7  *  the Free Software Foundation; either version 2, or (at your option)
8  *  any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  *
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include <string.h>
26 #include <gio/gio.h>
27 #include <glib/gstdio.h>
28 #include <glib/gi18n.h>
29 #include <gtk/gtkfilechooserdialog.h>
30
31 #include "ev-backends-manager.h"
32 #include "ev-document-factory.h"
33 #include "ev-file-helpers.h"
34
35 #ifdef ENABLE_PIXBUF
36 static GList*
37 gdk_pixbuf_mime_type_list ()
38 {
39         GSList *formats, *list;
40         GList *result = NULL;
41
42         formats = gdk_pixbuf_get_formats ();
43         for (list = formats; list != NULL; list = list->next) {
44                 GdkPixbufFormat *format = list->data;
45                 gchar          **mime_types;
46
47                 if (gdk_pixbuf_format_is_disabled (format))
48                         continue;
49
50                 mime_types = gdk_pixbuf_format_get_mime_types (format);
51                 result = g_list_prepend (result, mime_types); 
52         }
53         g_slist_free (formats);
54
55         return result;
56 }
57
58 /* Would be nice to have this in gdk-pixbuf */
59 static gboolean
60 mime_type_supported_by_gdk_pixbuf (const gchar *mime_type)
61 {
62         GList *mime_types;
63         GList *list;
64         gboolean retval = FALSE;
65
66         mime_types = gdk_pixbuf_mime_type_list ();
67         for (list = mime_types; list; list = list->next) {
68                 gchar      **mtypes = (gchar **)list->data;
69                 const gchar *mtype;
70                 gint         i = 0;
71
72                 while ((mtype = mtypes[i++])) {
73                         if (strcmp (mtype, mime_type) == 0) {
74                                 retval = TRUE;
75                                 break;
76                         }
77                 }
78         }
79
80         g_list_foreach (mime_types, (GFunc)g_strfreev, NULL);
81         g_list_free (mime_types);
82
83         return retval;
84 }
85 #endif /* ENABLE_PIXBUF */
86
87 static EvCompressionType
88 get_compression_from_mime_type (const gchar *mime_type)
89 {
90         gchar type[3];
91         gchar *p;
92
93         if (!(p = g_strrstr (mime_type, "/")))
94                 return EV_COMPRESSION_NONE;
95
96         if (sscanf (++p, "x-%2s%*s", type) == 1) {
97                 if (g_ascii_strcasecmp (type, "gz") == 0)
98                         return EV_COMPRESSION_GZIP;
99                 else if (g_ascii_strcasecmp (type, "bz") == 0)
100                         return EV_COMPRESSION_BZIP2;
101         }
102
103         return EV_COMPRESSION_NONE;
104 }
105
106 static gchar *
107 get_mime_type_from_uri (const gchar *uri, GError **error)
108 {
109         GFile     *file;
110         GFileInfo *file_info;
111         gchar     *mime_type;
112
113         file = g_file_new_for_uri (uri);
114         file_info = g_file_query_info (file,
115                                        G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
116                                        0, NULL, error);
117         g_object_unref (file);
118
119         if (file_info == NULL)
120                 return NULL;
121
122         mime_type = g_strdup (g_file_info_get_content_type (file_info));
123         g_object_unref (file_info);
124
125         return mime_type;
126 }
127
128 static gchar *
129 get_mime_type_from_data (const gchar *uri, GError **error)
130 {
131         GFile            *file;
132         GFileInputStream *input_stream;
133         gssize            size_read;
134         guchar            buffer[1024];
135
136         file = g_file_new_for_uri (uri);
137         
138         input_stream = g_file_read (file, NULL, error);
139         if (!input_stream) {
140                 g_object_unref (file);
141                 return NULL;
142         }
143
144         size_read = g_input_stream_read (G_INPUT_STREAM (input_stream),
145                                          buffer, 1024, NULL, NULL);
146         g_input_stream_close (G_INPUT_STREAM (input_stream), NULL, error);
147
148         g_object_unref (file);
149
150         if (size_read == -1)
151                 return NULL;
152
153         return g_content_type_guess (NULL, /* no filename */
154                                      buffer, 1024,
155                                      NULL);
156 }
157
158 static EvDocument *
159 get_document_from_uri (const char        *uri,
160                        gboolean           slow,
161                        EvCompressionType *compression,
162                        GError           **error)
163 {
164         EvDocument *document = NULL;
165         gchar      *mime_type = NULL;
166
167         *compression = EV_COMPRESSION_NONE;
168
169         mime_type = slow ?
170                 get_mime_type_from_data (uri, error) :
171                 get_mime_type_from_uri (uri, error);
172
173         if (mime_type == NULL) {
174                 g_free (mime_type);
175
176                 if (*error == NULL) {
177                         g_set_error (error,
178                                      EV_DOCUMENT_ERROR,
179                                      0,
180                                      _("Unknown MIME Type"));
181                 }
182                 
183                 return NULL;
184         }
185
186         document = ev_backends_manager_get_document (mime_type);
187         
188 #ifdef ENABLE_PIXBUF
189         if (!document && mime_type_supported_by_gdk_pixbuf (mime_type))
190                 document = ev_backends_manager_get_document ("image/*");
191 #endif /* ENABLE_PIXBUF */
192
193         if (document == NULL) {
194                 gchar *mime_desc;
195
196                 mime_desc = g_content_type_get_description (mime_type);
197                 g_set_error (error,
198                              EV_DOCUMENT_ERROR, 
199                              0,
200                              _("File type %s (%s) is not supported"),
201                              mime_desc, mime_type);
202                 g_free (mime_desc);
203                 g_free (mime_type);
204
205                 return NULL;
206         }
207
208         *compression = get_compression_from_mime_type (mime_type);
209
210         g_free (mime_type);
211         
212         return document;
213 }
214
215 static void
216 free_uncompressed_uri (gchar *uri_unc)
217 {
218         if (!uri_unc)
219                 return;
220
221         ev_tmp_uri_unlink (uri_unc);
222         g_free (uri_unc);
223 }
224
225 EvDocument *
226 ev_document_factory_get_document (const char *uri, GError **error)
227 {
228         EvDocument *document;
229         int result;
230         EvCompressionType compression;
231         gchar *uri_unc = NULL;
232
233         document = get_document_from_uri (uri, FALSE, &compression, error);
234         if (*error == NULL) {
235                 uri_unc = ev_file_uncompress (uri, compression, error);
236                 if (uri_unc) {
237                         g_object_set_data_full (G_OBJECT (document),
238                                                 "uri-uncompressed",
239                                                 uri_unc,
240                                                 (GDestroyNotify) free_uncompressed_uri);
241                 }
242
243                 if (*error != NULL) {
244                         /* Error uncompressing file */
245                         if (document)
246                                 g_object_unref (document);
247                         return NULL;
248                 }
249
250                 result = ev_document_load (document, uri_unc ? uri_unc : uri, error);
251
252                 if (result == FALSE || *error) {
253                         if (*error &&
254                             (*error)->domain == EV_DOCUMENT_ERROR &&
255                             (*error)->code == EV_DOCUMENT_ERROR_ENCRYPTED)
256                                 return document;
257                 } else {
258                         return document;
259                 }
260         }
261         
262         /* Try again with slow mime detection */
263         if (document)
264                 g_object_unref (document);
265         document = NULL;
266
267         if (*error)
268                 g_error_free (*error);
269         *error = NULL;
270
271         uri_unc = NULL;
272
273         document = get_document_from_uri (uri, TRUE, &compression, error);
274
275         if (*error != NULL) {
276                 return NULL;
277         }
278
279         uri_unc = ev_file_uncompress (uri, compression, error);
280         if (uri_unc) {
281                 g_object_set_data_full (G_OBJECT (document),
282                                         "uri-uncompressed",
283                                         uri_unc,
284                                         (GDestroyNotify) free_uncompressed_uri);
285         }
286
287         if (*error != NULL) {
288                 /* Error uncompressing file */
289                 if (document)
290                         g_object_unref (document);
291                 return NULL;
292         }
293         
294         result = ev_document_load (document, uri_unc ? uri_unc : uri, error);
295
296         if (result == FALSE) {
297                 if (*error == NULL) {
298                         g_set_error (error,
299                                      EV_DOCUMENT_ERROR,
300                                      0,
301                                      _("Unknown MIME Type"));
302                 } else if ((*error)->domain == EV_DOCUMENT_ERROR &&
303                            (*error)->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
304                         return document;
305                 }
306
307                 if (document)
308                         g_object_unref (document);
309                 document = NULL;
310         }
311         
312         return document;
313 }
314
315 static void
316 file_filter_add_mime_types (EvTypeInfo *info, GtkFileFilter *filter)
317 {
318         const gchar *mime_type;
319         gint         i = 0;
320
321 #ifdef ENABLE_PIXBUF
322         if (g_ascii_strcasecmp (info->mime_types[0], "image/*") == 0) {
323                 GList *pixbuf_types, *l;
324
325                 pixbuf_types = gdk_pixbuf_mime_type_list ();
326                 for (l = pixbuf_types; l; l = g_list_next (l)) {
327                         gchar **mime_types = (gchar **)l->data;
328                         gint    j = 0;
329                         
330                         while ((mime_type = mime_types[j++]))
331                                 gtk_file_filter_add_mime_type (filter, mime_type);
332                         
333                         g_strfreev (mime_types);
334                 }
335                 g_list_free (pixbuf_types);
336
337                 return;
338         }
339 #endif /* ENABLE_PIXBUF */
340         
341         while ((mime_type = info->mime_types[i++]))
342                 gtk_file_filter_add_mime_type (filter, mime_type);
343 }
344
345 void 
346 ev_document_factory_add_filters (GtkWidget *chooser, EvDocument *document)
347 {
348         GList         *all_types;
349         GtkFileFilter *filter;
350         GtkFileFilter *default_filter;
351         GtkFileFilter *document_filter;
352
353         all_types = ev_backends_manager_get_all_types_info ();
354         
355         default_filter = document_filter = filter = gtk_file_filter_new ();
356         gtk_file_filter_set_name (filter, _("All Documents"));
357         g_list_foreach (all_types, (GFunc)file_filter_add_mime_types, filter);
358         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
359
360         if (document) {
361                 EvTypeInfo *info;
362
363                 info = ev_backends_manager_get_document_type_info (document);
364                 default_filter = filter = gtk_file_filter_new ();
365                 gtk_file_filter_set_name (filter, info->desc);
366                 file_filter_add_mime_types (info, filter);
367                 g_free (info);
368                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
369         } else {
370                 GList *l;
371
372                 for (l = all_types; l; l = g_list_next (l)){
373                         EvTypeInfo *info;
374
375                         info = (EvTypeInfo *)l->data;
376
377                         default_filter = filter = gtk_file_filter_new ();
378                         gtk_file_filter_set_name (filter, info->desc);
379                         file_filter_add_mime_types (info, filter);
380                         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
381                 }
382         }
383
384         g_list_foreach (all_types, (GFunc)g_free, NULL);
385         g_list_free (all_types);
386
387         filter = gtk_file_filter_new ();
388         gtk_file_filter_set_name (filter, _("All Files"));
389         gtk_file_filter_add_pattern (filter, "*");
390         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
391
392         gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser),
393                                      document == NULL ? document_filter : default_filter);
394 }