shell/ev-print-operation.c

   1 /* this file is part of evince, a gnome document viewer
   2  *
   3  *  Copyright (C) 2008 Carlos Garcia Campos <carlosgc@gnome.org>
   4  *
   5  * Evince is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * Evince is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <config.h>
  21
  22 #include "ev-print-operation.h"
  23
  24 #if GTK_CHECK_VERSION (2, 14, 0)
  25 #include <gtk/gtkunixprint.h>
  26 #else
  27 #include <gtk/gtkprintunixdialog.h>
  28 #endif
  29
  30 #include <glib/gi18n.h>
  31 #include <glib/gstdio.h>
  32 #include <unistd.h>
  33
  34 #include "ev-page-cache.h"
  35 #include "ev-file-exporter.h"
  36 #include "ev-jobs.h"
  37 #include "ev-job-scheduler.h"
  38 #include "ev-application.h"
  39 #include "ev-file-helpers.h"
  40
  41 enum {
  42         PROP_0,
  43         PROP_DOCUMENT
  44 };
  45
  46 enum {
  47         DONE,
  48         BEGIN_PRINT,
  49         STATUS_CHANGED,
  50         LAST_SIGNAL
  51 };
  52
  53 static guint signals[LAST_SIGNAL] = { 0 };
  54
  55 struct _EvPrintOperation {
  56         GObject parent;
  57
  58         EvDocument *document;
  59
  60         /* Progress */
  61         gchar      *status;
  62         gdouble     progress;
  63 };
  64
  65 struct _EvPrintOperationClass {
  66         GObjectClass parent_class;
  67
  68         void              (* set_current_page)       (EvPrintOperation       *op,
  69                                                       gint                    current_page);
  70         void              (* set_print_settings)     (EvPrintOperation       *op,
  71                                                       GtkPrintSettings       *print_settings);
  72         GtkPrintSettings *(* get_print_settings)     (EvPrintOperation       *op);
  73         void              (* set_default_page_setup) (EvPrintOperation       *op,
  74                                                       GtkPageSetup           *page_setup);
  75         GtkPageSetup     *(* get_default_page_setup) (EvPrintOperation       *op);
  76         void              (* set_job_name)           (EvPrintOperation       *op,
  77                                                       const gchar            *job_name);
  78         const gchar      *(* get_job_name)           (EvPrintOperation       *op);
  79         void              (* run)                    (EvPrintOperation       *op,
  80                                                       GtkWindow              *parent);
  81         void              (* cancel)                 (EvPrintOperation       *op);
  82         void              (* get_error)              (EvPrintOperation       *op,
  83                                                       GError                **error);
  84
  85         /* signals */
  86         void              (* done)                   (EvPrintOperation       *op,
  87                                                       GtkPrintOperationResult result);
  88         void              (* begin_print)            (EvPrintOperation       *op);
  89         void              (* status_changed)         (EvPrintOperation       *op);
  90
  91 };
  92
  93 G_DEFINE_ABSTRACT_TYPE (EvPrintOperation, ev_print_operation, G_TYPE_OBJECT)
  94
  95 static void
  96 ev_print_operation_finalize (GObject *object)
  97 {
  98         EvPrintOperation *op = EV_PRINT_OPERATION (object);
  99
 100         if (op->document) {
 101                 g_object_unref (op->document);
 102                 op->document = NULL;
 103         }
 104
 105         if (op->status) {
 106                 g_free (op->status);
 107                 op->status = NULL;
 108         }
 109
 110         (* G_OBJECT_CLASS (ev_print_operation_parent_class)->finalize) (object);
 111 }
 112
 113 static void
 114 ev_print_operation_set_property (GObject      *object,
 115                                  guint         prop_id,
 116                                  const GValue *value,
 117                                  GParamSpec   *pspec)
 118 {
 119         EvPrintOperation *op = EV_PRINT_OPERATION (object);
 120
 121         switch (prop_id) {
 122         case PROP_DOCUMENT:
 123                 op->document = g_value_dup_object (value);
 124                 break;
 125         default:
 126                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 127         }
 128 }
 129
 130 static void
 131 ev_print_operation_init (EvPrintOperation *op)
 132 {
 133 }
 134
 135 static void
 136 ev_print_operation_class_init (EvPrintOperationClass *klass)
 137 {
 138         GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
 139
 140         g_object_class->set_property = ev_print_operation_set_property;
 141         g_object_class->finalize = ev_print_operation_finalize;
 142
 143         g_object_class_install_property (g_object_class,
 144                                          PROP_DOCUMENT,
 145                                          g_param_spec_object ("document",
 146                                                               "Document",
 147                                                               "The document to print",
 148                                                               EV_TYPE_DOCUMENT,
 149                                                               G_PARAM_WRITABLE |
 150                                                               G_PARAM_CONSTRUCT_ONLY));
 151         signals[DONE] =
 152                 g_signal_new ("done",
 153                               G_TYPE_FROM_CLASS (g_object_class),
 154                               G_SIGNAL_RUN_LAST,
 155                               G_STRUCT_OFFSET (EvPrintOperationClass, done),
 156                               NULL, NULL,
 157                               g_cclosure_marshal_VOID__ENUM,
 158                               G_TYPE_NONE, 1,
 159                               GTK_TYPE_PRINT_OPERATION_RESULT);
 160         signals[BEGIN_PRINT] =
 161                 g_signal_new ("begin_print",
 162                               G_TYPE_FROM_CLASS (g_object_class),
 163                               G_SIGNAL_RUN_LAST,
 164                               G_STRUCT_OFFSET (EvPrintOperationClass, begin_print),
 165                               NULL, NULL,
 166                               g_cclosure_marshal_VOID__VOID,
 167                               G_TYPE_NONE, 0);
 168         signals[STATUS_CHANGED] =
 169                 g_signal_new ("status_changed",
 170                               G_TYPE_FROM_CLASS (g_object_class),
 171                               G_SIGNAL_RUN_LAST,
 172                               G_STRUCT_OFFSET (EvPrintOperationClass, status_changed),
 173                               NULL, NULL,
 174                               g_cclosure_marshal_VOID__VOID,
 175                               G_TYPE_NONE, 0);
 176 }
 177
 178 /* Public methods */
 179 void
 180 ev_print_operation_set_current_page (EvPrintOperation *op,
 181                                      gint              current_page)
 182 {
 183         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 184
 185         g_return_if_fail (EV_IS_PRINT_OPERATION (op));
 186         g_return_if_fail (current_page >= 0);
 187
 188         class->set_current_page (op, current_page);
 189 }
 190
 191 void
 192 ev_print_operation_set_print_settings (EvPrintOperation *op,
 193                                        GtkPrintSettings *print_settings)
 194 {
 195         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 196
 197         g_return_if_fail (EV_IS_PRINT_OPERATION (op));
 198         g_return_if_fail (GTK_IS_PRINT_SETTINGS (print_settings));
 199
 200         class->set_print_settings (op, print_settings);
 201 }
 202
 203 GtkPrintSettings *
 204 ev_print_operation_get_print_settings (EvPrintOperation *op)
 205 {
 206         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 207
 208         g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
 209
 210         return class->get_print_settings (op);
 211 }
 212
 213 void
 214 ev_print_operation_set_default_page_setup (EvPrintOperation *op,
 215                                            GtkPageSetup     *page_setup)
 216 {
 217         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 218
 219         g_return_if_fail (EV_IS_PRINT_OPERATION (op));
 220         g_return_if_fail (GTK_IS_PAGE_SETUP (page_setup));
 221
 222         class->set_default_page_setup (op, page_setup);
 223 }
 224
 225 GtkPageSetup *
 226 ev_print_operation_get_default_page_setup (EvPrintOperation *op)
 227 {
 228         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 229
 230         g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
 231
 232         return class->get_default_page_setup (op);
 233 }
 234
 235 void
 236 ev_print_operation_set_job_name (EvPrintOperation *op,
 237                                  const gchar      *job_name)
 238 {
 239         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 240
 241         g_return_if_fail (EV_IS_PRINT_OPERATION (op));
 242         g_return_if_fail (job_name != NULL);
 243
 244         class->set_job_name (op, job_name);
 245 }
 246
 247 const gchar *
 248 ev_print_operation_get_job_name (EvPrintOperation *op)
 249 {
 250         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 251
 252         g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
 253
 254         return class->get_job_name (op);
 255 }
 256
 257 void
 258 ev_print_operation_run (EvPrintOperation *op,
 259                         GtkWindow        *parent)
 260 {
 261         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 262
 263         g_return_if_fail (EV_IS_PRINT_OPERATION (op));
 264
 265         class->run (op, parent);
 266 }
 267
 268 void
 269 ev_print_operation_cancel (EvPrintOperation *op)
 270 {
 271         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 272
 273         g_return_if_fail (EV_IS_PRINT_OPERATION (op));
 274
 275         class->cancel (op);
 276 }
 277
 278 void
 279 ev_print_operation_get_error (EvPrintOperation *op,
 280                               GError          **error)
 281 {
 282         EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
 283
 284         g_return_if_fail (EV_IS_PRINT_OPERATION (op));
 285
 286         class->get_error (op, error);
 287 }
 288
 289 const gchar *
 290 ev_print_operation_get_status (EvPrintOperation *op)
 291 {
 292         g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
 293
 294         return op->status ? op->status : "";
 295 }
 296
 297 gdouble
 298 ev_print_operation_get_progress (EvPrintOperation *op)
 299 {
 300         g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), 0.0);
 301
 302         return op->progress;
 303 }
 304
 305 static void
 306 ev_print_operation_update_status (EvPrintOperation *op,
 307                                   gint              page,
 308                                   gint              n_pages,
 309                                   gdouble           progress)
 310 {
 311         if (op->status && op->progress == progress)
 312                 return;
 313
 314         g_free (op->status);
 315
 316         if (page == -1) {
 317                 /* Initial state */
 318                 op->status = g_strdup (_("Preparing to print ..."));
 319         } else if (page > n_pages) {
 320                 op->status = g_strdup (_("Finishing..."));
 321         } else {
 322                 op->status = g_strdup_printf (_("Printing page %d of %d..."),
 323                                               page, n_pages);
 324         }
 325
 326         op->progress = MIN (1.0, progress);
 327
 328         g_signal_emit (op, signals[STATUS_CHANGED], 0);
 329 }
 330
 331 /* Export interface */
 332 #define EV_TYPE_PRINT_OPERATION_EXPORT         (ev_print_operation_export_get_type())
 333 #define EV_PRINT_OPERATION_EXPORT(object)      (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PRINT_OPERATION_EXPORT, EvPrintOperationExport))
 334 #define EV_PRINT_OPERATION_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PRINT_OPERATION_EXPORT, EvPrintOperationExportClass))
 335 #define EV_IS_PRINT_OPERATION_EXPORT(object)   (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PRINT_OPERATION_EXPORT))
 336
 337 typedef struct _EvPrintOperationExport      EvPrintOperationExport;
 338 typedef struct _EvPrintOperationExportClass EvPrintOperationExportClass;
 339
 340 GType           ev_print_operation_export_get_type (void) G_GNUC_CONST;
 341
 342 static void     ev_print_operation_export_begin    (EvPrintOperationExport *export);
 343 static gboolean export_print_page                  (EvPrintOperationExport *export);
 344 static void     export_cancel                      (EvPrintOperationExport *export);
 345
 346 struct _EvPrintOperationExport {
 347         EvPrintOperation parent;
 348
 349         GtkWindow *parent_window;
 350         EvJob *job_export;
 351         GError *error;
 352
 353         gboolean print_preview;
 354         gint n_pages;
 355         gint current_page;
 356         GtkPrinter *printer;
 357         GtkPageSetup *page_setup;
 358         GtkPrintSettings *print_settings;
 359         GtkPageSet page_set;
 360         gint copies;
 361         guint collate     : 1;
 362         guint reverse     : 1;
 363         gint pages_per_sheet;
 364         gint fd;
 365         gchar *temp_file;
 366         gchar *job_name;
 367
 368         guint idle_id;
 369
 370         /* Context */
 371         EvFileExporterContext fc;
 372         gint n_pages_to_print;
 373         gint uncollated_copies;
 374         gint collated_copies;
 375         gint uncollated, collated, total;
 376
 377         gint range, n_ranges;
 378         GtkPageRange *ranges;
 379         GtkPageRange one_range;
 380
 381         gint page, start, end, inc;
 382 };
 383
 384 struct _EvPrintOperationExportClass {
 385         EvPrintOperationClass parent_class;
 386 };
 387
 388 G_DEFINE_TYPE (EvPrintOperationExport, ev_print_operation_export, EV_TYPE_PRINT_OPERATION)
 389
 390 /* Internal print queue */
 391 static GHashTable *print_queue = NULL;
 392
 393 static void
 394 queue_free (GQueue *queue)
 395 {
 396         g_queue_foreach (queue, (GFunc)g_object_unref, NULL);
 397         g_queue_free (queue);
 398 }
 399
 400 static void
 401 ev_print_queue_init (void)
 402 {
 403         if (G_UNLIKELY (print_queue == NULL)) {
 404                 print_queue = g_hash_table_new_full (g_direct_hash,
 405                                                      g_direct_equal,
 406                                                      NULL,
 407                                                      (GDestroyNotify)queue_free);
 408         }
 409 }
 410
 411 static void
 412 remove_document_queue (gpointer data,
 413                        GObject *document)
 414 {
 415         if (print_queue)
 416                 g_hash_table_remove (print_queue, document);
 417 }
 418
 419 static gboolean
 420 ev_print_queue_is_empty (EvDocument *document)
 421 {
 422         GQueue *queue;
 423
 424         queue = g_hash_table_lookup (print_queue, document);
 425         return (!queue || g_queue_is_empty (queue));
 426 }
 427
 428 static void
 429 ev_print_queue_push (EvPrintOperation *op)
 430 {
 431         GQueue *queue;
 432
 433         queue = g_hash_table_lookup (print_queue, op->document);
 434         if (!queue) {
 435                 queue = g_queue_new ();
 436                 g_hash_table_insert (print_queue,
 437                                      op->document,
 438                                      queue);
 439                 g_object_weak_ref (G_OBJECT (op->document),
 440                                    (GWeakNotify)remove_document_queue,
 441                                    NULL);
 442         }
 443
 444         g_queue_push_head (queue, g_object_ref (op));
 445 }
 446
 447 static EvPrintOperation *
 448 ev_print_queue_pop (EvDocument *document)
 449 {
 450         EvPrintOperation *op;
 451         GQueue           *queue;
 452
 453         queue = g_hash_table_lookup (print_queue, document);
 454         if (!queue || g_queue_is_empty (queue))
 455                 return NULL;
 456
 457         op = g_queue_pop_tail (queue);
 458         g_object_unref (op);
 459
 460         return op;
 461 }
 462
 463 static EvPrintOperation *
 464 ev_print_queue_peek (EvDocument *document)
 465 {
 466         GQueue *queue;
 467
 468         queue = g_hash_table_lookup (print_queue, document);
 469         if (!queue || g_queue_is_empty (queue))
 470                 return NULL;
 471
 472         return g_queue_peek_tail (queue);
 473 }
 474
 475 static void
 476 ev_print_operation_export_set_current_page (EvPrintOperation *op,
 477                                             gint              current_page)
 478 {
 479         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 480
 481         g_return_if_fail (current_page < export->n_pages);
 482
 483         export->current_page = current_page;
 484 }
 485
 486 static void
 487 ev_print_operation_export_set_print_settings (EvPrintOperation *op,
 488                                               GtkPrintSettings *print_settings)
 489 {
 490         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 491
 492         if (print_settings == export->print_settings)
 493                 return;
 494
 495         g_object_ref (print_settings);
 496         if (export->print_settings)
 497                 g_object_unref (export->print_settings);
 498         export->print_settings = print_settings;
 499 }
 500
 501 static GtkPrintSettings *
 502 ev_print_operation_export_get_print_settings (EvPrintOperation *op)
 503 {
 504         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 505
 506         return export->print_settings;
 507 }
 508
 509 static void
 510 ev_print_operation_export_set_default_page_setup (EvPrintOperation *op,
 511                                                   GtkPageSetup     *page_setup)
 512 {
 513         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 514
 515         if (page_setup == export->page_setup)
 516                 return;
 517
 518         g_object_ref (page_setup);
 519         if (export->page_setup)
 520                 g_object_unref (export->page_setup);
 521         export->page_setup = page_setup;
 522 }
 523
 524 static GtkPageSetup *
 525 ev_print_operation_export_get_default_page_setup (EvPrintOperation *op)
 526 {
 527         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 528
 529         return export->page_setup;
 530 }
 531
 532 static void
 533 ev_print_operation_export_set_job_name (EvPrintOperation *op,
 534                                         const gchar      *job_name)
 535 {
 536         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 537
 538         g_free (export->job_name);
 539         export->job_name = g_strdup (job_name);
 540 }
 541
 542 static const gchar *
 543 ev_print_operation_export_get_job_name (EvPrintOperation *op)
 544 {
 545         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 546
 547         return export->job_name;
 548 }
 549
 550 static void
 551 ev_print_operation_export_set_printer (EvPrintOperationExport *export,
 552                                        GtkPrinter             *printer)
 553 {
 554         if (printer == export->printer)
 555                 return;
 556
 557         g_object_ref (printer);
 558         if (export->printer)
 559                 g_object_unref (export->printer);
 560         export->printer = printer;
 561 }
 562
 563 static void
 564 find_range (EvPrintOperationExport *export)
 565 {
 566         GtkPageRange *range;
 567
 568         range = &export->ranges[export->range];
 569
 570         if (export->inc < 0) {
 571                 export->start = range->end;
 572                 export->end = range->start - 1;
 573         } else {
 574                 export->start = range->start;
 575                 export->end = range->end + 1;
 576         }
 577 }
 578
 579 static void
 580 clamp_ranges (EvPrintOperationExport *export)
 581 {
 582         gint num_of_correct_ranges = 0;
 583         gint n_pages_to_print = 0;
 584         gint i;
 585
 586         for (i = 0; i < export->n_ranges; i++) {
 587                 gint n_pages;
 588
 589                 if ((export->ranges[i].start >= 0) &&
 590                     (export->ranges[i].start < export->n_pages) &&
 591                     (export->ranges[i].end >= 0) &&
 592                     (export->ranges[i].end < export->n_pages)) {
 593                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 594                         num_of_correct_ranges++;
 595                 } else if ((export->ranges[i].start >= 0) &&
 596                            (export->ranges[i].start < export->n_pages) &&
 597                            (export->ranges[i].end >= export->n_pages)) {
 598                         export->ranges[i].end = export->n_pages - 1;
 599                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 600                         num_of_correct_ranges++;
 601                 } else if ((export->ranges[i].end >= 0) &&
 602                            (export->ranges[i].end < export->n_pages) &&
 603                            (export->ranges[i].start < 0)) {
 604                         export->ranges[i].start = 0;
 605                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 606                         num_of_correct_ranges++;
 607                 }
 608
 609                 n_pages = export->ranges[i].end - export->ranges[i].start + 1;
 610                 if (export->page_set == GTK_PAGE_SET_ALL) {
 611                         n_pages_to_print += n_pages;
 612                 } else if (n_pages % 2 == 0) {
 613                         n_pages_to_print += n_pages / 2;
 614                 } else if (export->page_set == GTK_PAGE_SET_EVEN) {
 615                         n_pages_to_print += export->ranges[i].start % 2 == 0 ?
 616                                 n_pages / 2 : (n_pages / 2) + 1;
 617                 } else if (export->page_set == GTK_PAGE_SET_ODD) {
 618                         n_pages_to_print += export->ranges[i].start % 2 == 0 ?
 619                                 (n_pages / 2) + 1 : n_pages / 2;
 620                 }
 621         }
 622
 623         export->n_ranges = num_of_correct_ranges;
 624         export->n_pages_to_print = n_pages_to_print;
 625 }
 626
 627 static void
 628 get_first_and_last_page (EvPrintOperationExport *export,
 629                          gint                   *first,
 630                          gint                   *last)
 631 {
 632         gint i;
 633         gint first_page = G_MAXINT;
 634         gint last_page = G_MININT;
 635         gint max_page = export->n_pages - 1;
 636
 637         if (export->n_ranges == 0) {
 638                 *first = 0;
 639                 *last = max_page;
 640
 641                 return;
 642         }
 643
 644         for (i = 0; i < export->n_ranges; i++) {
 645                 if (export->ranges[i].start < first_page)
 646                         first_page = export->ranges[i].start;
 647                 if (export->ranges[i].end > last_page)
 648                         last_page = export->ranges[i].end;
 649         }
 650
 651         *first = MAX (0, first_page);
 652         *last = MIN (max_page, last_page);
 653 }
 654
 655 static gboolean
 656 export_print_inc_page (EvPrintOperationExport *export)
 657 {
 658         do {
 659                 export->page += export->inc;
 660                 if (export->page == export->end) {
 661                         export->range += export->inc;
 662                         if (export->range == -1 || export->range == export->n_ranges) {
 663                                 export->uncollated++;
 664                                 if (export->uncollated == export->uncollated_copies)
 665                                         return FALSE;
 666
 667                                 export->range = export->inc < 0 ? export->n_ranges - 1 : 0;
 668                         }
 669                         find_range (export);
 670                         export->page = export->start;
 671                 }
 672         } while ((export->page_set == GTK_PAGE_SET_EVEN && export->page % 2 == 0) ||
 673                  (export->page_set == GTK_PAGE_SET_ODD && export->page % 2 == 1));
 674
 675         return TRUE;
 676 }
 677
 678 static void
 679 ev_print_operation_export_clear_temp_file (EvPrintOperationExport *export)
 680 {
 681         if (!export->temp_file)
 682                 return;
 683
 684         g_unlink (export->temp_file);
 685         g_free (export->temp_file);
 686         export->temp_file = NULL;
 687 }
 688
 689 static void
 690 ev_print_operation_export_run_next (EvPrintOperationExport *export)
 691 {
 692         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 693         EvPrintOperation *next;
 694         EvDocument       *document;
 695
 696         /* First pop the current job */
 697         document = op->document;
 698         ev_print_queue_pop (document);
 699
 700         next = ev_print_queue_peek (document);
 701         if (next)
 702                 ev_print_operation_export_begin (EV_PRINT_OPERATION_EXPORT (next));
 703 }
 704
 705 static void
 706 print_job_finished (GtkPrintJob            *print_job,
 707                     EvPrintOperationExport *export,
 708                     GError                 *error)
 709 {
 710         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 711
 712         if (error) {
 713                 g_set_error_literal (&export->error,
 714                                      GTK_PRINT_ERROR,
 715                                      GTK_PRINT_ERROR_GENERAL,
 716                                      error->message);
 717                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
 718         } else {
 719                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
 720         }
 721
 722         ev_print_operation_export_clear_temp_file (export);
 723         g_object_unref (print_job);
 724
 725         ev_print_operation_export_run_next (export);
 726 }
 727
 728 static void
 729 export_print_done (EvPrintOperationExport *export)
 730 {
 731         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 732         GtkPrintSettings *settings;
 733         EvFileExporterCapabilities capabilities;
 734
 735         g_assert (export->temp_file != NULL);
 736
 737         /* Some printers take into account some print settings,
 738          * and others don't. However we have exported the document
 739          * to a ps or pdf file according to such print settings. So,
 740          * we want to send the exported file to printer with those
 741          * settings set to default values.
 742          */
 743         settings = gtk_print_settings_copy (export->print_settings);
 744         capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
 745
 746         gtk_print_settings_set_page_ranges (settings, NULL, 0);
 747         gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
 748         if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
 749                 gtk_print_settings_set_n_copies (settings, 1);
 750         if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
 751                 gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
 752         if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
 753                 gtk_print_settings_set_scale (settings, 1.0);
 754         if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
 755                 gtk_print_settings_set_collate (settings, FALSE);
 756         if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
 757                 gtk_print_settings_set_reverse (settings, FALSE);
 758         if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
 759                 gtk_print_settings_set_number_up (settings, 1);
 760                 gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
 761         }
 762
 763         if (export->print_preview) {
 764                 gchar *uri;
 765                 gchar *print_settings_file = NULL;
 766
 767                 print_settings_file = ev_tmp_filename ("print-settings");
 768                 gtk_print_settings_to_file (settings, print_settings_file, NULL);
 769
 770                 uri = g_filename_to_uri (export->temp_file, NULL, NULL);
 771                 ev_application_open_uri_at_dest (EV_APP,
 772                                                  uri,
 773                                                  gtk_window_get_screen (export->parent_window),
 774                                                  NULL,
 775                                                  EV_WINDOW_MODE_PREVIEW,
 776                                                  NULL,
 777                                                  TRUE,
 778                                                  print_settings_file,
 779                                                  GDK_CURRENT_TIME);
 780                 g_free (print_settings_file);
 781                 g_free (uri);
 782
 783                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
 784                 /* temp_file will be deleted by the previewer */
 785
 786                 ev_print_operation_export_run_next (export);
 787         } else {
 788                 GtkPrintJob *job;
 789                 GError      *error = NULL;
 790
 791                 job = gtk_print_job_new (export->job_name,
 792                                          export->printer,
 793                                          settings,
 794                                          export->page_setup);
 795                 gtk_print_job_set_source_file (job, export->temp_file, &error);
 796                 if (error) {
 797                         g_set_error_literal (&export->error,
 798                                              GTK_PRINT_ERROR,
 799                                              GTK_PRINT_ERROR_GENERAL,
 800                                              error->message);
 801                         g_error_free (error);
 802                         ev_print_operation_export_clear_temp_file (export);
 803                         g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
 804
 805                         ev_print_operation_export_run_next (export);
 806                 } else {
 807                         gtk_print_job_send (job,
 808                                             (GtkPrintJobCompleteFunc)print_job_finished,
 809                                             g_object_ref (export),
 810                                             (GDestroyNotify)g_object_unref);
 811                 }
 812         }
 813         g_object_unref (settings);
 814 }
 815
 816 static void
 817 export_print_page_idle_finished (EvPrintOperationExport *export)
 818 {
 819         export->idle_id = 0;
 820 }
 821
 822 static void
 823 export_job_finished (EvJobExport            *job,
 824                      EvPrintOperationExport *export)
 825 {
 826         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 827
 828         if (export->pages_per_sheet == 1 || export->total % export->pages_per_sheet == 0) {
 829                 ev_document_doc_mutex_lock ();
 830                 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
 831                 ev_document_doc_mutex_unlock ();
 832         }
 833
 834         /* Reschedule */
 835         export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 836                                            (GSourceFunc)export_print_page,
 837                                            export,
 838                                            (GDestroyNotify)export_print_page_idle_finished);
 839 }
 840
 841 static void
 842 export_job_cancelled (EvJobExport            *job,
 843                       EvPrintOperationExport *export)
 844 {
 845         export_cancel (export);
 846 }
 847
 848 static void
 849 export_cancel (EvPrintOperationExport *export)
 850 {
 851         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 852
 853         if (export->idle_id > 0)
 854                 g_source_remove (export->idle_id);
 855         export->idle_id = 0;
 856
 857         if (export->job_export) {
 858                 g_signal_handlers_disconnect_by_func (export->job_export,
 859                                                       export_job_finished,
 860                                                       export);
 861                 g_signal_handlers_disconnect_by_func (export->job_export,
 862                                                       export_job_cancelled,
 863                                                       export);
 864                 g_object_unref (export->job_export);
 865                 export->job_export = NULL;
 866         }
 867
 868         if (export->fd != -1) {
 869                 close (export->fd);
 870                 export->fd = -1;
 871         }
 872
 873         ev_print_operation_export_clear_temp_file (export);
 874
 875         g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
 876
 877         ev_print_operation_export_run_next (export);
 878 }
 879
 880 static void
 881 update_progress (EvPrintOperationExport *export)
 882 {
 883         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 884
 885         ev_print_operation_update_status (op, export->total,
 886                                           export->n_pages_to_print,
 887                                           export->total / (gdouble)export->n_pages_to_print);
 888 }
 889
 890 static gboolean
 891 export_print_page (EvPrintOperationExport *export)
 892 {
 893         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 894
 895         if (!export->temp_file)
 896                 return FALSE; /* cancelled */
 897
 898         export->total++;
 899         export->collated++;
 900
 901         if (export->collated == export->collated_copies) {
 902                 export->collated = 0;
 903                 if (!export_print_inc_page (export)) {
 904                         ev_document_doc_mutex_lock ();
 905                         if (export->pages_per_sheet > 1 &&
 906                             export->total - 1 % export->pages_per_sheet == 0)
 907                                 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
 908                         ev_file_exporter_end (EV_FILE_EXPORTER (op->document));
 909                         ev_document_doc_mutex_unlock ();
 910
 911                         close (export->fd);
 912                         export->fd = -1;
 913
 914                         update_progress (export);
 915
 916                         export_print_done (export);
 917
 918                         return FALSE;
 919                 }
 920         }
 921
 922         if (export->pages_per_sheet == 1 || export->total % export->pages_per_sheet == 1) {
 923                 ev_document_doc_mutex_lock ();
 924                 ev_file_exporter_begin_page (EV_FILE_EXPORTER (op->document));
 925                 ev_document_doc_mutex_unlock ();
 926         }
 927
 928         if (!export->job_export) {
 929                 export->job_export = ev_job_export_new (op->document);
 930                 g_signal_connect (G_OBJECT (export->job_export), "finished",
 931                                   G_CALLBACK (export_job_finished),
 932                                   (gpointer)export);
 933                 g_signal_connect (G_OBJECT (export->job_export), "cancelled",
 934                                   G_CALLBACK (export_job_cancelled),
 935                                   (gpointer)export);
 936         }
 937
 938         ev_job_export_set_page (EV_JOB_EXPORT (export->job_export), export->page);
 939         ev_job_scheduler_push_job (export->job_export, EV_JOB_PRIORITY_NONE);
 940
 941         update_progress (export);
 942
 943         return FALSE;
 944 }
 945
 946 static void
 947 ev_print_operation_export_begin (EvPrintOperationExport *export)
 948 {
 949         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 950
 951         if (!export->temp_file)
 952                 return; /* cancelled */
 953
 954         ev_document_doc_mutex_lock ();
 955         ev_file_exporter_begin (EV_FILE_EXPORTER (op->document), &export->fc);
 956         ev_document_doc_mutex_unlock ();
 957
 958         export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 959                                            (GSourceFunc)export_print_page,
 960                                            export,
 961                                            (GDestroyNotify)export_print_page_idle_finished);
 962 }
 963
 964 static void
 965 ev_print_operation_export_print_dialog_response_cb (GtkDialog              *dialog,
 966                                                     gint                    response,
 967                                                     EvPrintOperationExport *export)
 968 {
 969         GtkPrintPages     print_pages;
 970         GtkPrintSettings *print_settings;
 971         GtkPageSetup     *page_setup;
 972         GtkPrinter       *printer;
 973         gdouble           scale;
 974         gdouble           width;
 975         gdouble           height;
 976         gint              first_page;
 977         gint              last_page;
 978         const gchar      *file_format;
 979         gchar            *filename;
 980         GError           *error = NULL;
 981         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 982
 983         if (response != GTK_RESPONSE_OK &&
 984             response != GTK_RESPONSE_APPLY) {
 985                 gtk_widget_destroy (GTK_WIDGET (dialog));
 986                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
 987
 988                 return;
 989         }
 990
 991         ev_print_operation_update_status (op, -1, -1, 0.0);
 992
 993         export->print_preview = (response == GTK_RESPONSE_APPLY);
 994
 995         printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog));
 996         ev_print_operation_export_set_printer (export, printer);
 997
 998         print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog));
 999         ev_print_operation_export_set_print_settings (op, print_settings);
