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