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
  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
  20 static void ev_job_init                 (EvJob               *job);
  21 static void ev_job_class_init           (EvJobClass          *class);
  22 static void ev_job_links_init           (EvJobLinks          *job);
  23 static void ev_job_links_class_init     (EvJobLinksClass     *class);
  24 static void ev_job_render_init          (EvJobRender         *job);
  25 static void ev_job_render_class_init    (EvJobRenderClass    *class);
  26 static void ev_job_thumbnail_init       (EvJobThumbnail      *job);
  27 static void ev_job_thumbnail_class_init (EvJobThumbnailClass *class);
  28 static void ev_job_load_init            (EvJobLoad           *job);
  29 static void ev_job_load_class_init      (EvJobLoadClass      *class);
  30 static void ev_job_print_init           (EvJobPrint          *job);
  31 static void ev_job_print_class_init     (EvJobPrintClass     *class);
  32
  33 enum {
  34         FINISHED,
  35         LAST_SIGNAL
  36 };
  37
  38 enum {
  39         PAGE_READY,
  40         RENDER_LAST_SIGNAL
  41 };
  42
  43 static guint job_signals[LAST_SIGNAL] = { 0 };
  44 static guint job_render_signals[RENDER_LAST_SIGNAL] = { 0 };
  45
  46 G_DEFINE_TYPE (EvJob, ev_job, G_TYPE_OBJECT)
  47 G_DEFINE_TYPE (EvJobLinks, ev_job_links, EV_TYPE_JOB)
  48 G_DEFINE_TYPE (EvJobRender, ev_job_render, EV_TYPE_JOB)
  49 G_DEFINE_TYPE (EvJobThumbnail, ev_job_thumbnail, EV_TYPE_JOB)
  50 G_DEFINE_TYPE (EvJobFonts, ev_job_fonts, EV_TYPE_JOB)
  51 G_DEFINE_TYPE (EvJobLoad, ev_job_load, EV_TYPE_JOB)
  52 G_DEFINE_TYPE (EvJobPrint, ev_job_print, EV_TYPE_JOB)
  53
  54 static void ev_job_init (EvJob *job) { /* Do Nothing */ }
  55
  56 static void
  57 ev_job_dispose (GObject *object)
  58 {
  59         EvJob *job;
  60
  61         job = EV_JOB (object);
  62
  63         if (job->document) {
  64                 g_object_unref (job->document);
  65                 job->document = NULL;
  66         }
  67
  68         (* G_OBJECT_CLASS (ev_job_parent_class)->dispose) (object);
  69 }
  70
  71 static void
  72 ev_job_class_init (EvJobClass *class)
  73 {
  74         GObjectClass *oclass;
  75
  76         oclass = G_OBJECT_CLASS (class);
  77
  78         oclass->dispose = ev_job_dispose;
  79
  80         job_signals [FINISHED] =
  81                 g_signal_new ("finished",
  82                               EV_TYPE_JOB,
  83                               G_SIGNAL_RUN_LAST,
  84                               G_STRUCT_OFFSET (EvJobClass, finished),
  85                               NULL, NULL,
  86                               g_cclosure_marshal_VOID__VOID,
  87                               G_TYPE_NONE, 0);
  88 }
  89
  90
  91 static void ev_job_links_init (EvJobLinks *job) { /* Do Nothing */ }
  92
  93 static void
  94 ev_job_links_dispose (GObject *object)
  95 {
  96         EvJobLinks *job;
  97
  98         job = EV_JOB_LINKS (object);
  99
 100         if (job->model) {
 101                 g_object_unref (job->model);
 102                 job->model = NULL;
 103         }
 104
 105         (* G_OBJECT_CLASS (ev_job_links_parent_class)->dispose) (object);
 106 }
 107
 108 static void
 109 ev_job_links_class_init (EvJobLinksClass *class)
 110 {
 111         GObjectClass *oclass;
 112
 113         oclass = G_OBJECT_CLASS (class);
 114
 115         oclass->dispose = ev_job_links_dispose;
 116 }
 117
 118
 119 static void ev_job_render_init (EvJobRender *job) { /* Do Nothing */ }
 120
 121 static void
 122 ev_job_render_dispose (GObject *object)
 123 {
 124         EvJobRender *job;
 125
 126         job = EV_JOB_RENDER (object);
 127
 128         if (job->surface) {
 129                 cairo_surface_destroy (job->surface);
 130                 job->surface = NULL;
 131         }
 132
 133         if (job->rc) {
 134                 g_object_unref (job->rc);
 135                 job->rc = NULL;
 136         }
 137
 138         if (job->selection) {
 139                 cairo_surface_destroy (job->selection);
 140                 job->selection = NULL;
 141         }
 142
 143         if (job->selection_region) {
 144                 gdk_region_destroy (job->selection_region);
 145                 job->selection_region = NULL;
 146         }
 147
 148         (* G_OBJECT_CLASS (ev_job_render_parent_class)->dispose) (object);
 149 }
 150
 151 static void
 152 ev_job_render_class_init (EvJobRenderClass *class)
 153 {
 154         GObjectClass *oclass;
 155
 156         oclass = G_OBJECT_CLASS (class);
 157
 158         job_render_signals [PAGE_READY] =
 159                 g_signal_new ("page-ready",
 160                               EV_TYPE_JOB_RENDER,
 161                               G_SIGNAL_RUN_LAST,
 162                               G_STRUCT_OFFSET (EvJobRenderClass, page_ready),
 163                               NULL, NULL,
 164                               g_cclosure_marshal_VOID__VOID,
 165                               G_TYPE_NONE, 0);
 166
 167         oclass->dispose = ev_job_render_dispose;
 168 }
 169
 170 static void ev_job_thumbnail_init (EvJobThumbnail *job) { /* Do Nothing */ }
 171
 172 static void
 173 ev_job_thumbnail_dispose (GObject *object)
 174 {
 175         EvJobThumbnail *job;
 176
 177         job = EV_JOB_THUMBNAIL (object);
 178
 179         if (job->thumbnail) {
 180                 g_object_unref (job->thumbnail);
 181                 job->thumbnail = NULL;
 182         }
 183
 184         if (job->rc) {
 185                 g_object_unref (job->rc);
 186                 job->rc = NULL;
 187         }
 188
 189         (* G_OBJECT_CLASS (ev_job_thumbnail_parent_class)->dispose) (object);
 190 }
 191
 192 static void
 193 ev_job_thumbnail_class_init (EvJobThumbnailClass *class)
 194 {
 195         GObjectClass *oclass;
 196
 197         oclass = G_OBJECT_CLASS (class);
 198
 199         oclass->dispose = ev_job_thumbnail_dispose;
 200 }
 201
 202 static void ev_job_print_init (EvJobPrint *job) { /* Do Nothing */ }
 203
 204 static void
 205 ev_job_print_dispose (GObject *object)
 206 {
 207         EvJobPrint *job;
 208
 209         job = EV_JOB_PRINT (object);
 210
 211         if (job->temp_file) {
 212                 g_unlink (job->temp_file);
 213                 g_free (job->temp_file);
 214                 job->temp_file = NULL;
 215         }
 216
 217         if (job->error) {
 218                 g_error_free (job->error);
 219                 job->error = NULL;
 220         }
 221
 222         if (job->ranges) {
 223                 g_free (job->ranges);
 224                 job->ranges = NULL;
 225                 job->n_ranges = 0;
 226         }
 227
 228         (* G_OBJECT_CLASS (ev_job_print_parent_class)->dispose) (object);
 229 }
 230
 231 static void
 232 ev_job_print_class_init (EvJobPrintClass *class)
 233 {
 234         GObjectClass *oclass;
 235
 236         oclass = G_OBJECT_CLASS (class);
 237
 238         oclass->dispose = ev_job_print_dispose;
 239 }
 240
 241 /* Public functions */
 242 void
 243 ev_job_finished (EvJob *job)
 244 {
 245         g_return_if_fail (EV_IS_JOB (job));
 246
 247         g_signal_emit (job, job_signals[FINISHED], 0);
 248 }
 249
 250 EvJob *
 251 ev_job_links_new (EvDocument *document)
 252 {
 253         EvJob *job;
 254
 255         job = g_object_new (EV_TYPE_JOB_LINKS, NULL);
 256         job->document = g_object_ref (document);
 257
 258         return job;
 259 }
 260
 261 void
 262 ev_job_links_run (EvJobLinks *job)
 263 {
 264         g_return_if_fail (EV_IS_JOB_LINKS (job));
 265
 266         ev_document_doc_mutex_lock ();
 267         job->model = ev_document_links_get_links_model (EV_DOCUMENT_LINKS (EV_JOB (job)->document));
 268         EV_JOB (job)->finished = TRUE;
 269         ev_document_doc_mutex_unlock ();
 270 }
 271
 272
 273 EvJob *
 274 ev_job_render_new (EvDocument      *document,
 275                    EvRenderContext *rc,
 276                    gint             width,
 277                    gint             height,
 278                    EvRectangle     *selection_points,
 279                    GdkColor        *text,
 280                    GdkColor        *base,
 281                    gboolean         include_forms,
 282                    gboolean         include_links,
 283                    gboolean         include_images,
 284                    gboolean         include_text,
 285                    gboolean         include_selection)
 286 {
 287         EvJobRender *job;
 288
 289         g_return_val_if_fail (EV_IS_RENDER_CONTEXT (rc), NULL);
 290         if (include_selection)
 291                 g_return_val_if_fail (selection_points != NULL, NULL);
 292
 293         job = g_object_new (EV_TYPE_JOB_RENDER, NULL);
 294
 295         EV_JOB (job)->document = g_object_ref (document);
 296         job->rc = g_object_ref (rc);
 297         job->target_width = width;
 298         job->target_height = height;
 299         job->text = *text;
 300         job->base = *base;
 301         job->include_forms = include_forms;
 302         job->include_links = include_links;
 303         job->include_images = include_images;
 304         job->include_text = include_text;
 305         job->include_selection = include_selection;
 306
 307         if (include_selection)
 308                 job->selection_points = *selection_points;
 309
 310         if (EV_IS_ASYNC_RENDERER (document)) {
 311                 EV_JOB (job)->async = TRUE;
 312         }
 313
 314         return EV_JOB (job);
 315 }
 316
 317 static void
 318 render_finished_cb (EvDocument      *document,
 319                     GdkPixbuf       *pixbuf,
 320                     EvJobRender     *job)
 321 {
 322         g_signal_handlers_disconnect_by_func (EV_JOB (job)->document,
 323                                               render_finished_cb, job);
 324
 325         /* FIXME: ps backend should be ported to cairo */
 326         job->surface = ev_document_misc_surface_from_pixbuf (pixbuf);
 327         job->page_ready = TRUE;
 328         g_signal_emit (job, job_render_signals[PAGE_READY], 0);
 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_full (G_PRIORITY_HIGH_IDLE,
 346                          (GSourceFunc)notify_page_ready,
 347                          g_object_ref (job),
 348                          (GDestroyNotify)g_object_unref);
 349 }
 350
 351 void
 352 ev_job_render_run (EvJobRender *job)
 353 {
 354         g_return_if_fail (EV_IS_JOB_RENDER (job));
 355
 356         ev_document_doc_mutex_lock ();
 357
 358         if (EV_JOB (job)->async) {
 359                 EvAsyncRenderer *renderer = EV_ASYNC_RENDERER (EV_JOB (job)->document);
 360                 ev_async_renderer_render_pixbuf (renderer, job->rc->page, job->rc->scale,
 361                                                  job->rc->rotation);
 362                 g_signal_connect (EV_JOB (job)->document, "render_finished",
 363                                   G_CALLBACK (render_finished_cb), job);
 364         } else {
 365                 ev_document_fc_mutex_lock ();
 366
 367                 job->surface = ev_document_render (EV_JOB (job)->document, job->rc);
 368                 if (job->include_selection && EV_IS_SELECTION (EV_JOB (job)->document)) {
 369                         ev_selection_render_selection (EV_SELECTION (EV_JOB (job)->document),
 370                                                        job->rc,
 371                                                        &(job->selection),
 372                                                        &(job->selection_points),
 373                                                        NULL,
 374                                                        &(job->text), &(job->base));
 375                         job->selection_region =
 376                                 ev_selection_get_selection_region (EV_SELECTION (EV_JOB (job)->document),
 377                                                                    job->rc,
 378                                                                    &(job->selection_points));
 379                 }
 380
 381                 ev_job_render_page_ready (job);
 382
 383                 ev_document_fc_mutex_unlock ();
 384
 385                 if (job->include_text && EV_IS_SELECTION (EV_JOB (job)->document))
 386                         job->text_mapping =
 387                                 ev_selection_get_selection_map (EV_SELECTION (EV_JOB (job)->document),
 388                                                                 job->rc);
 389                 if (job->include_links && EV_IS_DOCUMENT_LINKS (EV_JOB (job)->document))
 390                         job->link_mapping =
 391                                 ev_document_links_get_links (EV_DOCUMENT_LINKS (EV_JOB (job)->document),
 392                                                              job->rc->page);
 393                 if (job->include_forms && EV_IS_DOCUMENT_FORMS (EV_JOB (job)->document))
 394                         job->form_field_mapping =
 395                                 ev_document_forms_get_form_fields (EV_DOCUMENT_FORMS (EV_JOB(job)->document),
 396                                                                    job->rc->page);
 397                 if (job->include_images && EV_IS_DOCUMENT_IMAGES (EV_JOB (job)->document))
 398                         job->image_mapping =
 399                                 ev_document_images_get_images (EV_DOCUMENT_IMAGES (EV_JOB (job)->document),
 400                                                                job->rc->page);
 401                 EV_JOB (job)->finished = TRUE;
 402         }
 403
 404         ev_document_doc_mutex_unlock ();
 405 }
 406
 407 EvJob *
 408 ev_job_thumbnail_new (EvDocument      *document,
 409                       EvRenderContext *rc)
 410 {
 411         EvJobThumbnail *job;
 412
 413         job = g_object_new (EV_TYPE_JOB_THUMBNAIL, NULL);
 414
 415         EV_JOB (job)->document = g_object_ref (document);
 416         job->rc = g_object_ref (rc);
 417
 418         return EV_JOB (job);
 419 }
 420
 421 void
 422 ev_job_thumbnail_run (EvJobThumbnail *job)
 423 {
 424         g_return_if_fail (EV_IS_JOB_THUMBNAIL (job));
 425
 426         ev_document_doc_mutex_lock ();
 427
 428         job->thumbnail =
 429                 ev_document_thumbnails_get_thumbnail (EV_DOCUMENT_THUMBNAILS (EV_JOB (job)->document),
 430                                                       job->rc, TRUE);
 431         EV_JOB (job)->finished = TRUE;
 432
 433         ev_document_doc_mutex_unlock ();
 434 }
 435
 436 static void ev_job_fonts_init (EvJobFonts *job) { /* Do Nothing */ }
 437
 438 static void ev_job_fonts_class_init (EvJobFontsClass *class) { /* Do Nothing */ }
 439
 440 EvJob *
 441 ev_job_fonts_new (EvDocument *document)
 442 {
 443         EvJobFonts *job;
 444
 445         job = g_object_new (EV_TYPE_JOB_FONTS, NULL);
 446
 447         EV_JOB (job)->document = g_object_ref (document);
 448
 449         return EV_JOB (job);
 450 }
 451
 452 void
 453 ev_job_fonts_run (EvJobFonts *job)
 454 {
 455         EvDocumentFonts *fonts;
 456
 457         g_return_if_fail (EV_IS_JOB_FONTS (job));
 458
 459         ev_document_doc_mutex_lock ();
 460
 461         fonts = EV_DOCUMENT_FONTS (EV_JOB (job)->document);
 462         ev_document_fc_mutex_lock ();
 463         job->scan_completed = !ev_document_fonts_scan (fonts, 20);
 464         ev_document_fc_mutex_unlock ();
 465
 466         EV_JOB (job)->finished = TRUE;
 467
 468         ev_document_doc_mutex_unlock ();
 469 }
 470
 471 static void ev_job_load_init (EvJobLoad *job) { /* Do Nothing */ }
 472
 473 static void
 474 ev_job_load_dispose (GObject *object)
 475 {
 476         EvJobLoad *job = EV_JOB_LOAD (object);
 477
 478         if (job->uri) {
 479                 g_free (job->uri);
 480                 job->uri = NULL;
 481         }
 482
 483         if (job->error) {
 484                 g_error_free (job->error);
 485                 job->error = NULL;
 486         }
 487
 488         if (job->dest) {
 489                 g_object_unref (job->dest);
 490                 job->dest = NULL;
 491         }
 492
 493         (* G_OBJECT_CLASS (ev_job_load_parent_class)->dispose) (object);
 494 }
 495
 496 static void
 497 ev_job_load_class_init (EvJobLoadClass *class)
 498 {
 499         GObjectClass *oclass;
 500
 501         oclass = G_OBJECT_CLASS (class);
 502
 503         oclass->dispose = ev_job_load_dispose;
 504 }
 505
 506
 507 EvJob *
 508 ev_job_load_new (const gchar *uri, EvLinkDest *dest, EvWindowRunMode mode)
 509 {
 510         EvJobLoad *job;
 511
 512         job = g_object_new (EV_TYPE_JOB_LOAD, NULL);
 513
 514         job->uri = g_strdup (uri);
 515         if (dest)
 516                 job->dest = g_object_ref (dest);
 517
 518         job->mode = mode;
 519
 520         return EV_JOB (job);
 521 }
 522
 523 void
 524 ev_job_load_set_uri (EvJobLoad *job, const gchar *uri)
 525 {
 526         if (job->uri)
 527                 g_free (job->uri);
 528         job->uri = g_strdup (uri);
 529 }
 530
 531 void
 532 ev_job_load_run (EvJobLoad *job)
 533 {
 534         g_return_if_fail (EV_IS_JOB_LOAD (job));
 535
 536         if (job->error) {
 537                 g_error_free (job->error);
 538                 job->error = NULL;
 539         }
 540
 541         ev_document_fc_mutex_lock ();
 542
 543         /* This job may already have a document even if the job didn't complete
 544            because, e.g., a password is required - if so, just reload rather than
 545            creating a new instance */
 546         if (EV_JOB (job)->document) {
 547                 ev_document_load (EV_JOB (job)->document,
 548                                   job->uri,
 549                                   &job->error);
 550         } else {
 551                 EV_JOB(job)->document =
 552                         ev_document_factory_get_document (job->uri,
 553                                                           &job->error);
 554         }
 555
 556         ev_document_fc_mutex_unlock ();
 557         EV_JOB (job)->finished = TRUE;
 558 }
 559
 560 EvJob *
 561 ev_job_print_new (EvDocument    *document,
 562                   const gchar   *format,
 563                   gdouble        width,
 564                   gdouble        height,
 565                   EvFileExporterOrientation orientation,
 566                   EvPrintRange  *ranges,
 567                   gint           n_ranges,
 568                   EvPrintPageSet page_set,
 569                   gint           pages_per_sheet,
 570                   gint           copies,
 571                   gdouble        collate,
 572                   gdouble        reverse)
 573 {
 574         EvJobPrint *job;
 575
 576         job = g_object_new (EV_TYPE_JOB_PRINT, NULL);
 577
 578         EV_JOB (job)->document = g_object_ref (document);
 579
 580         job->format = format;
 581
 582         job->temp_file = NULL;
 583         job->error = NULL;
 584
 585         job->width = width;
 586         job->height = height;
 587         job->orientation = orientation;
 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.orientation = job->orientation;
 722         fc.duplex = FALSE;
 723         fc.pages_per_sheet = MAX (1, job->pages_per_sheet);
 724
 725         ev_document_doc_mutex_lock ();
 726         ev_file_exporter_begin (EV_FILE_EXPORTER (document), &fc);
 727         ev_document_doc_mutex_unlock ();
 728
 729         for (i = 0; i < job->copies; i++) {
 730                 gint page, step;
 731
 732                 step = job->reverse ? -1 : 1;
 733                 page = job->reverse ? last_page : first_page;
 734
 735                 while ((job->reverse && (page >= first_page)) ||
 736                        (!job->reverse && (page <= last_page))) {
 737                         gint n_pages = 1;
 738                         gint j;
 739
 740                         if (job->n_ranges > 0 &&
 741                             !ev_print_job_print_page_in_range (job, page)) {
 742                                 page += step;
 743                                 continue;
 744                         }
 745
 746                         if (!ev_print_job_print_page_in_set (job, page + 1)) {
 747                                 page += step;
 748                                 continue;
 749                         }
 750
 751                         if (job->collate)
 752                                 n_pages = job->copies;
 753
 754                         for (j = 0; j < n_pages; j++) {
 755                                 ev_document_doc_mutex_lock ();
 756                                 ev_job_print_do_page (job, page);
 757                                 ev_document_doc_mutex_unlock ();
 758                         }
 759
 760                         page += step;
 761                 }
 762
 763                 if (job->collate)
 764                         break;
 765         }
 766
 767         ev_document_doc_mutex_lock ();
 768         ev_file_exporter_end (EV_FILE_EXPORTER (document));
 769         ev_document_doc_mutex_unlock ();
 770
 771         close (fd);
 772
 773         EV_JOB (job)->finished = TRUE;
 774 }