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