1000
1001         page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog));
1002         ev_print_operation_export_set_default_page_setup (op, page_setup);
1003
1004         if (!gtk_printer_accepts_ps (export->printer)) {
1005                 gtk_widget_destroy (GTK_WIDGET (dialog));
1006
1007                 g_set_error (&export->error,
1008                              GTK_PRINT_ERROR,
1009                              GTK_PRINT_ERROR_GENERAL,
1010                              "%s", _("Printing is not supported on this printer."));
1011                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1012
1013                 return;
1014         }
1015
1016         file_format = gtk_print_settings_get (print_settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
1017
1018         filename = g_strdup_printf ("evince_print.%s.XXXXXX", file_format);
1019         export->fd = g_file_open_tmp (filename, &export->temp_file, &error);
1020         g_free (filename);
1021         if (export->fd <= -1) {
1022                 gtk_widget_destroy (GTK_WIDGET (dialog));
1023
1024                 g_set_error_literal (&export->error,
1025                                      GTK_PRINT_ERROR,
1026                                      GTK_PRINT_ERROR_GENERAL,
1027                                      error->message);
1028                 g_error_free (error);
1029                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1030
1031                 return;
1032         }
1033
1034         export->current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
1035         export->page_set = gtk_print_settings_get_page_set (print_settings);
1036         print_pages = gtk_print_settings_get_print_pages (print_settings);
1037
1038         switch (print_pages) {
1039         case GTK_PRINT_PAGES_CURRENT:
1040                 export->ranges = &export->one_range;
1041
1042                 export->ranges[0].start = export->current_page;
1043                 export->ranges[0].end = export->current_page;
1044                 export->n_ranges = 1;
1045
1046                 break;
1047         case GTK_PRINT_PAGES_RANGES: {
1048                 gint i;
1049
1050                 export->ranges = gtk_print_settings_get_page_ranges (print_settings, &export->n_ranges);
1051                 for (i = 0; i < export->n_ranges; i++)
1052                         if (export->ranges[i].end == -1 || export->ranges[i].end >= export->n_pages)
1053                                 export->ranges[i].end = export->n_pages - 1;
1054         }
1055                 break;
1056         case GTK_PRINT_PAGES_ALL:
1057                 export->ranges = &export->one_range;
1058
1059                 export->ranges[0].start = 0;
1060                 export->ranges[0].end = export->n_pages - 1;
1061                 export->n_ranges = 1;
1062
1063                 break;
1064         }
1065         clamp_ranges (export);
1066
1067         width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
1068         height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
1069         scale = gtk_print_settings_get_scale (print_settings) * 0.01;
1070         if (scale != 1.0) {
1071                 width *= scale;
1072                 height *= scale;
1073         }
1074
1075         export->pages_per_sheet = gtk_print_settings_get_number_up (print_settings);
1076
1077         export->copies = gtk_print_settings_get_n_copies (print_settings);
1078         export->collate = gtk_print_settings_get_collate (print_settings);
1079         export->reverse = gtk_print_settings_get_reverse (print_settings);
1080
1081         if (export->collate) {
1082                 export->uncollated_copies = export->copies;
1083                 export->collated_copies = 1;
1084         } else {
1085                 export->uncollated_copies = 1;
1086                 export->collated_copies = export->copies;
1087         }
1088
1089         if (export->reverse) {
1090                 export->range = export->n_ranges - 1;
1091                 export->inc = -1;
1092         } else {
1093                 export->range = 0;
1094                 export->inc = 1;
1095         }
1096         find_range (export);
1097
1098         export->page = export->start - export->inc;
1099         export->collated = export->collated_copies - 1;
1100
1101         get_first_and_last_page (export, &first_page, &last_page);
1102
1103         export->fc.format = file_format && g_ascii_strcasecmp (file_format, "pdf") == 0 ?
1104                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1105         export->fc.filename = export->temp_file;
1106         export->fc.first_page = MIN (first_page, last_page);
1107         export->fc.last_page = MAX (first_page, last_page);
1108         export->fc.paper_width = width;
1109         export->fc.paper_height = height;
1110         export->fc.duplex = FALSE;
1111         export->fc.pages_per_sheet = MAX (1, export->pages_per_sheet);
1112
1113         if (ev_print_queue_is_empty (op->document))
1114                 ev_print_operation_export_begin (export);
1115
1116         ev_print_queue_push (op);
1117
1118         g_signal_emit (op, signals[BEGIN_PRINT], 0);
1119
1120         gtk_widget_destroy (GTK_WIDGET (dialog));
1121 }
1122
1123 static void
1124 ev_print_operation_export_run (EvPrintOperation *op,
1125                                GtkWindow        *parent)
1126 {
1127         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1128         GtkWidget              *dialog;
1129         GtkPrintCapabilities    capabilities;
1130
1131         ev_print_queue_init ();
1132
1133         export->parent_window = parent;
1134         export->error = NULL;
1135
1136         dialog = gtk_print_unix_dialog_new (_("Print"), parent);
1137         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1138
1139         capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
1140                 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
1141         gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
1142                                                        capabilities);
1143
1144         gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
1145                                                 export->current_page);
1146
1147         gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
1148                                             export->print_settings);
1149
1150         if (export->page_setup)
1151                 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1152                                                       export->page_setup);
1153
1154         g_signal_connect (G_OBJECT (dialog), "response",
1155                           G_CALLBACK (ev_print_operation_export_print_dialog_response_cb),
1156                           export);
1157
1158         gtk_window_present (GTK_WINDOW (dialog));
1159 }
1160
1161 static void
1162 ev_print_operation_export_cancel (EvPrintOperation *op)
1163 {
1164         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1165
1166         if (export->job_export &&
1167             !ev_job_is_finished (export->job_export)) {
1168                 ev_job_cancel (export->job_export);
1169         } else {
1170                 export_cancel (export);
1171         }
1172 }
1173
1174 static void
1175 ev_print_operation_export_get_error (EvPrintOperation *op,
1176                                      GError          **error)
1177 {
1178         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1179
1180         g_propagate_error (error, export->error);
1181         export->error = NULL;
1182 }
1183
1184 static void
1185 ev_print_operation_export_finalize (GObject *object)
1186 {
1187         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (object);
1188
1189         if (export->idle_id > 0) {
1190                 g_source_remove (export->idle_id);
1191                 export->idle_id = 0;
1192         }
1193
1194         if (export->fd != -1) {
1195                 close (export->fd);
1196                 export->fd = -1;
1197         }
1198
1199         if (export->ranges) {
1200                 if (export->ranges != &export->one_range)
1201                         g_free (export->ranges);
1202                 export->ranges = NULL;
1203                 export->n_ranges = 0;
1204         }
1205
1206         if (export->temp_file) {
1207                 g_free (export->temp_file);
1208                 export->temp_file = NULL;
1209         }
1210
1211         if (export->job_name) {
1212                 g_free (export->job_name);
1213                 export->job_name = NULL;
1214         }
1215
1216         if (export->job_export) {
1217                 if (!ev_job_is_finished (export->job_export))
1218                         ev_job_cancel (export->job_export);
1219                 g_signal_handlers_disconnect_by_func (export->job_export,
1220                                                       export_job_finished,
1221                                                       export);
1222                 g_signal_handlers_disconnect_by_func (export->job_export,
1223                                                       export_job_cancelled,
1224                                                       export);
1225                 g_object_unref (export->job_export);
1226                 export->job_export = NULL;
1227         }
1228
1229         if (export->error) {
1230                 g_error_free (export->error);
1231                 export->error = NULL;
1232         }
1233
1234         if (export->print_settings) {
1235                 g_object_unref (export->print_settings);
1236                 export->print_settings = NULL;
1237         }
1238
1239         if (export->page_setup) {
1240                 g_object_unref (export->page_setup);
1241                 export->page_setup = NULL;
1242         }
1243
1244         if (export->printer) {
1245                 g_object_unref (export->printer);
1246                 export->printer = NULL;
1247         }
1248
1249         (* G_OBJECT_CLASS (ev_print_operation_export_parent_class)->finalize) (object);
1250 }
1251
1252 static void
1253 ev_print_operation_export_init (EvPrintOperationExport *export)
1254 {
1255 }
1256
1257 static GObject *
1258 ev_print_operation_export_constructor (GType                  type,
1259                                        guint                  n_construct_properties,
1260                                        GObjectConstructParam *construct_params)
1261 {
1262         GObject                *object;
1263         EvPrintOperationExport *export;
1264         EvPrintOperation       *op;
1265
1266         object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,
1267                                                                                        n_construct_properties,
1268                                                                                        construct_params);
1269         export = EV_PRINT_OPERATION_EXPORT (object);
1270         op = EV_PRINT_OPERATION (object);
1271         export->n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1272
1273         return object;
1274 }
1275
1276 static void
1277 ev_print_operation_export_class_init (EvPrintOperationExportClass *klass)
1278 {
1279         GObjectClass          *g_object_class = G_OBJECT_CLASS (klass);
1280         EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1281
1282         ev_print_op_class->set_current_page = ev_print_operation_export_set_current_page;
1283         ev_print_op_class->set_print_settings = ev_print_operation_export_set_print_settings;
1284         ev_print_op_class->get_print_settings = ev_print_operation_export_get_print_settings;
1285         ev_print_op_class->set_default_page_setup = ev_print_operation_export_set_default_page_setup;
1286         ev_print_op_class->get_default_page_setup = ev_print_operation_export_get_default_page_setup;
1287         ev_print_op_class->set_job_name = ev_print_operation_export_set_job_name;
1288         ev_print_op_class->get_job_name = ev_print_operation_export_get_job_name;
1289         ev_print_op_class->run = ev_print_operation_export_run;
1290         ev_print_op_class->cancel = ev_print_operation_export_cancel;
1291         ev_print_op_class->get_error = ev_print_operation_export_get_error;
1292
1293         g_object_class->constructor = ev_print_operation_export_constructor;
1294         g_object_class->finalize = ev_print_operation_export_finalize;
1295 }
1296
1297 /* Factory method */
1298 EvPrintOperation *
1299 ev_print_operation_new (EvDocument *document)
1300 {
1301         /* TODO: EvPrintOperationPrint */
1302
1303         return EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_EXPORT,
1304                                                  "document", document, NULL));
1305 }