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