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         (* G_OBJECT_CLASS (ev_job_load_parent_class)->dispose) (object);
 503 }
 504
 505 static void
 506 ev_job_load_class_init (EvJobLoadClass *class)
 507 {
 508         GObjectClass *oclass;
 509
 510         oclass = G_OBJECT_CLASS (class);
 511
 512         oclass->dispose = ev_job_load_dispose;
 513 }
 514
 515
 516 EvJob *
 517 ev_job_load_new (const gchar *uri, EvLinkDest *dest, EvWindowRunMode mode)
 518 {
 519         EvJobLoad *job;
 520
 521         job = g_object_new (EV_TYPE_JOB_LOAD, NULL);
 522
 523         job->uri = g_strdup (uri);
 524         if (dest)
 525                 job->dest = g_object_ref (dest);
 526
 527         job->mode = mode;
 528
 529         return EV_JOB (job);
 530 }
 531
 532 void
 533 ev_job_load_set_uri (EvJobLoad *job, const gchar *uri)
 534 {
 535         if (job->uri)
 536                 g_free (job->uri);
 537         job->uri = g_strdup (uri);
 538 }
 539
 540 void
 541 ev_job_load_run (EvJobLoad *job)
 542 {
 543         g_return_if_fail (EV_IS_JOB_LOAD (job));
 544
 545         if (job->error) {
 546                 g_error_free (job->error);
 547                 job->error = NULL;
 548         }
 549
 550         ev_document_fc_mutex_lock ();
 551
 552         /* This job may already have a document even if the job didn't complete
 553            because, e.g., a password is required - if so, just reload rather than
 554            creating a new instance */
 555         if (EV_JOB (job)->document) {
 556                 ev_document_load (EV_JOB (job)->document,
 557                                   job->uri,
 558                                   &job->error);
 559         } else {
 560                 EV_JOB(job)->document =
 561                         ev_document_factory_get_document (job->uri,
 562                                                           &job->error);
 563         }
 564
 565         ev_document_fc_mutex_unlock ();
 566         EV_JOB (job)->finished = TRUE;
 567 }
 568
 569 static void ev_job_save_init (EvJobSave *job) { /* Do Nothing */ }
 570
 571 static void
 572 ev_job_save_dispose (GObject *object)
 573 {
 574         EvJobSave *job = EV_JOB_SAVE (object);
 575
 576         if (job->uri) {
 577                 g_free (job->uri);
 578                 job->uri = NULL;
 579         }
 580
 581         if (job->document_uri) {
 582                 g_free (job->document_uri);
 583                 job->document_uri = NULL;
 584         }
 585
 586         if (job->error) {
 587                 g_error_free (job->error);
 588                 job->error = NULL;
 589         }
 590
 591         (* G_OBJECT_CLASS (ev_job_save_parent_class)->dispose) (object);
 592 }
 593
 594 static void
 595 ev_job_save_class_init (EvJobSaveClass *class)
 596 {
 597         GObjectClass *oclass;
 598
 599         oclass = G_OBJECT_CLASS (class);
 600
 601         oclass->dispose = ev_job_save_dispose;
 602 }
 603
 604 EvJob *
 605 ev_job_save_new (EvDocument  *document,
 606                  const gchar *uri,
 607                  const gchar *document_uri)
 608 {
 609         EvJobSave *job;
 610
 611         job = g_object_new (EV_TYPE_JOB_SAVE, NULL);
 612
 613         EV_JOB (job)->document = g_object_ref (document);
 614         job->uri = g_strdup (uri);
 615         job->document_uri = g_strdup (document_uri);
 616         job->error = NULL;
 617
 618         return EV_JOB (job);
 619 }
 620
 621 void
 622 ev_job_save_run (EvJobSave *job)
 623 {
 624         gint   fd;
 625         gchar *filename;
 626         gchar *tmp_filename;
 627         gchar *local_uri;
 628
 629         filename = ev_tmp_filename ("saveacopy");
 630         tmp_filename = g_strdup_printf ("%s.XXXXXX", filename);
 631         g_free (filename);
 632
 633         fd = g_mkstemp (tmp_filename);
 634         if (fd == -1) {
 635                 gchar *display_name;
 636                 gint   save_errno = errno;
 637
 638                 display_name = g_filename_display_name (tmp_filename);
 639                 g_set_error (&(job->error),
 640                              G_FILE_ERROR,
 641                              g_file_error_from_errno (save_errno),
 642                              _("Failed to create file “%s”: %s"),
 643                              display_name, g_strerror (save_errno));
 644                 g_free (display_name);
 645                 g_free (tmp_filename);
 646
 647                 return;
 648         }
 649
 650         ev_document_doc_mutex_lock ();
 651
 652         /* Save document to temp filename */
 653         local_uri = g_filename_to_uri (tmp_filename, NULL, NULL);
 654         ev_document_save (EV_JOB (job)->document, local_uri, &(job->error));
 655         close (fd);
 656
 657         ev_document_doc_mutex_unlock ();
 658
 659         if (job->error) {
 660                 g_free (local_uri);
 661                 return;
 662         }
 663
 664         /* If original document was compressed,
 665          * compress it again before saving
 666          */
 667         if (g_object_get_data (G_OBJECT (EV_JOB (job)->document),
 668                                "uri-uncompressed")) {
 669                 EvCompressionType ctype = EV_COMPRESSION_NONE;
 670                 const gchar      *ext;
 671                 gchar            *uri_comp;
 672
 673                 ext = g_strrstr (job->document_uri, ".gz");
 674                 if (ext && g_ascii_strcasecmp (ext, ".gz") == 0)
 675                         ctype = EV_COMPRESSION_GZIP;
 676
 677                 ext = g_strrstr (job->document_uri, ".bz2");
 678                 if (ext && g_ascii_strcasecmp (ext, ".bz2") == 0)
 679                         ctype = EV_COMPRESSION_BZIP2;
 680
 681                 uri_comp = ev_file_compress (local_uri, ctype, &(job->error));
 682                 g_free (local_uri);
 683                 ev_tmp_filename_unlink (tmp_filename);
 684
 685                 if (!uri_comp || job->error) {
 686                         local_uri = NULL;
 687                 } else {
 688                         local_uri = uri_comp;
 689                 }
 690         }
 691
 692         g_free (tmp_filename);
 693
 694         if (job->error) {
 695                 g_free (local_uri);
 696                 return;
 697         }
 698
 699         if (!local_uri)
 700                 return;
 701
 702         ev_xfer_uri_simple (local_uri, job->uri, &(job->error));
 703         ev_tmp_uri_unlink (local_uri);
 704 }
 705
 706 EvJob *
 707 ev_job_print_new (EvDocument    *document,
 708                   const gchar   *format,
 709                   gdouble        width,
 710                   gdouble        height,
 711                   EvPrintRange  *ranges,
 712                   gint           n_ranges,
 713                   EvPrintPageSet page_set,
 714                   gint           pages_per_sheet,
 715                   gint           copies,
 716                   gdouble        collate,
 717                   gdouble        reverse)
 718 {
 719         EvJobPrint *job;
 720
 721         job = g_object_new (EV_TYPE_JOB_PRINT, NULL);
 722
 723         EV_JOB (job)->document = g_object_ref (document);
 724
 725         job->format = format;
 726
 727         job->temp_file = NULL;
 728         job->error = NULL;
 729
 730         job->width = width;
 731         job->height = height;
 732
 733         job->ranges = ranges;
 734         job->n_ranges = n_ranges;
 735
 736         job->page_set = page_set;
 737
 738         job->pages_per_sheet = pages_per_sheet;
 739
 740         job->copies = copies;
 741         job->collate = collate;
 742         job->reverse = reverse;
 743
 744         return EV_JOB (job);
 745 }
 746
 747 static gint
 748 ev_print_job_get_first_page (EvJobPrint *job)
 749 {
 750         gint i;
 751         gint first_page = G_MAXINT;
 752
 753         if (job->n_ranges == 0)
 754                 return 0;
 755
 756         for (i = 0; i < job->n_ranges; i++) {
 757                 if (job->ranges[i].start < first_page)
 758                         first_page = job->ranges[i].start;
 759         }
 760
 761         return MAX (0, first_page);
 762 }
 763
 764 static gint
 765 ev_print_job_get_last_page (EvJobPrint *job)
 766 {
 767         gint i;
 768         gint last_page = G_MININT;
 769         gint max_page;
 770
 771         max_page = ev_document_get_n_pages (EV_JOB (job)->document) - 1;
 772
 773         if (job->n_ranges == 0)
 774                 return max_page;
 775
 776         for (i = 0; i < job->n_ranges; i++) {
 777                 if (job->ranges[i].end > last_page)
 778                         last_page = job->ranges[i].end;
 779         }
 780
 781         return MIN (max_page, last_page);
 782 }
 783
 784 static gboolean
 785 ev_print_job_print_page_in_set (EvJobPrint *job,
 786                                 gint        page)
 787 {
 788         switch (job->page_set) {
 789                 case EV_PRINT_PAGE_SET_EVEN:
 790                         return page % 2 == 0;
 791                 case EV_PRINT_PAGE_SET_ODD:
 792                         return page % 2 != 0;
 793                 case EV_PRINT_PAGE_SET_ALL:
 794                         return TRUE;
 795         }
 796
 797         return FALSE;
 798 }
 799
 800 static gint *
 801 ev_job_print_get_page_list (EvJobPrint *job,
 802                             gint       *n_pages)
 803 {
 804         gint  i, j, page, max_page;
 805         gint  pages = 0;
 806         gint *page_list;
 807
 808         max_page = ev_document_get_n_pages (EV_JOB (job)->document) - 1;
 809
 810         for (i = 0; i < job->n_ranges; i++) {
 811                 gint rsize;
 812                 gint start, end;
 813
 814                 if (job->ranges[i].start > max_page)
 815                         continue;
 816
 817                 start = job->ranges[i].start + 1;
 818                 end = job->ranges[i].end <= max_page ? job->ranges[i].end + 1 : max_page + 1;
 819                 rsize = end - start + 1;
 820
 821                 switch (job->page_set) {
 822                         case EV_PRINT_PAGE_SET_EVEN:
 823                                 pages += start % 2 == 0 ? (rsize / 2) + (rsize % 2) : (rsize / 2);
 824                                 break;
 825                         case EV_PRINT_PAGE_SET_ODD:
 826                                 pages += start % 2 != 0 ? (rsize / 2) + (rsize % 2) : (rsize / 2);
 827                                 break;
 828                         default:
 829                                 pages += rsize;
 830                                 break;
 831                 }
 832         }
 833
 834         *n_pages = pages;
 835
 836         if (pages == 0)
 837                 return NULL;
 838
 839         page_list = g_new (gint, pages);
 840
 841         page = 0;
 842         for (i = 0; i < job->n_ranges; i++) {
 843                 for (j = job->ranges[i].start; j <= job->ranges[i].end; j++) {
 844                         if (j > max_page)
 845                                 break;
 846
 847                         if (ev_print_job_print_page_in_set (job, j + 1))
 848                                 page_list[page++] = j;
 849                 }
 850         }
 851
 852         return page_list;
 853 }
 854
 855 void
 856 ev_job_print_run (EvJobPrint *job)
 857 {
 858         EvDocument            *document = EV_JOB (job)->document;
 859         EvFileExporterContext  fc;
 860         EvRenderContext       *rc;
 861         gint                   fd;
 862         gint                  *page_list;
 863         gint                   n_pages;
 864         gint                   last_page;
 865         gint                   first_page;
 866         gint                   i, j;
 867         gchar                 *filename;
 868
 869         g_return_if_fail (EV_IS_JOB_PRINT (job));
 870
 871         if (job->temp_file)
 872                 g_free (job->temp_file);
 873         job->temp_file = NULL;
 874
 875         if (job->error)
 876                 g_error_free (job->error);
 877         job->error = NULL;
 878
 879         filename = g_strdup_printf ("evince_print.%s.XXXXXX", job->format);
 880         fd = g_file_open_tmp (filename, &job->temp_file, &job->error);
 881         g_free (filename);
 882         if (fd <= -1) {
 883                 EV_JOB (job)->finished = TRUE;
 884                 return;
 885         }
 886
 887         page_list = ev_job_print_get_page_list (job, &n_pages);
 888         if (n_pages == 0) {
 889                 close (fd);
 890                 EV_JOB (job)->finished = TRUE;
 891                 return;
 892         }
 893
 894         first_page = ev_print_job_get_first_page (job);
 895         last_page = ev_print_job_get_last_page (job);
 896
 897         fc.format = g_ascii_strcasecmp (job->format, "pdf") == 0 ?
 898                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
 899         fc.filename = job->temp_file;
 900         fc.first_page = MIN (first_page, last_page);
 901         fc.last_page = MAX (first_page, last_page);
 902         fc.paper_width = job->width;
 903         fc.paper_height = job->height;
 904         fc.duplex = FALSE;
 905         fc.pages_per_sheet = MAX (1, job->pages_per_sheet);
 906
 907         rc = ev_render_context_new (0, 0, 1.0);
 908
 909         ev_document_doc_mutex_lock ();
 910         ev_file_exporter_begin (EV_FILE_EXPORTER (document), &fc);
 911
 912         for (i = 0; i < job->copies; i++) {
 913                 gint page, step;
 914                 gint n_copies;
 915
 916                 step = job->reverse ? -1 * job->pages_per_sheet : job->pages_per_sheet;
 917                 page = job->reverse ? (n_pages / job->pages_per_sheet) * job->pages_per_sheet  : 0;
 918                 n_copies = job->collate ? job->copies : 1;
 919
 920                 while ((job->reverse && (page >= 0)) || (!job->reverse && (page < n_pages))) {
 921                         gint k;
 922
 923                         ev_file_exporter_begin_page (EV_FILE_EXPORTER (document));
 924
 925                         for (j = 0; j < job->pages_per_sheet; j++) {
 926                                 gint p = page + j;
 927
 928                                 if (p < 0 || p >= n_pages)
 929                                         break;
 930
 931                                 ev_render_context_set_page (rc, page_list[p]);
 932
 933                                 for (k = 0; k < n_copies; k++) {
 934                                         ev_file_exporter_do_page (EV_FILE_EXPORTER (document), rc);
 935                                 }
 936                         }
 937
 938                         ev_file_exporter_end_page (EV_FILE_EXPORTER (document));
 939
 940                         page += step;
 941                 }
 942
 943                 if (job->collate)
 944                         break;
 945         }
 946
 947         ev_file_exporter_end (EV_FILE_EXPORTER (document));
 948         ev_document_doc_mutex_unlock ();
 949
 950         g_free (page_list);
 951         close (fd);
 952         g_object_unref (rc);
 953
 954         EV_JOB (job)->finished = TRUE;
 955 }