comics/comics-document.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */
   2 /*
   3  * Copyright (C) 2005, Teemu Tervo <teemu.tervo@gmx.net>
   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 #include <unistd.h>
  21 #include <string.h>
  22 #include <glib/gi18n.h>
  23 #include <libgnomevfs/gnome-vfs-mime-utils.h>
  24 #include <libgnomevfs/gnome-vfs-xfer.h>
  25
  26 #include "comics-document.h"
  27 #include "ev-document-misc.h"
  28 #include "ev-document-thumbnails.h"
  29
  30 struct _ComicsDocumentClass
  31 {
  32         GObjectClass parent_class;
  33 };
  34
  35 struct _ComicsDocument
  36 {
  37         GObject parent_instance;
  38
  39         gchar  *archive;
  40         GSList *page_names;
  41         int     n_pages;
  42         char   *extract_command;
  43 };
  44
  45 typedef struct _ComicsDocumentClass ComicsDocumentClass;
  46
  47 static void       comics_document_document_iface_init (EvDocumentIface *iface);
  48 static void       comics_document_document_thumbnails_iface_init (EvDocumentThumbnailsIface *iface);
  49
  50 static GSList*    get_supported_image_extensions (void);
  51 static void       get_page_size_area_prepared_cb (GdkPixbufLoader *loader,
  52                                                   gpointer data);
  53 static void       render_pixbuf_size_prepared_cb (GdkPixbufLoader *loader,
  54                                                   gint width,
  55                                                   gint height,
  56                                                   gpointer data);
  57 static char**     extract_argv                   (EvDocument *document,
  58                                                   gint page);
  59
  60
  61 G_DEFINE_TYPE_WITH_CODE (
  62         ComicsDocument, comics_document, G_TYPE_OBJECT,
  63         {
  64                 G_IMPLEMENT_INTERFACE (EV_TYPE_DOCUMENT,
  65                                        comics_document_document_iface_init);
  66                 G_IMPLEMENT_INTERFACE (EV_TYPE_DOCUMENT_THUMBNAILS,
  67                                        comics_document_document_thumbnails_iface_init);
  68         } );
  69
  70 static gboolean
  71 comics_document_load (EvDocument *document,
  72                       const char *uri,
  73                       GError    **error)
  74 {
  75         ComicsDocument *comics_document = COMICS_DOCUMENT (document);
  76         GSList *supported_extensions;
  77         gchar *list_files_command = NULL, *stdout, *quoted_file, *mime_type;
  78         gchar **cbr_files;
  79         gboolean success;
  80         int i, retval;
  81
  82         comics_document->archive = g_filename_from_uri (uri, NULL, error);
  83         g_return_val_if_fail (comics_document->archive != NULL, FALSE);
  84
  85         quoted_file = g_shell_quote (comics_document->archive);
  86         mime_type = gnome_vfs_get_mime_type (uri);
  87
  88         /* FIXME, use proper cbr/cbz mime types once they're
  89          * included in shared-mime-info */
  90         if (!strcmp (mime_type, "application/x-cbr")) {
  91                 comics_document->extract_command =
  92                         g_strdup ("unrar p -c- -ierr");
  93                 list_files_command =
  94                         g_strdup_printf ("unrar vb -c- -- %s", quoted_file);
  95         } else if (!strcmp (mime_type, "application/x-cbz")) {
  96                 comics_document->extract_command =
  97                         g_strdup ("unzip -p -C");
  98                 list_files_command =
  99                         g_strdup_printf ("zipinfo -1 -- %s", quoted_file);
 100         }
 101
 102         g_free (quoted_file);
 103
 104         /* Get list of files in archive */
 105         success = g_spawn_command_line_sync (list_files_command,
 106                                              &stdout, NULL, &retval, error);
 107         g_free (list_files_command);
 108
 109         if (!success) {
 110                 g_free (mime_type);
 111                 return FALSE;
 112         } else if (retval != 0) {
 113                 g_set_error (error,
 114                              EV_DOCUMENT_ERROR,
 115                              EV_DOCUMENT_ERROR_INVALID,
 116                              _("File corrupted."));
 117                 g_free (mime_type);
 118                 return FALSE;
 119         }
 120
 121         cbr_files = g_strsplit (stdout, "\n", 0);
 122         supported_extensions = get_supported_image_extensions ();
 123         for (i = 0; cbr_files[i] != NULL; i++) {
 124                 gchar *suffix = g_strrstr (cbr_files[i], ".");
 125                 if (!suffix)
 126                         continue;
 127                 suffix = g_ascii_strdown (suffix + 1, -1);
 128
 129                 if (g_slist_find_custom (supported_extensions, suffix,
 130                                          (GCompareFunc) strcmp) != NULL) {
 131                         comics_document->page_names =
 132                                 g_slist_insert_sorted (
 133                                         comics_document->page_names,
 134                                         g_strdup (g_strstrip (cbr_files[i])),
 135                                         (GCompareFunc) strcmp);
 136                         comics_document->n_pages++;
 137                 }
 138
 139                 g_free (suffix);
 140         }
 141
 142         g_free (stdout);
 143         g_free (mime_type);
 144         g_strfreev (cbr_files);
 145         g_slist_foreach (supported_extensions, (GFunc) g_free, NULL);
 146         g_slist_free (supported_extensions);
 147
 148         if (comics_document->n_pages == 0) {
 149                 g_set_error (error,
 150                              EV_DOCUMENT_ERROR,
 151                              EV_DOCUMENT_ERROR_INVALID,
 152                              _("No images found in archive %s"),
 153                              uri);
 154                 return FALSE;
 155         }
 156
 157         return TRUE;
 158 }
 159
 160
 161 static gboolean
 162 comics_document_save (EvDocument *document,
 163                       const char *uri,
 164                       GError    **error)
 165 {
 166         ComicsDocument *comics_document = COMICS_DOCUMENT (document);
 167         GnomeVFSURI *source, *target;
 168         GnomeVFSResult ret;
 169
 170         source = gnome_vfs_uri_new (comics_document->archive);
 171         target = gnome_vfs_uri_new (uri);
 172
 173         ret = gnome_vfs_xfer_uri (source, target,
 174                                   GNOME_VFS_XFER_DEFAULT,
 175                                   GNOME_VFS_XFER_ERROR_MODE_ABORT,
 176                                   GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE,
 177                                   NULL, NULL);
 178
 179         gnome_vfs_uri_unref (source);
 180         gnome_vfs_uri_unref (target);
 181
 182         return ret == GNOME_VFS_OK;
 183 }
 184
 185 static int
 186 comics_document_get_n_pages (EvDocument *document)
 187 {
 188         return COMICS_DOCUMENT (document)->n_pages;
 189 }
 190
 191 static void
 192 comics_document_get_page_size (EvDocument *document,
 193                                int         page,
 194                                double     *width,
 195                                double     *height)
 196 {
 197         GdkPixbufLoader *loader;
 198         char **argv;
 199         guchar buf[1024];
 200         gboolean success, got_size = FALSE;
 201         gint outpipe = -1;
 202         GPid child_pid = -1;
 203
 204         argv = extract_argv (document, page);
 205         success = g_spawn_async_with_pipes (NULL, argv, NULL,
 206                                             G_SPAWN_SEARCH_PATH | G_SPAWN_STDERR_TO_DEV_NULL,
 207                                             NULL, NULL,
 208                                             &child_pid,
 209                                             NULL, &outpipe, NULL, NULL);
 210         g_strfreev (argv);
 211         g_return_if_fail (success == TRUE);
 212
 213         loader = gdk_pixbuf_loader_new ();
 214         g_signal_connect (loader, "area-prepared",
 215                           G_CALLBACK (get_page_size_area_prepared_cb),
 216                           &got_size);
 217
 218         while (outpipe >= 0) {
 219                 gssize bytes = read (outpipe, buf, 1024);
 220
 221                 if (bytes > 0)
 222                         gdk_pixbuf_loader_write (loader, buf, bytes, NULL);
 223                 if (bytes <= 0 || got_size) {
 224                         close (outpipe);
 225                         outpipe = -1;
 226                         gdk_pixbuf_loader_close (loader, NULL);
 227                 }
 228         }
 229
 230         if (gdk_pixbuf_loader_get_pixbuf (loader)) {
 231                 GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
 232                 if (width)
 233                         *width = gdk_pixbuf_get_width (pixbuf);
 234                 if (height)
 235                         *height = gdk_pixbuf_get_height (pixbuf);
 236         }
 237
 238         g_spawn_close_pid (child_pid);
 239         g_object_unref (loader);
 240 }
 241
 242 static void
 243 get_page_size_area_prepared_cb (GdkPixbufLoader *loader,
 244                                 gpointer         data)
 245 {
 246         gboolean *got_size = data;
 247         *got_size = TRUE;
 248 }
 249
 250 static GdkPixbuf *
 251 comics_document_render_pixbuf (EvDocument  *document,
 252                                EvRenderContext *rc)
 253 {
 254         GdkPixbufLoader *loader;
 255         GdkPixbuf *rotated_pixbuf;
 256         char **argv;
 257         guchar buf[4096];
 258         gboolean success;
 259         gint outpipe = -1;
 260         GPid child_pid = -1;
 261
 262         argv = extract_argv (document, rc->page);
 263         success = g_spawn_async_with_pipes (NULL, argv, NULL,
 264                                             G_SPAWN_SEARCH_PATH
 265                                             | G_SPAWN_STDERR_TO_DEV_NULL,
 266                                             NULL, NULL,
 267                                             &child_pid,
 268                                             NULL, &outpipe, NULL, NULL);
 269         g_strfreev (argv);
 270         g_return_val_if_fail (success == TRUE, NULL);
 271
 272         loader = gdk_pixbuf_loader_new ();
 273         g_signal_connect (loader, "size-prepared",
 274                           G_CALLBACK (render_pixbuf_size_prepared_cb), &rc->scale);
 275
 276         while (outpipe >= 0) {
 277                 gssize bytes = read (outpipe, buf, 4096);
 278
 279                 if (bytes > 0) {
 280                         gdk_pixbuf_loader_write (loader, buf, bytes, NULL);
 281                 } else if (bytes <= 0) {
 282                         close (outpipe);
 283                         gdk_pixbuf_loader_close (loader, NULL);
 284                         outpipe = -1;
 285                 }
 286         }
 287
 288         rotated_pixbuf = gdk_pixbuf_rotate_simple (gdk_pixbuf_loader_get_pixbuf (loader),
 289                                                    360 - rc->rotation);
 290         g_spawn_close_pid (child_pid);
 291         g_object_unref (loader);
 292         return rotated_pixbuf;
 293 }
 294
 295 static void
 296 render_pixbuf_size_prepared_cb (GdkPixbufLoader *loader,
 297                                 gint             width,
 298                                 gint             height,
 299                                 gpointer         data)
 300 {
 301         double *scale = data;
 302         int w = width  * (*scale);
 303         int h = height * (*scale);
 304
 305         gdk_pixbuf_loader_set_size (loader, w, h);
 306 }
 307
 308 static void
 309 comics_document_finalize (GObject *object)
 310 {
 311         ComicsDocument *comics_document = COMICS_DOCUMENT (object);
 312
 313         if (comics_document->archive)
 314                 g_free (comics_document->archive);
 315
 316         if (comics_document->page_names) {
 317                 g_slist_foreach (comics_document->page_names,
 318                                  (GFunc) g_free, NULL);
 319                 g_slist_free (comics_document->page_names);
 320         }
 321
 322         if (comics_document->extract_command)
 323                 g_free (comics_document->extract_command);
 324
 325         G_OBJECT_CLASS (comics_document_parent_class)->finalize (object);
 326 }
 327
 328 static void
 329 comics_document_class_init (ComicsDocumentClass *klass)
 330 {
 331         GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 332         gobject_class->finalize = comics_document_finalize;
 333 }
 334
 335 static gboolean
 336 comics_document_can_get_text (EvDocument *document)
 337 {
 338         return FALSE;
 339 }
 340
 341 static EvDocumentInfo *
 342 comics_document_get_info (EvDocument *document)
 343 {
 344         EvDocumentInfo *info;
 345         info = g_new0 (EvDocumentInfo, 1);
 346         return info;
 347 }
 348
 349 static void
 350 comics_document_document_iface_init (EvDocumentIface *iface)
 351 {
 352         iface->load = comics_document_load;
 353         iface->save = comics_document_save;
 354         iface->can_get_text  = comics_document_can_get_text;
 355         iface->get_n_pages   = comics_document_get_n_pages;
 356         iface->get_page_size = comics_document_get_page_size;
 357         iface->render_pixbuf = comics_document_render_pixbuf;
 358         iface->get_info      = comics_document_get_info;
 359 }
 360
 361 static void
 362 comics_document_init (ComicsDocument *comics_document)
 363 {
 364         comics_document->archive = NULL;
 365         comics_document->page_names = NULL;
 366         comics_document->extract_command = NULL;
 367         comics_document->n_pages = 0;
 368 }
 369
 370 /* Returns a list of file extensions supported by gdk-pixbuf */
 371 static GSList*
 372 get_supported_image_extensions()
 373 {
 374         GSList *extensions = NULL;
 375         GSList *formats = gdk_pixbuf_get_formats ();
 376         GSList *l;
 377
 378         for (l = formats; l != NULL; l = l->next) {
 379                 int i;
 380                 gchar **ext = gdk_pixbuf_format_get_extensions (l->data);
 381
 382                 for (i = 0; ext[i] != NULL; i++) {
 383                         extensions = g_slist_append (extensions,
 384                                                      g_strdup (ext[i]));
 385                 }
 386
 387                 g_strfreev (ext);
 388         }
 389
 390         g_slist_free (formats);
 391         return extensions;
 392 }
 393
 394 static void
 395 comics_document_thumbnails_get_geometry (EvDocumentThumbnails *document,
 396                                          gint                  page,
 397                                          gint                  suggested_width,
 398                                          gint                 *width,
 399                                          gint                 *height,
 400                                          gdouble              *scale_factor)
 401 {
 402         gdouble orig_width, orig_height, scale;
 403
 404         comics_document_get_page_size (EV_DOCUMENT (document), page,
 405                                        &orig_width, &orig_height);
 406         scale = suggested_width / orig_width;
 407
 408         if (width)
 409                 *width = suggested_width;
 410         if (height)
 411                 *height = orig_height * scale;
 412         if (scale_factor)
 413                 *scale_factor = scale;
 414 }
 415
 416 static GdkPixbuf *
 417 comics_document_thumbnails_get_thumbnail (EvDocumentThumbnails *document,
 418                                         gint                  page,
 419                                         gint                  rotation,
 420                                         gint                  size,
 421                                         gboolean              border)
 422 {
 423         GdkPixbuf *thumbnail, *framed;
 424         gint thumb_width, thumb_height;
 425         gdouble scale;
 426         EvRenderContext *rc;
 427
 428         comics_document_thumbnails_get_geometry (document, page, size,
 429                                                  &thumb_width, &thumb_height,
 430                                                  &scale);
 431
 432         rc = ev_render_context_new (rotation, page, scale);
 433         thumbnail = comics_document_render_pixbuf (EV_DOCUMENT (document),
 434                                                    rc);
 435         g_object_unref (G_OBJECT (rc));
 436
 437         if (border) {
 438               GdkPixbuf *tmp_pixbuf = thumbnail;
 439               thumbnail = ev_document_misc_get_thumbnail_frame (-1, -1, 0, tmp_pixbuf);
 440               g_object_unref (tmp_pixbuf);
 441         }
 442
 443         return thumbnail;
 444 }
 445
 446 static void
 447 comics_document_thumbnails_get_dimensions (EvDocumentThumbnails *document,
 448                                            gint                  page,
 449                                            gint                  suggested_width,
 450                                            gint                  *width,
 451                                            gint                  *height)
 452 {
 453         comics_document_thumbnails_get_geometry (document, page,
 454                                                  suggested_width,
 455                                                  width, height, NULL);
 456 }
 457
 458 static void
 459 comics_document_document_thumbnails_iface_init (EvDocumentThumbnailsIface *iface)
 460 {
 461         iface->get_thumbnail = comics_document_thumbnails_get_thumbnail;
 462         iface->get_dimensions = comics_document_thumbnails_get_dimensions;
 463 }
 464
 465 static char**
 466 extract_argv (EvDocument *document, gint page)
 467 {
 468         ComicsDocument *comics_document = COMICS_DOCUMENT (document);
 469         char **argv;
 470         char *command_line, *quoted_archive, *quoted_filename;
 471
 472         quoted_archive = g_shell_quote (comics_document->archive);
 473         quoted_filename = g_shell_quote (
 474                 g_slist_nth_data (comics_document->page_names, page));
 475
 476         command_line = g_strdup_printf ("%s -- %s %s",
 477                                         comics_document->extract_command,
 478                                         quoted_archive,
 479                                         quoted_filename);
 480         g_shell_parse_argv (command_line, NULL, &argv, NULL);
 481
 482         g_free (command_line);
 483         g_free (quoted_archive);
 484         g_free (quoted_filename);
 485         return argv;
 486 }