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         int result;
 291
 292         document = get_document_from_uri (uri, FALSE, error);
 293
 294         if (*error != NULL) {
 295                 return NULL;
 296         }
 297
 298         result = ev_document_load (document, uri, error);
 299
 300         if (result == FALSE || *error) {
 301                 if (document)
 302                         g_object_unref (document);
 303                 document = NULL;
 304         } else {
 305                 return document;
 306         }
 307
 308         if (*error)
 309                 g_error_free (*error);
 310         *error = NULL;
 311
 312         document = get_document_from_uri (uri, TRUE, error);
 313
 314         if (*error != NULL) {
 315                 return NULL;
 316         }
 317
 318         result = ev_document_load (document, uri, error);
 319
 320         if (result == FALSE || *error) {
 321                 if (document)
 322                         g_object_unref (document);
 323                 document = NULL;
 324         }
 325
 326         if (result == FALSE && *error == NULL)  {
 327                 g_set_error (error,
 328                              EV_DOCUMENT_ERROR,
 329                              0,
 330                              _("Unknown MIME Type"));
 331         }
 332
 333         return document;
 334 }
 335
 336 static void
 337 file_filter_add_mime_list_and_free (GtkFileFilter *filter, GList *mime_types)
 338 {
 339         GList *l;
 340
 341         for (l = mime_types; l != NULL; l = l->next) {
 342                 gtk_file_filter_add_mime_type (filter, l->data);
 343         }
 344
 345         g_list_foreach (mime_types, (GFunc)g_free, NULL);
 346         g_list_free (mime_types);
 347 }
 348
 349 void
 350 ev_document_factory_add_filters (GtkWidget *chooser, EvDocument *document)
 351 {
 352         EvBackend backend = 0;
 353         GList *mime_types;
 354         GtkFileFilter *filter;
 355         GtkFileFilter *default_filter;
 356         GtkFileFilter *document_filter;
 357
 358         if (document != NULL) {
 359                 backend = ev_document_factory_get_backend (document);
 360         }
 361
 362         default_filter = document_filter = filter = gtk_file_filter_new ();
 363         gtk_file_filter_set_name (filter, _("All Documents"));
 364         mime_types = ev_document_factory_get_all_mime_types ();
 365         file_filter_add_mime_list_and_free (filter, mime_types);
 366         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 367
 368 #ifdef ENABLE_PS
 369         if (document == NULL || backend == EV_BACKEND_PS) {
 370                 default_filter = filter = gtk_file_filter_new ();
 371                 gtk_file_filter_set_name (filter, _("PostScript Documents"));
 372                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_PS);
 373                 file_filter_add_mime_list_and_free (filter, mime_types);
 374                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 375         }
 376 #endif
 377
 378         if (document == NULL || backend == EV_BACKEND_PDF) {
 379                 default_filter = filter = gtk_file_filter_new ();
 380                 gtk_file_filter_set_name (filter, _("PDF Documents"));
 381                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_PDF);
 382                 file_filter_add_mime_list_and_free (filter, mime_types);
 383                 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 384         }
 385
 386 #ifdef ENABLE_PIXBUF
 387         if (document == NULL || backend == EV_BACKEND_PIXBUF) {
 388                 default_filter = filter = gtk_file_filter_new ();
 389                 gtk_file_filter_set_name (filter, _("Images"));
 390                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_PIXBUF);
 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_DVI
 397         if (document == NULL || backend == EV_BACKEND_DVI) {
 398                 default_filter = filter = gtk_file_filter_new ();
 399                 gtk_file_filter_set_name (filter, _("DVI Documents"));
 400                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_DVI);
 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_DJVU
 407         if (document == NULL || backend == EV_BACKEND_DJVU) {
 408                 default_filter = filter = gtk_file_filter_new ();
 409                 gtk_file_filter_set_name (filter, _("Djvu Documents"));
 410                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_DJVU);
 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_COMICS
 417         if (document == NULL || backend == EV_BACKEND_COMICS) {
 418                 default_filter = filter = gtk_file_filter_new ();
 419                 gtk_file_filter_set_name (filter, _("Comic Books"));
 420                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_COMICS);
 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_IMPRESS
 427         if (document == NULL || backend == EV_BACKEND_IMPRESS) {
 428                 default_filter = filter = gtk_file_filter_new ();
 429                 gtk_file_filter_set_name (filter, _("Impress Slides"));
 430                 mime_types = ev_document_factory_get_mime_types (EV_BACKEND_IMPRESS);
 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         filter = gtk_file_filter_new ();
 437         gtk_file_filter_set_name (filter, _("All Files"));
 438         gtk_file_filter_add_pattern (filter, "*");
 439         gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 440
 441         gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser),
 442                                      document == NULL ? document_filter : default_filter);
 443 }