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-factory.h"
   7 #include "ev-file-helpers.h"
   8 #include "ev-document-fonts.h"
   9 #include "ev-selection.h"
  10 #include "ev-async-renderer.h"
  11 #include "ev-file-exporter.h"
  12 #include "ev-window.h"
  13
  14 #include <glib/gstdio.h>
  15 #include <unistd.h>
  16 #include <libgnomevfs/gnome-vfs-uri.h>
  17 #include <libgnomevfs/gnome-vfs-utils.h>
  18 #include <libgnomevfs/gnome-vfs-ops.h>
  19 #include <libgnomevfs/gnome-vfs-xfer.h>
  20
  21 static void ev_job_init                 (EvJob               *job);
  22 static void ev_job_class_init           (EvJobClass          *class);
  23 static void ev_job_links_init           (EvJobLinks          *job);
  24 static void ev_job_links_class_init     (EvJobLinksClass     *class);
  25 static void ev_job_render_init          (EvJobRender         *job);
  26 static void ev_job_render_class_init    (EvJobRenderClass    *class);
  27 static void ev_job_thumbnail_init       (EvJobThumbnail      *job);
  28 static void ev_job_thumbnail_class_init (EvJobThumbnailClass *class);
  29 static void ev_job_xfer_init            (EvJobXfer           *job);
  30 static void ev_job_xfer_class_init      (EvJobXferClass      *class);
  31 static void ev_job_print_init           (EvJobPrint          *job);
  32 static void ev_job_print_class_init     (EvJobPrintClass     *class);
  33
  34 enum
  35 {
  36         FINISHED,
  37         LAST_SIGNAL
  38 };
  39
  40 static guint job_signals[LAST_SIGNAL] = { 0 };
  41
  42 G_DEFINE_TYPE (EvJob, ev_job, G_TYPE_OBJECT)
  43 G_DEFINE_TYPE (EvJobLinks, ev_job_links, EV_TYPE_JOB)
  44 G_DEFINE_TYPE (EvJobRender, ev_job_render, EV_TYPE_JOB)
  45 G_DEFINE_TYPE (EvJobThumbnail, ev_job_thumbnail, EV_TYPE_JOB)
  46 G_DEFINE_TYPE (EvJobFonts, ev_job_fonts, EV_TYPE_JOB)
  47 G_DEFINE_TYPE (EvJobXfer, ev_job_xfer, EV_TYPE_JOB)
  48 G_DEFINE_TYPE (EvJobPrint, ev_job_print, EV_TYPE_JOB)
  49
  50 static void ev_job_init (EvJob *job) { /* Do Nothing */ }
  51
  52 static void
  53 ev_job_dispose (GObject *object)
  54 {
  55         EvJob *job;
  56
  57         job = EV_JOB (object);
  58
  59         if (job->document) {
  60                 g_object_unref (job->document);
  61                 job->document = NULL;
  62         }
  63
  64         (* G_OBJECT_CLASS (ev_job_parent_class)->dispose) (object);
  65 }
  66
  67 static void
  68 ev_job_class_init (EvJobClass *class)
  69 {
  70         GObjectClass *oclass;
  71
  72         oclass = G_OBJECT_CLASS (class);
  73
  74         oclass->dispose = ev_job_dispose;
  75
  76         job_signals [FINISHED] =
  77                 g_signal_new ("finished",
  78                               EV_TYPE_JOB,
  79                               G_SIGNAL_RUN_LAST,
  80                               G_STRUCT_OFFSET (EvJobClass, finished),
  81                               NULL, NULL,
  82                               g_cclosure_marshal_VOID__VOID,
  83                               G_TYPE_NONE, 0);
  84 }
  85
  86
  87 static void ev_job_links_init (EvJobLinks *job) { /* Do Nothing */ }
  88
  89 static void
  90 ev_job_links_dispose (GObject *object)
  91 {
  92         EvJobLinks *job;
  93
  94         job = EV_JOB_LINKS (object);
  95
  96         if (job->model) {
  97                 g_object_unref (job->model);
  98                 job->model = NULL;
  99         }
 100
 101         (* G_OBJECT_CLASS (ev_job_links_parent_class)->dispose) (object);
 102 }
 103
 104 static void
 105 ev_job_links_class_init (EvJobLinksClass *class)
 106 {
 107         GObjectClass *oclass;
 108
 109         oclass = G_OBJECT_CLASS (class);
 110
 111         oclass->dispose = ev_job_links_dispose;
 112 }
 113
 114
 115 static void ev_job_render_init (EvJobRender *job) { /* Do Nothing */ }
 116
 117 static void
 118 ev_job_render_dispose (GObject *object)
 119 {
 120         EvJobRender *job;
 121
 122         job = EV_JOB_RENDER (object);
 123
 124         if (job->pixbuf) {
 125                 g_object_unref (job->pixbuf);
 126                 job->pixbuf = NULL;
 127         }
 128
 129         if (job->rc) {
 130                 g_object_unref (job->rc);
 131                 job->rc = NULL;
 132         }
 133
 134         if (job->selection) {
 135                 g_object_unref (job->selection);
 136                 job->selection = NULL;
 137         }
 138
 139         if (job->selection_region) {
 140                 gdk_region_destroy (job->selection_region);
 141                 job->selection_region = NULL;
 142         }
 143
 144         (* G_OBJECT_CLASS (ev_job_render_parent_class)->dispose) (object);
 145 }
 146
 147 static void
 148 ev_job_render_class_init (EvJobRenderClass *class)
 149 {
 150         GObjectClass *oclass;
 151
 152         oclass = G_OBJECT_CLASS (class);
 153
 154         oclass->dispose = ev_job_render_dispose;
 155 }
 156
 157 static void ev_job_thumbnail_init (EvJobThumbnail *job) { /* Do Nothing */ }
 158
 159 static void
 160 ev_job_thumbnail_dispose (GObject *object)
 161 {
 162         EvJobThumbnail *job;
 163
 164         job = EV_JOB_THUMBNAIL (object);
 165
 166         if (job->thumbnail) {
 167                 g_object_unref (job->thumbnail);
 168                 job->thumbnail = NULL;
 169         }
 170
 171         (* G_OBJECT_CLASS (ev_job_thumbnail_parent_class)->dispose) (object);
 172 }
 173
 174 static void
 175 ev_job_thumbnail_class_init (EvJobThumbnailClass *class)
 176 {
 177         GObjectClass *oclass;
 178
 179         oclass = G_OBJECT_CLASS (class);
 180
 181         oclass->dispose = ev_job_thumbnail_dispose;
 182 }
 183
 184 static void ev_job_print_init (EvJobPrint *job) { /* Do Nothing */ }
 185
 186 static void
 187 ev_job_print_dispose (GObject *object)
 188 {
 189         EvJobPrint *job;
 190
 191         job = EV_JOB_PRINT (object);
 192
 193         if (job->temp_file) {
 194                 g_unlink (job->temp_file);
 195                 g_free (job->temp_file);
 196                 job->temp_file = NULL;
 197         }
 198
 199         if (job->error) {
 200                 g_error_free (job->error);
 201                 job->error = NULL;
 202         }
 203
 204         if (job->ranges) {
 205                 g_free (job->ranges);
 206                 job->ranges = NULL;
 207                 job->n_ranges = 0;
 208         }
 209
 210         (* G_OBJECT_CLASS (ev_job_print_parent_class)->dispose) (object);
 211 }
 212
 213 static void
 214 ev_job_print_class_init (EvJobPrintClass *class)
 215 {
 216         GObjectClass *oclass;
 217
 218         oclass = G_OBJECT_CLASS (class);
 219
 220         oclass->dispose = ev_job_print_dispose;
 221 }
 222
 223 /* Public functions */
 224 void
 225 ev_job_finished (EvJob *job)
 226 {
 227         g_return_if_fail (EV_IS_JOB (job));
 228
 229         g_signal_emit (job, job_signals[FINISHED], 0);
 230 }
 231
 232 EvJob *
 233 ev_job_links_new (EvDocument *document)
 234 {
 235         EvJob *job;
 236
 237         job = g_object_new (EV_TYPE_JOB_LINKS, NULL);
 238         job->document = g_object_ref (document);
 239
 240         return job;
 241 }
 242
 243 void
 244 ev_job_links_run (EvJobLinks *job)
 245 {
 246         g_return_if_fail (EV_IS_JOB_LINKS (job));
 247
 248         ev_document_doc_mutex_lock ();
 249         job->model = ev_document_links_get_links_model (EV_DOCUMENT_LINKS (EV_JOB (job)->document));
 250         EV_JOB (job)->finished = TRUE;
 251         ev_document_doc_mutex_unlock ();
 252 }
 253
 254
 255 EvJob *
 256 ev_job_render_new (EvDocument      *document,
 257                    EvRenderContext *rc,
 258                    gint             width,
 259                    gint             height,
 260                    EvRectangle     *selection_points,
 261                    GdkColor        *text,
 262                    GdkColor        *base,
 263                    gboolean         include_links,
 264                    gboolean         include_images,
 265                    gboolean         include_text,
 266                    gboolean         include_selection)
 267 {
 268         EvJobRender *job;
 269
 270         g_return_val_if_fail (EV_IS_RENDER_CONTEXT (rc), NULL);
 271         if (include_selection)
 272                 g_return_val_if_fail (selection_points != NULL, NULL);
 273
 274         job = g_object_new (EV_TYPE_JOB_RENDER, NULL);
 275
 276         EV_JOB (job)->document = g_object_ref (document);
 277         job->rc = g_object_ref (rc);
 278         job->target_width = width;
 279         job->target_height = height;
 280         job->text = *text;
 281         job->base = *base;
 282         job->include_links = include_links;
 283         job->include_images = include_images;
 284         job->include_text = include_text;
 285         job->include_selection = include_selection;
 286
 287         if (include_selection)
 288                 job->selection_points = *selection_points;
 289
 290         if (EV_IS_ASYNC_RENDERER (document)) {
 291                 EV_JOB (job)->async = TRUE;
 292         }
 293
 294         return EV_JOB (job);
 295 }
 296
 297 static void
 298 render_finished_cb (EvDocument *document, GdkPixbuf *pixbuf, EvJobRender *job)
 299 {
 300         g_signal_handlers_disconnect_by_func (EV_JOB (job)->document,
 301                                               render_finished_cb, job);
 302
 303         EV_JOB (job)->finished = TRUE;
 304         job->pixbuf = g_object_ref (pixbuf);
 305         ev_job_finished (EV_JOB (job));
 306 }
 307
 308 void
 309 ev_job_render_run (EvJobRender *job)
 310 {
 311         g_return_if_fail (EV_IS_JOB_RENDER (job));
 312
 313         ev_document_doc_mutex_lock ();
 314
 315         if (EV_JOB (job)->async) {
 316                 EvAsyncRenderer *renderer = EV_ASYNC_RENDERER (EV_JOB (job)->document);
 317                 ev_async_renderer_render_pixbuf (renderer, job->rc->page, job->rc->scale,
 318                                                  job->rc->rotation);
 319                 g_signal_connect (EV_JOB (job)->document, "render_finished",
 320                                   G_CALLBACK (render_finished_cb), job);
 321         } else {
 322                 ev_document_fc_mutex_lock ();
 323
 324                 job->pixbuf = ev_document_render_pixbuf (EV_JOB (job)->document, job->rc);
 325                 if (job->include_links && EV_IS_DOCUMENT_LINKS (EV_JOB (job)->document))
 326                         job->link_mapping =
 327                                 ev_document_links_get_links (EV_DOCUMENT_LINKS (EV_JOB (job)->document),
 328                                                              job->rc->page);
 329                 if (job->include_images && EV_IS_DOCUMENT_IMAGES (EV_JOB (job)->document))
 330                         job->image_mapping =
 331                                 ev_document_images_get_images (EV_DOCUMENT_IMAGES (EV_JOB (job)->document),
 332                                                                job->rc->page);
 333                 if (job->include_text && EV_IS_SELECTION (EV_JOB (job)->document))
 334                         job->text_mapping =
 335                                 ev_selection_get_selection_map (EV_SELECTION (EV_JOB (job)->document),
 336                                                                 job->rc);
 337                 if (job->include_selection && EV_IS_SELECTION (EV_JOB (job)->document)) {
 338                         ev_selection_render_selection (EV_SELECTION (EV_JOB (job)->document),
 339                                                        job->rc,
 340                                                        &(job->selection),
 341                                                        &(job->selection_points),
 342                                                        NULL,
 343                                                        &(job->text), &(job->base));
 344                         job->selection_region =
 345                                 ev_selection_get_selection_region (EV_SELECTION (EV_JOB (job)->document),
 346                                                                    job->rc,
 347                                                                    &(job->selection_points));
 348                 }
 349
 350                 ev_document_fc_mutex_unlock ();
 351                 EV_JOB (job)->finished = TRUE;
 352         }
 353
 354         ev_document_doc_mutex_unlock ();
 355 }
 356
 357 EvJob *
 358 ev_job_thumbnail_new (EvDocument   *document,
 359                       gint          page,
 360                       int           rotation,
 361                       gint          requested_width)
 362 {
 363         EvJobThumbnail *job;
 364
 365         job = g_object_new (EV_TYPE_JOB_THUMBNAIL, NULL);
 366
 367         EV_JOB (job)->document = g_object_ref (document);
 368         job->page = page;
 369         job->rotation = rotation;
 370         job->requested_width = requested_width;
 371
 372         return EV_JOB (job);
 373 }
 374
 375 void
 376 ev_job_thumbnail_run (EvJobThumbnail *job)
 377 {
 378         g_return_if_fail (EV_IS_JOB_THUMBNAIL (job));
 379
 380         ev_document_doc_mutex_lock ();
 381
 382         job->thumbnail =
 383                 ev_document_thumbnails_get_thumbnail (EV_DOCUMENT_THUMBNAILS (EV_JOB (job)->document),
 384                                                       job->page,
 385                                                       job->rotation,
 386                                                       job->requested_width,
 387                                                       TRUE);
 388         EV_JOB (job)->finished = TRUE;
 389
 390         ev_document_doc_mutex_unlock ();
 391 }
 392
 393 static void ev_job_fonts_init (EvJobFonts *job) { /* Do Nothing */ }
 394
 395 static void ev_job_fonts_class_init (EvJobFontsClass *class) { /* Do Nothing */ }
 396
 397 EvJob *
 398 ev_job_fonts_new (EvDocument *document)
 399 {
 400         EvJobFonts *job;
 401
 402         job = g_object_new (EV_TYPE_JOB_FONTS, NULL);
 403
 404         EV_JOB (job)->document = g_object_ref (document);
 405
 406         return EV_JOB (job);
 407 }
 408
 409 void
 410 ev_job_fonts_run (EvJobFonts *job)
 411 {
 412         EvDocumentFonts *fonts;
 413
 414         g_return_if_fail (EV_IS_JOB_FONTS (job));
 415
 416         ev_document_doc_mutex_lock ();
 417
 418         fonts = EV_DOCUMENT_FONTS (EV_JOB (job)->document);
 419         ev_document_fc_mutex_lock ();
 420         job->scan_completed = !ev_document_fonts_scan (fonts, 20);
 421         ev_document_fc_mutex_unlock ();
 422
 423         EV_JOB (job)->finished = TRUE;
 424
 425         ev_document_doc_mutex_unlock ();
 426 }
 427
 428 static void ev_job_xfer_init (EvJobXfer *job) { /* Do Nothing */ }
 429
 430 static void
 431 ev_job_xfer_dispose (GObject *object)
 432 {
 433         EvJobXfer *job = EV_JOB_XFER (object);
 434
 435         if (job->uri) {
 436                 g_free (job->uri);
 437                 job->uri = NULL;
 438         }
 439
 440         if (job->local_uri) {
 441                 g_free (job->local_uri);
 442                 job->local_uri = NULL;
 443         }
 444
 445         if (job->error) {
 446                 g_error_free (job->error);
 447                 job->error = NULL;
 448         }
 449
 450         if (job->dest) {
 451                 g_object_unref (job->dest);
 452                 job->dest = NULL;
 453         }
 454
 455         (* G_OBJECT_CLASS (ev_job_xfer_parent_class)->dispose) (object);
 456 }
 457
 458 static void
 459 ev_job_xfer_class_init (EvJobXferClass *class)
 460 {
 461         GObjectClass *oclass;
 462
 463         oclass = G_OBJECT_CLASS (class);
 464
 465         oclass->dispose = ev_job_xfer_dispose;
 466 }
 467
 468
 469 EvJob *
 470 ev_job_xfer_new (const gchar *uri, EvLinkDest *dest, EvWindowRunMode mode)
 471 {
 472         EvJobXfer *job;
 473
 474         job = g_object_new (EV_TYPE_JOB_XFER, NULL);
 475
 476         job->uri = g_strdup (uri);
 477         if (dest)
 478                 job->dest = g_object_ref (dest);
 479
 480         job->mode = mode;
 481
 482         return EV_JOB (job);
 483 }
 484
 485 void
 486 ev_job_xfer_run (EvJobXfer *job)
 487 {
 488         GnomeVFSURI *source_uri;
 489         GnomeVFSURI *target_uri;
 490
 491         g_return_if_fail (EV_IS_JOB_XFER (job));
 492
 493         if (job->error) {
 494                 g_error_free (job->error);
 495                 job->error = NULL;
 496         }
 497
 498         /* This job may already have a document even if the job didn't complete
 499            because, e.g., a password is required - if so, just reload rather than
 500            creating a new instance */
 501         if (EV_JOB (job)->document) {
 502                 ev_document_fc_mutex_lock ();
 503                 ev_document_load (EV_JOB (job)->document,
 504                                   job->local_uri ? job->local_uri : job->uri,
 505                                   &job->error);
 506                 ev_document_fc_mutex_unlock ();
 507                 EV_JOB (job)->finished = TRUE;
 508                 return;
 509         }
 510
 511         source_uri = gnome_vfs_uri_new (job->uri);
 512         if (!gnome_vfs_uri_is_local (source_uri) && !job->local_uri) {
 513                 char *tmp_name;
 514                 char *base_name;
 515
 516                 /* We'd like to keep extension of source uri since
 517                  * it helps to resolve some mime types, say cbz */
 518
 519                 tmp_name = ev_tmp_filename (NULL);
 520                 base_name = gnome_vfs_uri_extract_short_name (source_uri);
 521                 job->local_uri = g_strconcat ("file:", tmp_name, "-", base_name, NULL);
 522                 g_free (base_name);
 523                 g_free (tmp_name);
 524
 525                 target_uri = gnome_vfs_uri_new (job->local_uri);
 526
 527                 gnome_vfs_xfer_uri (source_uri, target_uri,
 528                                     GNOME_VFS_XFER_DEFAULT | GNOME_VFS_XFER_FOLLOW_LINKS,
 529                                     GNOME_VFS_XFER_ERROR_MODE_ABORT,
 530                                     GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE,
 531                                     NULL,
 532                                     job);
 533                 gnome_vfs_uri_unref (target_uri);
 534         }
 535         gnome_vfs_uri_unref (source_uri);
 536
 537         EV_JOB(job)->document = ev_document_factory_get_document (job->local_uri ? job->local_uri : job->uri, &job->error);
 538         EV_JOB (job)->finished = TRUE;
 539
 540         return;
 541 }
 542
 543 EvJob *
 544 ev_job_print_new (EvDocument    *document,
 545                   const gchar   *format,
 546                   gdouble        width,
 547                   gdouble        height,
 548                   EvPrintRange  *ranges,
 549                   gint           n_ranges,
 550                   EvPrintPageSet page_set,
 551                   gint           copies,
 552                   gdouble        collate,
 553                   gdouble        reverse)
 554 {
 555         EvJobPrint *job;
 556
 557         job = g_object_new (EV_TYPE_JOB_PRINT, NULL);
 558
 559         EV_JOB (job)->document = g_object_ref (document);
 560
 561         job->format = format;
 562
 563         job->temp_file = NULL;
 564         job->error = NULL;
 565
 566         job->width = width;
 567         job->height = height;
 568
 569         job->ranges = ranges;
 570         job->n_ranges = n_ranges;
 571
 572         job->page_set = page_set;
 573
 574         job->copies = copies;
 575         job->collate = collate;
 576         job->reverse = reverse;
 577
 578         return EV_JOB (job);
 579 }
 580
 581 static gint
 582 ev_print_job_get_first_page (EvJobPrint *job)
 583 {
 584         gint i;
 585         gint first_page = G_MAXINT;
 586
 587         if (job->n_ranges == 0)
 588                 return 0;
 589
 590         for (i = 0; i < job->n_ranges; i++) {
 591                 if (job->ranges[i].start < first_page)
 592                         first_page = job->ranges[i].start;
 593         }
 594
 595         return MAX (0, first_page);
 596 }
 597
 598 static gint
 599 ev_print_job_get_last_page (EvJobPrint *job)
 600 {
 601         gint i;
 602         gint last_page = G_MININT;
 603         gint max_page;
 604
 605         max_page = ev_document_get_n_pages (EV_JOB (job)->document) - 1;
 606
 607         if (job->n_ranges == 0)
 608                 return max_page;
 609
 610         for (i = 0; i < job->n_ranges; i++) {
 611                 if (job->ranges[i].end > last_page)
 612                         last_page = job->ranges[i].end;
 613         }
 614
 615         return MIN (max_page, last_page);
 616 }
 617
 618 static gboolean
 619 ev_print_job_print_page_in_range (EvJobPrint *job,
 620                                   gint        page)
 621 {
 622         gint i;
 623
 624         for (i = 0; i < job->n_ranges; i++) {
 625                 if (page >= job->ranges[i].start &&
 626                     page <= job->ranges[i].end)
 627                         return TRUE;
 628         }
 629
 630         return FALSE;
 631 }
 632
 633 static gboolean
 634 ev_print_job_print_page_in_set (EvJobPrint *job,
 635                                 gint        page)
 636 {
 637         switch (job->page_set) {
 638                 case EV_PRINT_PAGE_SET_EVEN:
 639                         return page % 2 == 0;
 640                 case EV_PRINT_PAGE_SET_ODD:
 641                         return page % 2 != 0;
 642                 case EV_PRINT_PAGE_SET_ALL:
 643                         return TRUE;
 644         }
 645
 646         return FALSE;
 647 }
 648
 649 static void
 650 ev_job_print_do_page (EvJobPrint *job, gint page)
 651 {
 652         EvDocument      *document = EV_JOB (job)->document;
 653         EvRenderContext *rc;
 654
 655         rc = ev_render_context_new (0, page, 1.0);
 656         ev_file_exporter_do_page (EV_FILE_EXPORTER (document), rc);
 657         g_object_unref (rc);
 658 }
 659
 660 void
 661 ev_job_print_run (EvJobPrint *job)
 662 {
 663         EvDocument *document = EV_JOB (job)->document;
 664         gint        fd;
 665         gint        last_page;
 666         gint        first_page;
 667         gint        i;
 668         gchar      *filename;
 669
 670         g_return_if_fail (EV_IS_JOB_PRINT (job));
 671
 672         if (job->temp_file)
 673                 g_free (job->temp_file);
 674         job->temp_file = NULL;
 675
 676         if (job->error)
 677                 g_error_free (job->error);
 678         job->error = NULL;
 679
 680         filename = g_strdup_printf ("evince_print.%s.XXXXXX", job->format);
 681         fd = g_file_open_tmp (filename, &job->temp_file, &job->error);
 682         g_free (filename);
 683         if (fd <= -1) {
 684                 EV_JOB (job)->finished = TRUE;
 685                 return;
 686         }
 687
 688         first_page = ev_print_job_get_first_page (job);
 689         last_page = ev_print_job_get_last_page (job);
 690
 691         ev_document_doc_mutex_lock ();
 692         ev_file_exporter_begin (EV_FILE_EXPORTER (document),
 693                                 g_ascii_strcasecmp (job->format, "pdf") == 0 ?
 694                                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS,
 695                                 job->temp_file,
 696                                 MIN (first_page, last_page),
 697                                 MAX (first_page, last_page),
 698                                 job->width, job->height, FALSE);
 699         ev_document_doc_mutex_unlock ();
 700
 701         for (i = 0; i < job->copies; i++) {
 702                 gint page, step;
 703
 704                 step = job->reverse ? -1 : 1;
 705                 page = job->reverse ? last_page : first_page;
 706
 707                 while ((job->reverse && (page >= first_page)) ||
 708                        (!job->reverse && (page <= last_page))) {
 709                         gint n_pages = 1;
 710                         gint j;
 711
 712                         if (job->n_ranges > 0 &&
 713                             !ev_print_job_print_page_in_range (job, page)) {
 714                                 page += step;
 715                                 continue;
 716                         }
 717
 718                         if (!ev_print_job_print_page_in_set (job, page + 1)) {
 719                                 page += step;
 720                                 continue;
 721                         }
 722
 723                         if (job->collate)
 724                                 n_pages = job->copies;
 725
 726                         for (j = 0; j < n_pages; j++) {
 727                                 ev_document_doc_mutex_lock ();
 728                                 ev_job_print_do_page (job, page);
 729                                 ev_document_doc_mutex_unlock ();
 730                         }
 731
 732                         page += step;
 733                 }
 734
 735                 if (job->collate)
 736                         break;
 737         }
 738
 739         ev_document_doc_mutex_lock ();
 740         ev_file_exporter_end (EV_FILE_EXPORTER (document));
 741         ev_document_doc_mutex_unlock ();
 742
 743         close (fd);
 744
 745         EV_JOB (job)->finished = TRUE;
 746 }