shell/ev-jobs.c

   1 #include "ev-jobs.h"
   2 #include "ev-job-queue.h"
   3 #include "ev-document-thumbnails.h"
   4 #include "ev-document-links.h"
   5 #include "ev-document-images.h"
   6 #include "ev-document-forms.h"
   7 #include "ev-file-exporter.h"
   8 #include "ev-document-factory.h"
   9 #include "ev-document-misc.h"
  10 #include "ev-file-helpers.h"
  11 #include "ev-document-fonts.h"
  12 #include "ev-async-renderer.h"
  13
  14 #include <errno.h>
  15 #include <glib/gstdio.h>
  16 #include <glib/gi18n.h>
  17 #include <unistd.h>
  18 #include <libgnomevfs/gnome-vfs-uri.h>
  19 #include <libgnomevfs/gnome-vfs-utils.h>
  20 #include <libgnomevfs/gnome-vfs-ops.h>
  21
  22 static void ev_job_init                 (EvJob               *job);
  23 static void ev_job_class_init           (EvJobClass          *class);
  24 static void ev_job_links_init           (EvJobLinks          *job);
  25 static void ev_job_links_class_init     (EvJobLinksClass     *class);
  26 static void ev_job_render_init          (EvJobRender         *job);
  27 static void ev_job_render_class_init    (EvJobRenderClass    *class);
  28 static void ev_job_thumbnail_init       (EvJobThumbnail      *job);
  29 static void ev_job_thumbnail_class_init (EvJobThumbnailClass *class);
  30 static void ev_job_load_init            (EvJobLoad           *job);
  31 static void ev_job_load_class_init      (EvJobLoadClass      *class);
  32 static void ev_job_save_init            (EvJobSave           *job);
  33 static void ev_job_save_class_init      (EvJobSaveClass      *class);
  34 static void ev_job_print_init           (EvJobPrint          *job);
  35 static void ev_job_print_class_init     (EvJobPrintClass     *class);
  36
  37 enum {
  38         FINISHED,
  39         LAST_SIGNAL
  40 };
  41
  42 enum {
  43         PAGE_READY,
  44         RENDER_LAST_SIGNAL
  45 };
  46
  47 static guint job_signals[LAST_SIGNAL] = { 0 };
  48 static guint job_render_signals[RENDER_LAST_SIGNAL] = { 0 };
  49
  50 G_DEFINE_TYPE (EvJob, ev_job, G_TYPE_OBJECT)
  51 G_DEFINE_TYPE (EvJobLinks, ev_job_links, EV_TYPE_JOB)
  52 G_DEFINE_TYPE (EvJobRender, ev_job_render, EV_TYPE_JOB)
  53 G_DEFINE_TYPE (EvJobThumbnail, ev_job_thumbnail, EV_TYPE_JOB)
  54 G_DEFINE_TYPE (EvJobFonts, ev_job_fonts, EV_TYPE_JOB)
  55 G_DEFINE_TYPE (EvJobLoad, ev_job_load, EV_TYPE_JOB)
  56 G_DEFINE_TYPE (EvJobSave, ev_job_save, EV_TYPE_JOB)
  57 G_DEFINE_TYPE (EvJobPrint, ev_job_print, EV_TYPE_JOB)
  58
  59 static void ev_job_init (EvJob *job) { /* Do Nothing */ }
  60
  61 static void
  62 ev_job_dispose (GObject *object)
  63 {
  64         EvJob *job;
  65
  66         job = EV_JOB (object);
  67
  68         if (job->document) {
  69                 g_object_unref (job->document);
  70                 job->document = NULL;
  71         }
  72
  73         (* G_OBJECT_CLASS (ev_job_parent_class)->dispose) (object);
  74 }
  75
  76 static void
  77 ev_job_class_init (EvJobClass *class)
  78 {
  79         GObjectClass *oclass;
  80
  81         oclass = G_OBJECT_CLASS (class);
  82
  83         oclass->dispose = ev_job_dispose;
  84
  85         job_signals [FINISHED] =
  86                 g_signal_new ("finished",
  87                               EV_TYPE_JOB,
  88                               G_SIGNAL_RUN_LAST,
  89                               G_STRUCT_OFFSET (EvJobClass, finished),
  90                               NULL, NULL,
  91                               g_cclosure_marshal_VOID__VOID,
  92                               G_TYPE_NONE, 0);
  93 }
  94
  95
  96 static void ev_job_links_init (EvJobLinks *job) { /* Do Nothing */ }
  97
  98 static void
  99 ev_job_links_dispose (GObject *object)
 100 {
 101         EvJobLinks *job;
 102
 103         job = EV_JOB_LINKS (object);
 104
 105         if (job->model) {
 106                 g_object_unref (job->model);
 107                 job->model = NULL;
 108         }
 109
 110         (* G_OBJECT_CLASS (ev_job_links_parent_class)->dispose) (object);
 111 }
 112
 113 static void
 114 ev_job_links_class_init (EvJobLinksClass *class)
 115 {
 116         GObjectClass *oclass;
 117
 118         oclass = G_OBJECT_CLASS (class);
 119
 120         oclass->dispose = ev_job_links_dispose;
 121 }
 122
 123
 124 static void ev_job_render_init (EvJobRender *job) { /* Do Nothing */ }
 125
 126 static void
 127 ev_job_render_dispose (GObject *object)
 128 {
 129         EvJobRender *job;
 130
 131         job = EV_JOB_RENDER (object);
 132
 133         if (job->surface) {
 134                 cairo_surface_destroy (job->surface);
 135                 job->surface = NULL;
 136         }
 137
 138         if (job->rc) {
 139                 g_object_unref (job->rc);
 140                 job->rc = NULL;
 141         }
 142
 143         if (job->selection) {
 144                 cairo_surface_destroy (job->selection);
 145                 job->selection = NULL;
 146         }
 147
 148         if (job->selection_region) {
 149                 gdk_region_destroy (job->selection_region);
 150                 job->selection_region = NULL;
 151         }
 152
 153         (* G_OBJECT_CLASS (ev_job_render_parent_class)->dispose) (object);
 154 }
 155
 156 static void
 157 ev_job_render_class_init (EvJobRenderClass *class)
 158 {
 159         GObjectClass *oclass;
 160
 161         oclass = G_OBJECT_CLASS (class);
 162
 163         job_render_signals [PAGE_READY] =
 164                 g_signal_new ("page-ready",
 165                               EV_TYPE_JOB_RENDER,
 166                               G_SIGNAL_RUN_LAST,
 167                               G_STRUCT_OFFSET (EvJobRenderClass, page_ready),
 168                               NULL, NULL,
 169                               g_cclosure_marshal_VOID__VOID,
 170                               G_TYPE_NONE, 0);
 171
 172         oclass->dispose = ev_job_render_dispose;
 173 }
 174
 175 static void ev_job_thumbnail_init (EvJobThumbnail *job) { /* Do Nothing */ }
 176
 177 static void
 178 ev_job_thumbnail_dispose (GObject *object)
 179 {
 180         EvJobThumbnail *job;
 181
 182         job = EV_JOB_THUMBNAIL (object);
 183
 184         if (job->thumbnail) {
 185                 g_object_unref (job->thumbnail);
 186                 job->thumbnail = NULL;
 187         }
 188
 189         if (job->rc) {
 190                 g_object_unref (job->rc);
 191                 job->rc = NULL;
 192         }
 193
 194         (* G_OBJECT_CLASS (ev_job_thumbnail_parent_class)->dispose) (object);
 195 }
 196
 197 static void
 198 ev_job_thumbnail_class_init (EvJobThumbnailClass *class)
 199 {
 200         GObjectClass *oclass;
 201
 202         oclass = G_OBJECT_CLASS (class);
 203
 204         oclass->dispose = ev_job_thumbnail_dispose;
 205 }
 206
 207 static void ev_job_print_init (EvJobPrint *job) { /* Do Nothing */ }
 208
 209 static void
 210 ev_job_print_dispose (GObject *object)
 211 {
 212         EvJobPrint *job;
 213
 214         job = EV_JOB_PRINT (object);
 215
 216         if (job->temp_file) {
 217                 g_unlink (job->temp_file);
 218                 g_free (job->temp_file);
 219                 job->temp_file = NULL;
 220         }
 221
 222         if (job->error) {
 223                 g_error_free (job->error);
 224                 job->error = NULL;
 225         }
 226
 227         if (job->ranges) {
 228                 g_free (job->ranges);
 229                 job->ranges = NULL;
 230                 job->n_ranges = 0;
 231         }
 232
 233         (* G_OBJECT_CLASS (ev_job_print_parent_class)->dispose) (object);
 234 }
 235
 236 static void
 237 ev_job_print_class_init (EvJobPrintClass *class)
 238 {
 239         GObjectClass *oclass;
 240
 241         oclass = G_OBJECT_CLASS (class);
 242
 243         oclass->dispose = ev_job_print_dispose;
 244 }
 245
 246 /* Public functions */
 247 void
 248 ev_job_finished (EvJob *job)
 249 {
 250         g_return_if_fail (EV_IS_JOB (job));
 251
 252         g_signal_emit (job, job_signals[FINISHED], 0);
 253 }
 254
 255 EvJob *
 256 ev_job_links_new (EvDocument *document)
 257 {
 258         EvJob *job;
 259
 260         job = g_object_new (EV_TYPE_JOB_LINKS, NULL);
 261         job->document = g_object_ref (document);
 262
 263         return job;
 264 }
 265
 266 void
 267 ev_job_links_run (EvJobLinks *job)
 268 {
 269         g_return_if_fail (EV_IS_JOB_LINKS (job));
 270
 271         ev_document_doc_mutex_lock ();
 272         job->model = ev_document_links_get_links_model (EV_DOCUMENT_LINKS (EV_JOB (job)->document));
 273         EV_JOB (job)->finished = TRUE;
 274         ev_document_doc_mutex_unlock ();
 275 }
 276
 277
 278 EvJob *
 279 ev_job_render_new (EvDocument      *document,
 280                    EvRenderContext *rc,
 281                    gint             width,
 282                    gint             height,
 283                    EvRectangle     *selection_points,
 284                    EvSelectionStyle selection_style,
 285                    GdkColor        *text,
 286                    GdkColor        *base,
 287                    gboolean         include_forms,
 288                    gboolean         include_links,
 289                    gboolean         include_images,
 290                    gboolean         include_text,
 291                    gboolean         include_selection)
 292 {
 293         EvJobRender *job;
 294
 295         g_return_val_if_fail (EV_IS_RENDER_CONTEXT (rc), NULL);
 296         if (include_selection)
 297                 g_return_val_if_fail (selection_points != NULL, NULL);
 298
 299         job = g_object_new (EV_TYPE_JOB_RENDER, NULL);
 300
 301         EV_JOB (job)->document = g_object_ref (document);
 302         job->rc = g_object_ref (rc);
 303         job->target_width = width;
 304         job->target_height = height;
 305         job->selection_style = selection_style;
 306         job->text = *text;
 307         job->base = *base;
 308         job->include_forms = include_forms;
 309         job->include_links = include_links;
 310         job->include_images = include_images;
 311         job->include_text = include_text;
 312         job->include_selection = include_selection;
 313
 314         if (include_selection)
 315                 job->selection_points = *selection_points;
 316
 317         if (EV_IS_ASYNC_RENDERER (document)) {
 318                 EV_JOB (job)->async = TRUE;
 319         }
 320
 321         return EV_JOB (job);
 322 }
 323
 324 static void
 325 render_finished_cb (EvDocument      *document,
 326                     GdkPixbuf       *pixbuf,
 327                     EvJobRender     *job)
 328 {
 329         g_signal_handlers_disconnect_by_func (EV_JOB (job)->document,
 330                                               render_finished_cb, job);
 331
 332         /* FIXME: ps backend should be ported to cairo */
 333         job->surface = ev_document_misc_surface_from_pixbuf (pixbuf);
 334         job->page_ready = TRUE;
 335         g_signal_emit (job, job_render_signals[PAGE_READY], 0);
 336         EV_JOB (job)->finished = TRUE;
 337         ev_job_finished (EV_JOB (job));
 338 }
 339
 340 static gboolean
 341 notify_page_ready (EvJobRender *job)
 342 {
 343         g_signal_emit (job, job_render_signals[PAGE_READY], 0);
 344
 345         return FALSE;
 346 }
 347
 348 static void
 349 ev_job_render_page_ready (EvJobRender *job)
 350 {
 351         job->page_ready = TRUE;
 352         g_idle_add_full (G_PRIORITY_HIGH_IDLE,
 353                          (GSourceFunc)notify_page_ready,
 354                          g_object_ref (job),
 355                          (GDestroyNotify)g_object_unref);
 356 }
 357
 358 void
 359 ev_job_render_run (EvJobRender *job)
 360 {
 361         g_return_if_fail (EV_IS_JOB_RENDER (job));
 362
 363         ev_document_doc_mutex_lock ();
 364
 365         if (EV_JOB (job)->async) {
 366                 EvAsyncRenderer *renderer = EV_ASYNC_RENDERER (EV_JOB (job)->document);
 367                 ev_async_renderer_render_pixbuf (renderer, job->rc->page, job->rc->scale,
 368                                                  job->rc->rotation);
 369                 g_signal_connect (EV_JOB (job)->document, "render_finished",
 370                                   G_CALLBACK (render_finished_cb), job);
 371         } else {
 372                 ev_document_fc_mutex_lock ();
 373
 374                 job->surface = ev_document_render (EV_JOB (job)->document, job->rc);
 375                 if (job->include_selection && EV_IS_SELECTION (EV_JOB (job)->document)) {
 376                         ev_selection_render_selection (EV_SELECTION (EV_JOB (job)->document),
 377                                                        job->rc,
 378                                                        &(job->selection),
 379                                                        &(job->selection_points),
 380                                                        NULL,
 381                                                        job->selection_style,
 382                                                        &(job->text), &(job->base));
 383                         job->selection_region =
 384                                 ev_selection_get_selection_region (EV_SELECTION (EV_JOB (job)->document),
 385                                                                    job->rc,
 386                                                                    job->selection_style,
 387                                                                    &(job->selection_points));
 388                 }
 389
 390                 ev_job_render_page_ready (job);
 391
 392                 ev_document_fc_mutex_unlock ();
 393
 394                 if (job->include_text && EV_IS_SELECTION (EV_JOB (job)->document))
 395                         job->text_mapping =
 396                                 ev_selection_get_selection_map (EV_SELECTION (EV_JOB (job)->document),
 397                                                                 job->rc);
 398                 if (job->include_links && EV_IS_DOCUMENT_LINKS (EV_JOB (job)->document))
 399                         job->link_mapping =
 400                                 ev_document_links_get_links (EV_DOCUMENT_LINKS (EV_JOB (job)->document),
 401                                                              job->rc->page);
 402                 if (job->include_forms && EV_IS_DOCUMENT_FORMS (EV_JOB (job)->document))
 403                         job->form_field_mapping =
 404                                 ev_document_forms_get_form_fields (EV_DOCUMENT_FORMS (EV_JOB(job)->document),
 405                                                                    job->rc->page);
 406                 if (job->include_images && EV_IS_DOCUMENT_IMAGES (EV_JOB (job)->document))
 407                         job->image_mapping =
 408                                 ev_document_images_get_images (EV_DOCUMENT_IMAGES (EV_JOB (job)->document),
 409                                                                job->rc->page);
 410                 EV_JOB (job)->finished = TRUE;
 411         }
 412
 413         ev_document_doc_mutex_unlock ();
 414 }
 415
 416 EvJob *
 417 ev_job_thumbnail_new (EvDocument      *document,
 418                       EvRenderContext *rc)
 419 {
 420         EvJobThumbnail *job;
 421
 422         job = g_object_new (EV_TYPE_JOB_THUMBNAIL, NULL);
 423
 424         EV_JOB (job)->document = g_object_ref (document);
 425         job->rc = g_object_ref (rc);
 426
 427         return EV_JOB (job);
 428 }
 429
 430 void
 431 ev_job_thumbnail_run (EvJobThumbnail *job)
 432 {
 433         g_return_if_fail (EV_IS_JOB_THUMBNAIL (job));
 434
 435         ev_document_doc_mutex_lock ();
 436
 437         job->thumbnail =
 438                 ev_document_thumbnails_get_thumbnail (EV_DOCUMENT_THUMBNAILS (EV_JOB (job)->document),
 439                                                       job->rc, TRUE);
 440         EV_JOB (job)->finished = TRUE;
 441
 442         ev_document_doc_mutex_unlock ();
 443 }
 444
 445 static void ev_job_fonts_init (EvJobFonts *job) { /* Do Nothing */ }
 446
 447 static void ev_job_fonts_class_init (EvJobFontsClass *class) { /* Do Nothing */ }
 448
 449 EvJob *
 450 ev_job_fonts_new (EvDocument *document)
 451 {
 452         EvJobFonts *job;
 453
 454         job = g_object_new (EV_TYPE_JOB_FONTS, NULL);
 455
 456         EV_JOB (job)->document = g_object_ref (document);
 457
 458         return EV_JOB (job);
 459 }
 460
 461 void
 462 ev_job_fonts_run (EvJobFonts *job)
 463 {
 464         EvDocumentFonts *fonts;
 465
 466         g_return_if_fail (EV_IS_JOB_FONTS (job));
 467
 468         ev_document_doc_mutex_lock ();
 469
 470         fonts = EV_DOCUMENT_FONTS (EV_JOB (job)->document);
 471         ev_document_fc_mutex_lock ();
 472         job->scan_completed = !ev_document_fonts_scan (fonts, 20);
 473         ev_document_fc_mutex_unlock ();
 474
 475         EV_JOB (job)->finished = TRUE;
 476
 477         ev_document_doc_mutex_unlock ();
 478 }
 479
 480 static void ev_job_load_init (EvJobLoad *job) { /* Do Nothing */ }
 481
 482 static void
 483 ev_job_load_dispose (GObject *object)
 484 {
 485         EvJobLoad *job = EV_JOB_LOAD (object);
 486
 487         if (job->uri) {
 488                 g_free (job->uri);
 489                 job->uri = NULL;
 490         }
 491
 492         if (job->error) {
 493                 g_error_free (job->error);
 494                 job->error = NULL;
 495         }
 496
 497         if (job->dest) {
 498                 g_object_unref (job->dest);
 499                 job->dest = NULL;
 500         }
 501
 502         if (job->search_string) {
 503                 g_free (job->search_string);
 504                 job->search_string = NULL;
 505         }
 506
 507         (* G_OBJECT_CLASS (ev_job_load_parent_class)->dispose) (object);
 508 }
 509
 510 static void
 511 ev_job_load_class_init (EvJobLoadClass *class)
 512 {
 513         GObjectClass *oclass;
 514
 515         oclass = G_OBJECT_CLASS (class);
 516
 517         oclass->dispose = ev_job_load_dispose;
 518 }
 519
 520
 521 EvJob *
 522 ev_job_load_new (const gchar    *uri,
 523                  EvLinkDest     *dest,
 524                  EvWindowRunMode mode,
 525                  const gchar    *search_string)
 526 {
 527         EvJobLoad *job;
 528
 529         job = g_object_new (EV_TYPE_JOB_LOAD, NULL);
 530
 531         job->uri = g_strdup (uri);
 532         if (dest)
 533                 job->dest = g_object_ref (dest);
 534
 535         job->mode = mode;
 536         if (search_string)
 537                 job->search_string = g_strdup (search_string);
 538
 539         return EV_JOB (job);
 540 }
 541
 542 void
 543 ev_job_load_set_uri (EvJobLoad *job, const gchar *uri)
 544 {
 545         if (job->uri)
 546                 g_free (job->uri);
 547         job->uri = g_strdup (uri);
 548 }
 549
 550 void
 551 ev_job_load_run (EvJobLoad *job)
 552 {
 553         g_return_if_fail (EV_IS_JOB_LOAD (job));
 554
 555         if (job->error) {
 556                 g_error_free (job->error);
 557                 job->error = NULL;
 558         }
 559
 560         ev_document_fc_mutex_lock ();
 561
 562         /* This job may already have a document even if the job didn't complete
 563            because, e.g., a password is required - if so, just reload rather than
 564            creating a new instance */
 565         if (EV_JOB (job)->document) {
 566                 ev_document_load (EV_JOB (job)->document,
 567                                   job->uri,
 568                                   &job->error);
 569         } else {
 570                 EV_JOB(job)->document =
 571                         ev_document_factory_get_document (job->uri,
 572                                                           &job->error);
 573         }
 574
 575         ev_document_fc_mutex_unlock ();
 576         EV_JOB (job)->finished = TRUE;
 577 }
 578
 579 static void ev_job_save_init (EvJobSave *job) { /* Do Nothing */ }
 580
 581 static void
 582 ev_job_save_dispose (GObject *object)
 583 {
 584         EvJobSave *job = EV_JOB_SAVE (object);
 585
 586         if (job->uri) {
 587                 g_free (job->uri);
 588                 job->uri = NULL;
 589         }
 590
 591         if (job->document_uri) {
 592                 g_free (job->document_uri);
 593                 job->document_uri = NULL;
 594         }
 595
 596         if (job->error) {
 597                 g_error_free (job->error);
 598                 job->error = NULL;
 599         }
 600
 601         (* G_OBJECT_CLASS (ev_job_save_parent_class)->dispose) (object);
 602 }
 603
 604 static void
 605 ev_job_save_class_init (EvJobSaveClass *class)
 606 {
 607         GObjectClass *oclass;
 608
 609         oclass = G_OBJECT_CLASS (class);
 610
 611         oclass->dispose = ev_job_save_dispose;
 612 }
 613
 614 EvJob *
 615 ev_job_save_new (EvDocument  *document,
 616                  const gchar *uri,
 617                  const gchar *document_uri)
 618 {
 619         EvJobSave *job;
 620
 621         job = g_object_new (EV_TYPE_JOB_SAVE, NULL);
 622
 623         EV_JOB (job)->document = g_object_ref (document);
 624         job->uri = g_strdup (uri);
 625         job->document_uri = g_strdup (document_uri);
 626         job->error = NULL;
 627
 628         return EV_JOB (job);
 629 }
 630
 631 void
 632 ev_job_save_run (EvJobSave *job)
 633 {
 634         gint   fd;
 635         gchar *filename;
 636         gchar *tmp_filename;
 637         gchar *local_uri;
 638
 639         filename = ev_tmp_filename ("saveacopy");
 640         tmp_filename = g_strdup_printf ("%s.XXXXXX", filename);
 641         g_free (filename);
 642
 643         fd = g_mkstemp (tmp_filename);
 644         if (fd == -1) {
 645                 gchar *display_name;
 646                 gint   save_errno = errno;
 647
 648                 display_name = g_filename_display_name (tmp_filename);
 649                 g_set_error (&(job->error),
 650                              G_FILE_ERROR,
 651                              g_file_error_from_errno (save_errno),
 652                              _("Failed to create file “%s”: %s"),
 653                              display_name, g_strerror (save_errno));
 654                 g_free (display_name);
 655                 g_free (tmp_filename);
 656
 657                 return;
 658         }
 659
 660         ev_document_doc_mutex_lock ();
 661
 662         /* Save document to temp filename */
 663         local_uri = g_filename_to_uri (tmp_filename, NULL, NULL);
 664         ev_document_save (EV_JOB (job)->document, local_uri, &(job->error));
 665         close (fd);
 666
 667         ev_document_doc_mutex_unlock ();
 668
 669         if (job->error) {
 670                 g_free (local_uri);
 671                 return;
 672         }
 673
 674         /* If original document was compressed,
 675          * compress it again before saving
 676          */
 677         if (g_object_get_data (G_OBJECT (EV_JOB (job)->document),
 678                                "uri-uncompressed")) {
 679                 EvCompressionType ctype = EV_COMPRESSION_NONE;
 680                 const gchar      *ext;
 681                 gchar            *uri_comp;
 682
 683                 ext = g_strrstr (job->document_uri, ".gz");
 684                 if (ext && g_ascii_strcasecmp (ext, ".gz") == 0)
 685                         ctype = EV_COMPRESSION_GZIP;
 686
 687                 ext = g_strrstr (job->document_uri, ".bz2");
 688                 if (ext && g_ascii_strcasecmp (ext, ".bz2") == 0)
 689                         ctype = EV_COMPRESSION_BZIP2;
 690
 691                 uri_comp = ev_file_compress (local_uri, ctype, &(job->error));
 692                 g_free (local_uri);
 693                 ev_tmp_filename_unlink (tmp_filename);
 694
 695                 if (!uri_comp || job->error) {
 696                         local_uri = NULL;
 697                 } else {
 698                         local_uri = uri_comp;
 699                 }
 700         }
 701
 702         g_free (tmp_filename);
 703
 704         if (job->error) {
 705                 g_free (local_uri);
 706                 return;
 707         }
 708
 709         if (!local_uri)
 710                 return;
 711
 712         ev_xfer_uri_simple (local_uri, job->uri, &(job->error));
 713         ev_tmp_uri_unlink (local_uri);
 714 }
 715
 716 EvJob *
 717 ev_job_print_new (EvDocument    *document,
 718                   const gchar   *format,
 719                   gdouble        width,
 720                   gdouble        height,
 721                   EvPrintRange  *ranges,
 722                   gint           n_ranges,
 723                   EvPrintPageSet page_set,
 724                   gint           pages_per_sheet,
 725                   gint           copies,
 726                   gdouble        collate,
 727                   gdouble        reverse)
 728 {
 729         EvJobPrint *job;
 730
 731         job = g_object_new (EV_TYPE_JOB_PRINT, NULL);
 732
 733         EV_JOB (job)->document = g_object_ref (document);
 734
 735         job->format = format;
 736
 737         job->temp_file = NULL;
 738         job->error = NULL;
 739
 740         job->width = width;
 741         job->height = height;
 742
 743         job->ranges = ranges;
 744         job->n_ranges = n_ranges;
 745
 746         job->page_set = page_set;
 747
 748         job->pages_per_sheet = CLAMP (pages_per_sheet, 1, 16);
 749
 750         job->copies = copies;
 751         job->collate = collate;
 752         job->reverse = reverse;
 753
 754         return EV_JOB (job);
 755 }
 756
 757 static gint
 758 ev_print_job_get_first_page (EvJobPrint *job)
 759 {
 760         gint i;
 761         gint first_page = G_MAXINT;
 762
 763         if (job->n_ranges == 0)
 764                 return 0;
 765
 766         for (i = 0; i < job->n_ranges; i++) {
 767                 if (job->ranges[i].start < first_page)
 768                         first_page = job->ranges[i].start;
 769         }
 770
 771         return MAX (0, first_page);
 772 }
 773
 774 static gint
 775 ev_print_job_get_last_page (EvJobPrint *job)
 776 {
 777         gint i;
 778         gint last_page = G_MININT;
 779         gint max_page;
 780
 781         max_page = ev_document_get_n_pages (EV_JOB (job)->document) - 1;
 782
 783         if (job->n_ranges == 0)
 784                 return max_page;
 785
 786         for (i = 0; i < job->n_ranges; i++) {
 787                 if (job->ranges[i].end > last_page)
 788                         last_page = job->ranges[i].end;
 789         }
 790
 791         return MIN (max_page, last_page);
 792 }
 793
 794 static gboolean
 795 ev_print_job_print_page_in_set (EvJobPrint *job,
 796                                 gint        page)
 797 {
 798         switch (job->page_set) {
 799                 case EV_PRINT_PAGE_SET_EVEN:
 800                         return page % 2 == 0;
 801                 case EV_PRINT_PAGE_SET_ODD:
 802                         return page % 2 != 0;
 803                 case EV_PRINT_PAGE_SET_ALL:
 804                         return TRUE;
 805         }
 806
 807         return FALSE;
 808 }
 809
 810 static gint *
 811 ev_job_print_get_page_list (EvJobPrint *job,
 812                             gint       *n_pages)
 813 {
 814         gint  i, j, page, max_page;
 815         gint  pages = 0;
 816         gint *page_list;
 817
 818         max_page = ev_document_get_n_pages (EV_JOB (job)->document) - 1;
 819
 820         for (i = 0; i < job->n_ranges; i++) {
 821                 gint rsize;
 822                 gint start, end;
 823
 824                 if (job->ranges[i].start > max_page)
 825                         continue;
 826
 827                 start = job->ranges[i].start + 1;
 828                 end = job->ranges[i].end <= max_page ? job->ranges[i].end + 1 : max_page + 1;
 829                 rsize = end - start + 1;
 830
 831                 switch (job->page_set) {
 832                         case EV_PRINT_PAGE_SET_EVEN:
 833                                 pages += start % 2 == 0 ? (rsize / 2) + (rsize % 2) : (rsize / 2);
 834                                 break;
 835                         case EV_PRINT_PAGE_SET_ODD:
 836                                 pages += start % 2 != 0 ? (rsize / 2) + (rsize % 2) : (rsize / 2);
 837                                 break;
 838                         default:
 839                                 pages += rsize;
 840                                 break;
 841                 }
 842         }
 843
 844         *n_pages = pages;
 845
 846         if (pages == 0)
 847                 return NULL;
 848
 849         page_list = g_new (gint, pages);
 850
 851         page = 0;
 852         for (i = 0; i < job->n_ranges; i++) {
 853                 for (j = job->ranges[i].start; j <= job->ranges[i].end; j++) {
 854                         if (j > max_page)
 855                                 break;
 856
 857                         if (ev_print_job_print_page_in_set (job, j + 1))
 858                                 page_list[page++] = j;
 859                 }
 860         }
 861
 862         return page_list;
 863 }
 864
 865 void
 866 ev_job_print_run (EvJobPrint *job)
 867 {
 868         EvDocument            *document = EV_JOB (job)->document;
 869         EvFileExporterContext  fc;
 870         EvRenderContext       *rc;
 871         gint                   fd;
 872         gint                  *page_list;
 873         gint                   n_pages;
 874         gint                   last_page;
 875         gint                   first_page;
 876         gint                   i, j;
 877         gchar                 *filename;
 878
 879         g_return_if_fail (EV_IS_JOB_PRINT (job));
 880
 881         if (job->temp_file)
 882                 g_free (job->temp_file);
 883         job->temp_file = NULL;
 884
 885         if (job->error)
 886                 g_error_free (job->error);
 887         job->error = NULL;
 888
 889         filename = g_strdup_printf ("evince_print.%s.XXXXXX", job->format);
 890         fd = g_file_open_tmp (filename, &job->temp_file, &job->error);
 891         g_free (filename);
 892         if (fd <= -1) {
 893                 EV_JOB (job)->finished = TRUE;
 894                 return;
 895         }
 896
 897         page_list = ev_job_print_get_page_list (job, &n_pages);
 898         if (n_pages == 0) {
 899                 close (fd);
 900                 EV_JOB (job)->finished = TRUE;
 901                 return;
 902         }
 903
 904         first_page = ev_print_job_get_first_page (job);
 905         last_page = ev_print_job_get_last_page (job);
 906
 907         fc.format = g_ascii_strcasecmp (job->format, "pdf") == 0 ?
 908                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
 909         fc.filename = job->temp_file;
 910         fc.first_page = MIN (first_page, last_page);
 911         fc.last_page = MAX (first_page, last_page);
 912         fc.paper_width = job->width;
 913         fc.paper_height = job->height;
 914         fc.duplex = FALSE;
 915         fc.pages_per_sheet = MAX (1, job->pages_per_sheet);
 916
 917         rc = ev_render_context_new (0, 0, 1.0);
 918
 919         ev_document_doc_mutex_lock ();
 920         ev_file_exporter_begin (EV_FILE_EXPORTER (document), &fc);
 921
 922         for (i = 0; i < job->copies; i++) {
 923                 gint page, step;
 924                 gint n_copies;
 925
 926                 step = job->reverse ? -1 * job->pages_per_sheet : job->pages_per_sheet;
 927                 page = job->reverse ? (n_pages / job->pages_per_sheet) * job->pages_per_sheet  : 0;
 928                 n_copies = job->collate ? job->copies : 1;
 929
 930                 while ((job->reverse && (page >= 0)) || (!job->reverse && (page < n_pages))) {
 931                         gint k;
 932
 933                         ev_file_exporter_begin_page (EV_FILE_EXPORTER (document));
 934
 935                         for (j = 0; j < job->pages_per_sheet; j++) {
 936                                 gint p = page + j;
 937
 938                                 if (p < 0 || p >= n_pages)
 939                                         break;
 940
 941                                 ev_render_context_set_page (rc, page_list[p]);
 942
 943                                 for (k = 0; k < n_copies; k++) {
 944                                         ev_file_exporter_do_page (EV_FILE_EXPORTER (document), rc);
 945                                 }
 946                         }
 947
 948                         ev_file_exporter_end_page (EV_FILE_EXPORTER (document));
 949
 950                         page += step;
 951                 }
 952
 953                 if (job->collate)
 954                         break;
 955         }
 956
 957         ev_file_exporter_end (EV_FILE_EXPORTER (document));
 958         ev_document_doc_mutex_unlock ();
 959
 960         g_free (page_list);
 961         close (fd);
 962         g_object_unref (rc);
 963
 964         EV_JOB (job)->finished = TRUE;
 965 }