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         job->page_ready = TRUE;
 330         g_signal_emit (job, job_render_signals[PAGE_READY], 0);
 331         EV_JOB (job)->finished = TRUE;
 332         ev_job_finished (EV_JOB (job));
 333 }
 334
 335 static gboolean
 336 notify_page_ready (EvJobRender *job)
 337 {
 338         g_signal_emit (job, job_render_signals[PAGE_READY], 0);
 339
 340         return FALSE;
 341 }
 342
 343 static void
 344 ev_job_render_page_ready (EvJobRender *job)
 345 {
 346         job->page_ready = TRUE;
 347         g_idle_add_full (G_PRIORITY_HIGH_IDLE,
 348                          (GSourceFunc)notify_page_ready,
 349                          g_object_ref (job),
 350                          (GDestroyNotify)g_object_unref);
 351 }
 352
 353 void
 354 ev_job_render_run (EvJobRender *job)
 355 {
 356         g_return_if_fail (EV_IS_JOB_RENDER (job));
 357
 358         ev_document_doc_mutex_lock ();
 359
 360         if (EV_JOB (job)->async) {
 361                 EvAsyncRenderer *renderer = EV_ASYNC_RENDERER (EV_JOB (job)->document);
 362                 ev_async_renderer_render_pixbuf (renderer, job->rc->page, job->rc->scale,
 363                                                  job->rc->rotation);
 364                 g_signal_connect (EV_JOB (job)->document, "render_finished",
 365                                   G_CALLBACK (render_finished_cb), job);
 366         } else {
 367                 ev_document_fc_mutex_lock ();
 368
 369                 job->surface = ev_document_render (EV_JOB (job)->document, job->rc);
 370                 if (job->include_selection && EV_IS_SELECTION (EV_JOB (job)->document)) {
 371                         ev_selection_render_selection (EV_SELECTION (EV_JOB (job)->document),
 372                                                        job->rc,
 373                                                        &(job->selection),
 374                                                        &(job->selection_points),
 375                                                        NULL,
 376                                                        &(job->text), &(job->base));
 377                         job->selection_region =
 378                                 ev_selection_get_selection_region (EV_SELECTION (EV_JOB (job)->document),
 379                                                                    job->rc,
 380                                                                    &(job->selection_points));
 381                 }
 382
 383                 ev_job_render_page_ready (job);
 384
 385                 ev_document_fc_mutex_unlock ();
 386
 387                 if (job->include_text && EV_IS_SELECTION (EV_JOB (job)->document))
 388                         job->text_mapping =
 389                                 ev_selection_get_selection_map (EV_SELECTION (EV_JOB (job)->document),
 390                                                                 job->rc);
 391                 if (job->include_links && EV_IS_DOCUMENT_LINKS (EV_JOB (job)->document))
 392                         job->link_mapping =
 393                                 ev_document_links_get_links (EV_DOCUMENT_LINKS (EV_JOB (job)->document),
 394                                                              job->rc->page);
 395                 if (job->include_forms && EV_IS_DOCUMENT_FORMS (EV_JOB (job)->document))
 396                         job->form_field_mapping =
 397                                 ev_document_forms_get_form_fields (EV_DOCUMENT_FORMS (EV_JOB(job)->document),
 398                                                                    job->rc->page);
 399                 if (job->include_images && EV_IS_DOCUMENT_IMAGES (EV_JOB (job)->document))
 400                         job->image_mapping =
 401                                 ev_document_images_get_images (EV_DOCUMENT_IMAGES (EV_JOB (job)->document),
 402                                                                job->rc->page);
 403                 EV_JOB (job)->finished = TRUE;
 404         }
 405
 406         ev_document_doc_mutex_unlock ();
 407 }
 408
 409 EvJob *
 410 ev_job_thumbnail_new (EvDocument      *document,
 411                       EvRenderContext *rc)
 412 {
 413         EvJobThumbnail *job;
 414
 415         job = g_object_new (EV_TYPE_JOB_THUMBNAIL, NULL);
 416
 417         EV_JOB (job)->document = g_object_ref (document);
 418         job->rc = g_object_ref (rc);
 419
 420         return EV_JOB (job);
 421 }
 422
 423 void
 424 ev_job_thumbnail_run (EvJobThumbnail *job)
 425 {
 426         g_return_if_fail (EV_IS_JOB_THUMBNAIL (job));
 427
 428         ev_document_doc_mutex_lock ();
 429
 430         job->thumbnail =
 431                 ev_document_thumbnails_get_thumbnail (EV_DOCUMENT_THUMBNAILS (EV_JOB (job)->document),
 432                                                       job->rc, TRUE);
 433         EV_JOB (job)->finished = TRUE;
 434
 435         ev_document_doc_mutex_unlock ();
 436 }
 437
 438 static void ev_job_fonts_init (EvJobFonts *job) { /* Do Nothing */ }
 439
 440 static void ev_job_fonts_class_init (EvJobFontsClass *class) { /* Do Nothing */ }
 441
 442 EvJob *
 443 ev_job_fonts_new (EvDocument *document)
 444 {
 445         EvJobFonts *job;
 446
 447         job = g_object_new (EV_TYPE_JOB_FONTS, NULL);
 448
 449         EV_JOB (job)->document = g_object_ref (document);
 450
 451         return EV_JOB (job);
 452 }
 453
 454 void
 455 ev_job_fonts_run (EvJobFonts *job)
 456 {
 457         EvDocumentFonts *fonts;
 458
 459         g_return_if_fail (EV_IS_JOB_FONTS (job));
 460
 461         ev_document_doc_mutex_lock ();
 462
 463         fonts = EV_DOCUMENT_FONTS (EV_JOB (job)->document);
 464         ev_document_fc_mutex_lock ();
 465         job->scan_completed = !ev_document_fonts_scan (fonts, 20);
 466         ev_document_fc_mutex_unlock ();
 467
 468         EV_JOB (job)->finished = TRUE;
 469
 470         ev_document_doc_mutex_unlock ();
 471 }
 472
 473 static void ev_job_load_init (EvJobLoad *job) { /* Do Nothing */ }
 474
 475 static void
 476 ev_job_load_dispose (GObject *object)
 477 {
 478         EvJobLoad *job = EV_JOB_LOAD (object);
 479
 480         if (job->uri) {
 481                 g_free (job->uri);
 482                 job->uri = NULL;
 483         }
 484
 485         if (job->error) {
 486                 g_error_free (job->error);
 487                 job->error = NULL;
 488         }
 489
 490         if (job->dest) {
 491                 g_object_unref (job->dest);
 492                 job->dest = NULL;
 493         }
 494
 495         (* G_OBJECT_CLASS (ev_job_load_parent_class)->dispose) (object);
 496 }
 497
 498 static void
 499 ev_job_load_class_init (EvJobLoadClass *class)
 500 {
 501         GObjectClass *oclass;
 502
 503         oclass = G_OBJECT_CLASS (class);
 504
 505         oclass->dispose = ev_job_load_dispose;
 506 }
 507
 508
 509 EvJob *
 510 ev_job_load_new (const gchar *uri, EvLinkDest *dest, EvWindowRunMode mode)
 511 {
 512         EvJobLoad *job;
 513
 514         job = g_object_new (EV_TYPE_JOB_LOAD, NULL);
 515
 516         job->uri = g_strdup (uri);
 517         if (dest)
 518                 job->dest = g_object_ref (dest);
 519
 520         job->mode = mode;
 521
 522         return EV_JOB (job);
 523 }
 524
 525 void
 526 ev_job_load_set_uri (EvJobLoad *job, const gchar *uri)
 527 {
 528         if (job->uri)
 529                 g_free (job->uri);
 530         job->uri = g_strdup (uri);
 531 }
 532
 533 void
 534 ev_job_load_run (EvJobLoad *job)
 535 {
 536         g_return_if_fail (EV_IS_JOB_LOAD (job));
 537
 538         if (job->error) {
 539                 g_error_free (job->error);
 540                 job->error = NULL;
 541         }
 542
 543         ev_document_fc_mutex_lock ();
 544
 545         /* This job may already have a document even if the job didn't complete
 546            because, e.g., a password is required - if so, just reload rather than
 547            creating a new instance */
 548         if (EV_JOB (job)->document) {
 549                 ev_document_load (EV_JOB (job)->document,
 550                                   job->uri,
 551                                   &job->error);
 552         } else {
 553                 EV_JOB(job)->document =
 554                         ev_document_factory_get_document (job->uri,
 555                                                           &job->error);
 556         }
 557
 558         ev_document_fc_mutex_unlock ();
 559         EV_JOB (job)->finished = TRUE;
 560 }
 561
 562 EvJob *
 563 ev_job_print_new (EvDocument    *document,
 564                   const gchar   *format,
 565                   gdouble        width,
 566                   gdouble        height,
 567                   EvPrintRange  *ranges,
 568                   gint           n_ranges,
 569                   EvPrintPageSet page_set,
 570                   gint           pages_per_sheet,
 571                   gint           copies,
 572                   gdouble        collate,
 573                   gdouble        reverse)
 574 {
 575         EvJobPrint *job;
 576
 577         job = g_object_new (EV_TYPE_JOB_PRINT, NULL);
 578
 579         EV_JOB (job)->document = g_object_ref (document);
 580
 581         job->format = format;
 582
 583         job->temp_file = NULL;
 584         job->error = NULL;
 585
 586         job->width = width;
 587         job->height = height;
 588
 589         job->ranges = ranges;
 590         job->n_ranges = n_ranges;
 591
 592         job->page_set = page_set;
 593
 594         job->pages_per_sheet = pages_per_sheet;
 595
 596         job->copies = copies;
 597         job->collate = collate;
 598         job->reverse = reverse;
 599
 600         return EV_JOB (job);
 601 }
 602
 603 static gint
 604 ev_print_job_get_first_page (EvJobPrint *job)
 605 {
 606         gint i;
 607         gint first_page = G_MAXINT;
 608
 609         if (job->n_ranges == 0)
 610                 return 0;
 611
 612         for (i = 0; i < job->n_ranges; i++) {
 613                 if (job->ranges[i].start < first_page)
 614                         first_page = job->ranges[i].start;
 615         }
 616
 617         return MAX (0, first_page);
 618 }
 619
 620 static gint
 621 ev_print_job_get_last_page (EvJobPrint *job)
 622 {
 623         gint i;
 624         gint last_page = G_MININT;
 625         gint max_page;
 626
 627         max_page = ev_document_get_n_pages (EV_JOB (job)->document) - 1;
 628
 629         if (job->n_ranges == 0)
 630                 return max_page;
 631
 632         for (i = 0; i < job->n_ranges; i++) {
 633                 if (job->ranges[i].end > last_page)
 634                         last_page = job->ranges[i].end;
 635         }
 636
 637         return MIN (max_page, last_page);
 638 }
 639
 640 static gboolean
 641 ev_print_job_print_page_in_range (EvJobPrint *job,
 642                                   gint        page)
 643 {
 644         gint i;
 645
 646         for (i = 0; i < job->n_ranges; i++) {
 647                 if (page >= job->ranges[i].start &&
 648                     page <= job->ranges[i].end)
 649                         return TRUE;
 650         }
 651
 652         return FALSE;
 653 }
 654
 655 static gboolean
 656 ev_print_job_print_page_in_set (EvJobPrint *job,
 657                                 gint        page)
 658 {
 659         switch (job->page_set) {
 660                 case EV_PRINT_PAGE_SET_EVEN:
 661                         return page % 2 == 0;
 662                 case EV_PRINT_PAGE_SET_ODD:
 663                         return page % 2 != 0;
 664                 case EV_PRINT_PAGE_SET_ALL:
 665                         return TRUE;
 666         }
 667
 668         return FALSE;
 669 }
 670
 671 static void
 672 ev_job_print_do_page (EvJobPrint *job, gint page)
 673 {
 674         EvDocument      *document = EV_JOB (job)->document;
 675         EvRenderContext *rc;
 676
 677         rc = ev_render_context_new (0, page, 1.0);
 678         ev_file_exporter_do_page (EV_FILE_EXPORTER (document), rc);
 679         g_object_unref (rc);
 680 }
 681
 682 void
 683 ev_job_print_run (EvJobPrint *job)
 684 {
 685         EvDocument            *document = EV_JOB (job)->document;
 686         EvFileExporterContext  fc;
 687         gint                   fd;
 688         gint                   last_page;
 689         gint                   first_page;
 690         gint                   i;
 691         gchar                 *filename;
 692
 693         g_return_if_fail (EV_IS_JOB_PRINT (job));
 694
 695         if (job->temp_file)
 696                 g_free (job->temp_file);
 697         job->temp_file = NULL;
 698
 699         if (job->error)
 700                 g_error_free (job->error);
 701         job->error = NULL;
 702
 703         filename = g_strdup_printf ("evince_print.%s.XXXXXX", job->format);
 704         fd = g_file_open_tmp (filename, &job->temp_file, &job->error);
 705         g_free (filename);
 706         if (fd <= -1) {
 707                 EV_JOB (job)->finished = TRUE;
 708                 return;
 709         }
 710
 711         first_page = ev_print_job_get_first_page (job);
 712         last_page = ev_print_job_get_last_page (job);
 713
 714         fc.format = g_ascii_strcasecmp (job->format, "pdf") == 0 ?
 715                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
 716         fc.filename = job->temp_file;
 717         fc.first_page = MIN (first_page, last_page);
 718         fc.last_page = MAX (first_page, last_page);
 719         fc.paper_width = job->width;
 720         fc.paper_height = job->height;
 721         fc.duplex = FALSE;
 722         fc.pages_per_sheet = job->pages_per_sheet;
 723
 724         ev_document_doc_mutex_lock ();
 725         ev_file_exporter_begin (EV_FILE_EXPORTER (document), &fc);
 726         ev_document_doc_mutex_unlock ();
 727
 728         for (i = 0; i < job->copies; i++) {
 729                 gint page, step;
 730
 731                 step = job->reverse ? -1 : 1;
 732                 page = job->reverse ? last_page : first_page;
 733
 734                 while ((job->reverse && (page >= first_page)) ||
 735                        (!job->reverse && (page <= last_page))) {
 736                         gint n_pages = 1;
 737                         gint j;
 738
 739                         if (job->n_ranges > 0 &&
 740                             !ev_print_job_print_page_in_range (job, page)) {
 741                                 page += step;
 742                                 continue;
 743                         }
 744
 745                         if (!ev_print_job_print_page_in_set (job, page + 1)) {
 746                                 page += step;
 747                                 continue;
 748                         }
 749
 750                         if (job->collate)
 751                                 n_pages = job->copies;
 752
 753                         for (j = 0; j < n_pages; j++) {
 754                                 ev_document_doc_mutex_lock ();
 755                                 ev_job_print_do_page (job, page);
 756                                 ev_document_doc_mutex_unlock ();
 757                         }
 758
 759                         page += step;
 760                 }
 761
 762                 if (job->collate)
 763                         break;
 764         }
 765
 766         ev_document_doc_mutex_lock ();
 767         ev_file_exporter_end (EV_FILE_EXPORTER (document));
 768         ev_document_doc_mutex_unlock ();
 769
 770         close (fd);
 771
 772         EV_JOB (job)->finished = TRUE;
 773 }