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 "ev-document-factory.h"
  26
  27 /* The various document type backends: */
  28 #ifdef ENABLE_PDF
  29 #include "ev-poppler.h"
  30 #endif
  31 #ifdef ENABLE_PS
  32 #include "ps-document.h"
  33 #endif
  34 #ifdef ENABLE_TIFF
  35 #include "tiff-document.h"
  36 #endif
  37 #ifdef ENABLE_DVI
  38 #include "dvi-document.h"
  39 #endif
  40 #ifdef ENABLE_PIXBUF
  41 #include "pixbuf-document.h"
  42 #endif
  43 #ifdef ENABLE_DJVU
  44 #include "djvu-document.h"
  45 #endif
  46 #ifdef ENABLE_COMICS
  47 #include "comics-document.h"
  48 #endif
  49 #ifdef ENABLE_IMPRESS
  50 #include "impress-document.h"
  51 #endif
  52
  53 #include <string.h>
  54 #include <glib/gi18n.h>
  55 #include <libgnomevfs/gnome-vfs-mime-utils.h>
  56 #include <libgnomevfs/gnome-vfs-file-info.h>
  57 #include <libgnomevfs/gnome-vfs-ops.h>
  58 #include <gtk/gtkfilechooserdialog.h>
  59
  60 typedef struct _EvDocumentType EvDocumentType;
  61 struct _EvDocumentType
  62 {
  63         const char *mime_type;
  64         EvBackend backend;
  65         GType (*document_type_factory_callback)();
  66 };
  67
  68 const EvDocumentType document_types[] = {
  69 #ifdef ENABLE_PDF
  70         /* PDF: */
  71         {"application/pdf",            EV_BACKEND_PDF,  pdf_document_get_type},
  72 #endif
  73
  74 #ifdef ENABLE_PS
  75         /* Postscript: */
  76         {"application/postscript",     EV_BACKEND_PS,   ps_document_get_type},
  77         {"application/x-gzpostscript", EV_BACKEND_PS,   ps_document_get_type},
  78         {"image/x-eps",                EV_BACKEND_PS,   ps_document_get_type},
  79 #endif
  80
  81 #ifdef ENABLE_TIFF
  82         /* Tiff: */
  83         {"image/tiff",                 EV_BACKEND_TIFF, tiff_document_get_type},
  84 #endif
  85
  86 #ifdef ENABLE_DJVU
  87         /* djvu: */
  88         {"image/vnd.djvu",             EV_BACKEND_DJVU, djvu_document_get_type},
  89 #endif
  90
  91 #ifdef ENABLE_DVI
  92         /* dvi: */
  93         {"application/x-dvi",          EV_BACKEND_DVI,  dvi_document_get_type},
  94 #endif
  95
  96 #ifdef ENABLE_COMICS
  97         /* cbr/cbz: */
  98         {"application/x-cbr",           EV_BACKEND_COMICS,  comics_document_get_type},
  99         {"application/x-cbz",           EV_BACKEND_COMICS,  comics_document_get_type},
 100 #endif
 101
 102 #ifdef ENABLE_IMPRESS
 103         /* Impress slides: */
 104         {"application/vnd.sun.xml.impress", EV_BACKEND_IMPRESS, impress_document_get_type},
 105         {"application/vnd.oasis.opendocument.presentation", EV_BACKEND_IMPRESS, impress_document_get_type},
 106 #endif
 107
 108 };
 109
 110 #ifdef ENABLE_PIXBUF
 111
 112 static GList*
 113 gdk_pixbuf_mime_type_list ()
 114 {
 115         GSList *formats, *list;
 116         GList *result;
 117
 118         formats = gdk_pixbuf_get_formats ();
 119         result = NULL;
 120
 121         for (list = formats; list != NULL; list = list->next) {
 122                 GdkPixbufFormat *format = list->data;
 123                 int i;
 124                 gchar **mime_types;
 125
 126                 if (gdk_pixbuf_format_is_disabled (format))
 127                         continue;
 128
 129                 mime_types = gdk_pixbuf_format_get_mime_types (format);
 130
 131                 for (i = 0; mime_types[i] != NULL; i++) {
 132                         result = g_list_append (result, mime_types[i]);
 133                 }
 134         }
 135         g_slist_free (formats);
 136
 137         return result;
 138 }
 139
 140 /* Would be nice to have this in gdk-pixbuf */
 141 static gboolean
 142 mime_type_supported_by_gdk_pixbuf (const gchar *mime_type)
 143 {
 144         GList *mime_types;
 145         GList *list;
 146         gboolean retval = FALSE;
 147
 148         mime_types = gdk_pixbuf_mime_type_list ();
 149         for (list = mime_types; list; list = list->next) {
 150                 if (strcmp ((char *)list->data, mime_type) == 0) {
 151                         retval = TRUE;
 152                         break;
 153                 }
 154         }
 155
 156         g_list_foreach (mime_types, (GFunc)g_free, NULL);
 157         g_list_free (mime_types);
 158
 159         return retval;
 160 }
 161 #endif
 162
 163 static EvDocument*
 164 ev_document_factory_get_from_mime (const char *mime_type)
 165 {
 166         int i;
 167         GType type = G_TYPE_INVALID;
 168         EvDocument *document = NULL;
 169
 170         g_return_val_if_fail (mime_type, G_TYPE_INVALID);
 171
 172         for (i = 0; i < G_N_ELEMENTS (document_types); i++) {
 173                 if (strcmp (mime_type, document_types[i].mime_type) == 0) {
 174                         g_assert (document_types[i].document_type_factory_callback != NULL);
 175                         type = document_types[i].document_type_factory_callback();
 176                         break;
 177                 }
 178         }
 179 #ifdef ENABLE_PIXBUF
 180         if (type == G_TYPE_INVALID && mime_type_supported_by_gdk_pixbuf (mime_type)) {
 181                 type = pixbuf_document_get_type ();
 182         }
 183 #endif
 184         if (type != G_TYPE_INVALID) {
 185                 document = g_object_new (type, NULL);
 186         }
 187
 188         return document;
 189 }
 190
 191 EvBackend
 192 ev_document_factory_get_backend (EvDocument *document)
 193 {
 194         int i;
 195
 196         for (i = 0; i < G_N_ELEMENTS (document_types); i++) {
 197                 GType type = document_types[i].document_type_factory_callback ();
 198                 if (type == G_TYPE_FROM_INSTANCE (document)) {
 199                         return  document_types[i].backend;
 200                 }
 201         }
 202
 203 #ifdef ENABLE_PIXBUF
 204         if (G_TYPE_FROM_INSTANCE (document) == pixbuf_document_get_type ())
 205                 return EV_BACKEND_PIXBUF;
 206 #endif
 207         g_assert_not_reached ();
 208
 209         return 0;
 210 }
 211
 212 static GList *
 213 ev_document_factory_get_mime_types (EvBackend backend)
 214 {
 215         GList *types = NULL;
 216         int i;
 217
 218 #ifdef ENABLE_PIXBUF
 219         if (backend == EV_BACKEND_PIXBUF) {
 220                 return gdk_pixbuf_mime_type_list ();
 221         }
 222 #endif
 223
 224         for (i = 0; i < G_N_ELEMENTS (document_types); i++) {
 225                 if (document_types[i].backend == backend) {
 226                         types = g_list_append (types, g_strdup (document_types[i].mime_type));
 227                 }
 228         }
 229
 230         return types;
 231 }
 232
 233 static GList *
 234 ev_document_factory_get_all_mime_types (void)
 235 {
 236         GList *types = NULL;
 237         int i;
 238
 239         for (i = 0; i < G_N_ELEMENTS (document_types); i++) {
 240                 types = g_list_append (types, g_strdup (document_types[i].mime_type));
 241         }
 242
 243 #ifdef ENABLE_PIXBUF
 244         types = g_list_concat (types, gdk_pixbuf_mime_type_list ());
 245 #endif
 246
 247         return types;
 248 }
 249
 250 static EvDocument *
 251 get_document_from_uri (const char *uri, gboolean slow, GError **error)
 252 {
 253         EvDocument *document = NULL;
 254
 255         GnomeVFSFileInfo *info;
 256         GnomeVFSResult result;
 257
 258         info = gnome_vfs_file_info_new ();
 259         result = gnome_vfs_get_file_info (uri, info,
 260                                           GNOME_VFS_FILE_INFO_GET_MIME_TYPE |
 261                                           GNOME_VFS_FILE_INFO_FOLLOW_LINKS |
 262                                           (slow ? GNOME_VFS_FILE_INFO_FORCE_SLOW_MIME_TYPE : 0));
 263         if (result != GNOME_VFS_OK) {
 264                 g_set_error (error,
 265                              EV_DOCUMENT_ERROR,
 266                              0,
 267                              gnome_vfs_result_to_string (result));
 268                 gnome_vfs_file_info_unref (info);
 269                 return NULL;
 270         }
 271
 272         if (info->mime_type == NULL) {
 273                 g_set_error (error,
 274                              EV_DOCUMENT_ERROR,
 275                              0,
 276                              _("Unknown MIME Type"));
 277                 gnome_vfs_file_info_unref (info);
 278                 return NULL;
 279         }
 280
 281         document = ev_document_factory_get_from_mime (info->mime_type);
 282
 283         if (document == NULL) {
 284                 g_set_error (error,
 285                              EV_DOCUMENT_ERROR,
 286                              0,
 287                              _("Unhandled MIME type: “%s”"), info->mime_type);
 288                 gnome_vfs_file_info_unref (info);
 289                 return NULL;
 290         }
 291
 292         gnome_vfs_file_info_unref (info);
 293
 294         return document;
 295 }
 296
 297 EvDocument *
 298 ev_document_factory_get_document (const char *uri, GError **error)
 299 {
 300         EvDocument *document;
 301         int result;
 302
 303         document = get_document_from_uri (uri, FALSE, error);
 304
 305         if (*error == NULL) {
 306                 result = ev_document_load (document, uri, error);
 307
 308                 if (result == FALSE || *error) {
 309                         if (*error &&
 310                             (*error)->domain == EV_DOCUMENT_ERROR &&
 311                             (*error)->code == EV_DOCUMENT_ERROR_ENCRYPTED)
 312                                 return document;
 313                 } else {
 314                         return document;
 315                 }
 316         }
 317
 318         /* Try again with slow mime detection */
 319         if (document)
 320                 g_object_unref (document);
 321         document = NULL;
 322
 323         if (*error)
 324                 g_error_free (*error);
 325         *error = NULL;
 326
 327         document = get_document_from_uri (uri, TRUE, error);
 328
 329         if (*error != NULL) {
 330                 return NULL;
 331         }
 332
 333         result = ev_document_load (document, uri, error);
 334
 335         if (result == FALSE) {
 336                 if (*error == NULL) {
 337                         g_set_error (error,
 338                                      EV_DOCUMENT_ERROR,
 339                                      0,
 340                                      _("Unknown MIME Type"));
 341                 } else if ((*error)->domain == EV_DOCUMENT_ERROR &&
 342                            (*error)->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
 343                         return document;
 344                 }
 345
 346                 if (document)
 347                         g_object_unref (document);
 348                 document = NULL;
 349         }
 350
 351         return document;
 352 }
 353
 354 static void
 355 file_filter_add_mime_list_and_free (GtkFileFilter *filter, GList *mime_types)
 356 {
 357         GList *l;
 358
 359         for (l = mime_types; l != NULL; l = l->next) {
 360                 gtk_file_filter_add_mime_type (filter, l->data);
 361         }
 362
 363         g_list_foreach (mime_types, (GFunc)g_free, NULL);
 364         g_list_free (mime_types);
 365 }
 366
 367 void
 368 ev_document_factory_add_filters (GtkWidget *chooser, EvDocument *document)
 369 {
 370         EvBackend backend = 0;
 371         GList *mime_types;
 372         GtkFileFilter *filter;
 373         GtkFileFilter *default_filter;
 374         GtkFileFilter *document_filter;
 375
 376         if (document != NULL) {
 377                 backend = ev_document_factory_get_backend (document);
 378         }
 379
 380         default_filter = document_filter = filter = gtk_file_filter_new ();
 381         gtk_file_filter_set_name (filter, _("All Documents"));
 382         mime_types = ev_document_factory_get_all_mime_types ();
 383         file_filter_add_mime_list_and_free (filter, mime_types);
 384         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 385
 386 #ifdef ENABLE_PS
 387         if (document == NULL || backend == EV_BACKEND_PS) {
 388                 default_filter = filter = gtk_file_filter_new ();
 389                 gtk_file_filter_set_name (filter, _("PostScript Documents"));
 390                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_PS);
 391                 file_filter_add_mime_list_and_free (filter, mime_types);
 392                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 393         }
 394 #endif
 395
 396 #ifdef ENABLE_PDF
 397         if (document == NULL || backend == EV_BACKEND_PDF) {
 398                 default_filter = filter = gtk_file_filter_new ();
 399                 gtk_file_filter_set_name (filter, _("PDF Documents"));
 400                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_PDF);
 401                 file_filter_add_mime_list_and_free (filter, mime_types);
 402                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 403         }
 404 #endif
 405
 406 #ifdef ENABLE_PIXBUF
 407         if (document == NULL || backend == EV_BACKEND_PIXBUF) {
 408                 default_filter = filter = gtk_file_filter_new ();
 409                 gtk_file_filter_set_name (filter, _("Images"));
 410                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_PIXBUF);
 411                 file_filter_add_mime_list_and_free (filter, mime_types);
 412                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 413         }
 414 #endif
 415
 416 #ifdef ENABLE_DVI
 417         if (document == NULL || backend == EV_BACKEND_DVI) {
 418                 default_filter = filter = gtk_file_filter_new ();
 419                 gtk_file_filter_set_name (filter, _("DVI Documents"));
 420                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_DVI);
 421                 file_filter_add_mime_list_and_free (filter, mime_types);
 422                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 423         }
 424 #endif
 425
 426 #ifdef ENABLE_DJVU
 427         if (document == NULL || backend == EV_BACKEND_DJVU) {
 428                 default_filter = filter = gtk_file_filter_new ();
 429                 gtk_file_filter_set_name (filter, _("Djvu Documents"));
 430                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_DJVU);
 431                 file_filter_add_mime_list_and_free (filter, mime_types);
 432                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 433         }
 434 #endif
 435
 436 #ifdef ENABLE_COMICS
 437         if (document == NULL || backend == EV_BACKEND_COMICS) {
 438                 default_filter = filter = gtk_file_filter_new ();
 439                 gtk_file_filter_set_name (filter, _("Comic Books"));
 440                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_COMICS);
 441                 file_filter_add_mime_list_and_free (filter, mime_types);
 442                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 443         }
 444 #endif
 445
 446 #ifdef ENABLE_IMPRESS
 447         if (document == NULL || backend == EV_BACKEND_IMPRESS) {
 448                 default_filter = filter = gtk_file_filter_new ();
 449                 gtk_file_filter_set_name (filter, _("Impress Slides"));
 450                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_IMPRESS);
 451                 file_filter_add_mime_list_and_free (filter, mime_types);
 452                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 453         }
 454 #endif
 455
 456         filter = gtk_file_filter_new ();
 457         gtk_file_filter_set_name (filter, _("All Files"));
 458         gtk_file_filter_add_pattern (filter, "*");
 459         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 460
 461         gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser),
 462                                      document == NULL ? document_filter : default_filter);
 463 }