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
 345 struct _EvPrintOperationExport {
 346         EvPrintOperation parent;
 347
 348         GtkWindow *parent_window;
 349         EvJob *job_export;
 350         GError *error;
 351
 352         gboolean print_preview;
 353         gint n_pages;
 354         gint current_page;
 355         GtkPrinter *printer;
 356         GtkPageSetup *page_setup;
 357         GtkPrintSettings *print_settings;
 358         GtkPageSet page_set;
 359         gint copies;
 360         guint collate     : 1;
 361         guint reverse     : 1;
 362         gint pages_per_sheet;
 363         gint fd;
 364         gchar *temp_file;
 365         gchar *job_name;
 366
 367         guint idle_id;
 368
 369         /* Context */
 370         EvFileExporterContext fc;
 371         gint n_pages_to_print;
 372         gint uncollated_copies;
 373         gint collated_copies;
 374         gint uncollated, collated, total;
 375
 376         gint range, n_ranges;
 377         GtkPageRange *ranges;
 378         GtkPageRange one_range;
 379
 380         gint page, start, end, inc;
 381 };
 382
 383 struct _EvPrintOperationExportClass {
 384         EvPrintOperationClass parent_class;
 385 };
 386
 387 G_DEFINE_TYPE (EvPrintOperationExport, ev_print_operation_export, EV_TYPE_PRINT_OPERATION)
 388
 389 /* Internal print queue */
 390 static GHashTable *print_queue = NULL;
 391
 392 static void
 393 queue_free (GQueue *queue)
 394 {
 395         g_queue_foreach (queue, (GFunc)g_object_unref, NULL);
 396         g_queue_free (queue);
 397 }
 398
 399 static void
 400 ev_print_queue_init (void)
 401 {
 402         if (G_UNLIKELY (print_queue == NULL)) {
 403                 print_queue = g_hash_table_new_full (g_direct_hash,
 404                                                      g_direct_equal,
 405                                                      NULL,
 406                                                      (GDestroyNotify)queue_free);
 407         }
 408 }
 409
 410 static void
 411 remove_document_queue (gpointer data,
 412                        GObject *document)
 413 {
 414         if (print_queue)
 415                 g_hash_table_remove (print_queue, document);
 416 }
 417
 418 static gboolean
 419 ev_print_queue_is_empty (EvDocument *document)
 420 {
 421         GQueue *queue;
 422
 423         queue = g_hash_table_lookup (print_queue, document);
 424         return (!queue || g_queue_is_empty (queue));
 425 }
 426
 427 static void
 428 ev_print_queue_push (EvPrintOperation *op)
 429 {
 430         GQueue *queue;
 431
 432         queue = g_hash_table_lookup (print_queue, op->document);
 433         if (!queue) {
 434                 queue = g_queue_new ();
 435                 g_hash_table_insert (print_queue,
 436                                      op->document,
 437                                      queue);
 438                 g_object_weak_ref (G_OBJECT (op->document),
 439                                    (GWeakNotify)remove_document_queue,
 440                                    NULL);
 441         }
 442
 443         g_queue_push_head (queue, g_object_ref (op));
 444 }
 445
 446 static EvPrintOperation *
 447 ev_print_queue_pop (EvDocument *document)
 448 {
 449         EvPrintOperation *op;
 450         GQueue           *queue;
 451
 452         queue = g_hash_table_lookup (print_queue, document);
 453         if (!queue || g_queue_is_empty (queue))
 454                 return NULL;
 455
 456         op = g_queue_pop_tail (queue);
 457         g_object_unref (op);
 458
 459         return op;
 460 }
 461
 462 static EvPrintOperation *
 463 ev_print_queue_peek (EvDocument *document)
 464 {
 465         GQueue *queue;
 466
 467         queue = g_hash_table_lookup (print_queue, document);
 468         if (!queue || g_queue_is_empty (queue))
 469                 return NULL;
 470
 471         return g_queue_peek_tail (queue);
 472 }
 473
 474 static void
 475 ev_print_operation_export_set_current_page (EvPrintOperation *op,
 476                                             gint              current_page)
 477 {
 478         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 479
 480         g_return_if_fail (current_page < export->n_pages);
 481
 482         export->current_page = current_page;
 483 }
 484
 485 static void
 486 ev_print_operation_export_set_print_settings (EvPrintOperation *op,
 487                                               GtkPrintSettings *print_settings)
 488 {
 489         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 490
 491         if (print_settings == export->print_settings)
 492                 return;
 493
 494         g_object_ref (print_settings);
 495         if (export->print_settings)
 496                 g_object_unref (export->print_settings);
 497         export->print_settings = print_settings;
 498 }
 499
 500 static GtkPrintSettings *
 501 ev_print_operation_export_get_print_settings (EvPrintOperation *op)
 502 {
 503         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 504
 505         return export->print_settings;
 506 }
 507
 508 static void
 509 ev_print_operation_export_set_default_page_setup (EvPrintOperation *op,
 510                                                   GtkPageSetup     *page_setup)
 511 {
 512         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 513
 514         if (page_setup == export->page_setup)
 515                 return;
 516
 517         g_object_ref (page_setup);
 518         if (export->page_setup)
 519                 g_object_unref (export->page_setup);
 520         export->page_setup = page_setup;
 521 }
 522
 523 static GtkPageSetup *
 524 ev_print_operation_export_get_default_page_setup (EvPrintOperation *op)
 525 {
 526         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 527
 528         return export->page_setup;
 529 }
 530
 531 static void
 532 ev_print_operation_export_set_job_name (EvPrintOperation *op,
 533                                         const gchar      *job_name)
 534 {
 535         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 536
 537         g_free (export->job_name);
 538         export->job_name = g_strdup (job_name);
 539 }
 540
 541 static const gchar *
 542 ev_print_operation_export_get_job_name (EvPrintOperation *op)
 543 {
 544         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
 545
 546         return export->job_name;
 547 }
 548
 549 static void
 550 ev_print_operation_export_set_printer (EvPrintOperationExport *export,
 551                                        GtkPrinter             *printer)
 552 {
 553         if (printer == export->printer)
 554                 return;
 555
 556         g_object_ref (printer);
 557         if (export->printer)
 558                 g_object_unref (export->printer);
 559         export->printer = printer;
 560 }
 561
 562 static void
 563 find_range (EvPrintOperationExport *export)
 564 {
 565         GtkPageRange *range;
 566
 567         range = &export->ranges[export->range];
 568
 569         if (export->inc < 0) {
 570                 export->start = range->end;
 571                 export->end = range->start - 1;
 572         } else {
 573                 export->start = range->start;
 574                 export->end = range->end + 1;
 575         }
 576 }
 577
 578 static void
 579 clamp_ranges (EvPrintOperationExport *export)
 580 {
 581         gint num_of_correct_ranges = 0;
 582         gint n_pages_to_print = 0;
 583         gint i;
 584
 585         for (i = 0; i < export->n_ranges; i++) {
 586                 gint n_pages;
 587
 588                 if ((export->ranges[i].start >= 0) &&
 589                     (export->ranges[i].start < export->n_pages) &&
 590                     (export->ranges[i].end >= 0) &&
 591                     (export->ranges[i].end < export->n_pages)) {
 592                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 593                         num_of_correct_ranges++;
 594                 } else if ((export->ranges[i].start >= 0) &&
 595                            (export->ranges[i].start < export->n_pages) &&
 596                            (export->ranges[i].end >= export->n_pages)) {
 597                         export->ranges[i].end = export->n_pages - 1;
 598                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 599                         num_of_correct_ranges++;
 600                 } else if ((export->ranges[i].end >= 0) &&
 601                            (export->ranges[i].end < export->n_pages) &&
 602                            (export->ranges[i].start < 0)) {
 603                         export->ranges[i].start = 0;
 604                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 605                         num_of_correct_ranges++;
 606                 }
 607
 608                 n_pages = export->ranges[i].end - export->ranges[i].start + 1;
 609                 if (export->page_set == GTK_PAGE_SET_ALL) {
 610                         n_pages_to_print += n_pages;
 611                 } else if (n_pages % 2 == 0) {
 612                         n_pages_to_print += n_pages / 2;
 613                 } else if (export->page_set == GTK_PAGE_SET_EVEN) {
 614                         n_pages_to_print += export->ranges[i].start % 2 == 0 ?
 615                                 n_pages / 2 : (n_pages / 2) + 1;
 616                 } else if (export->page_set == GTK_PAGE_SET_ODD) {
 617                         n_pages_to_print += export->ranges[i].start % 2 == 0 ?
 618                                 (n_pages / 2) + 1 : n_pages / 2;
 619                 }
 620         }
 621
 622         export->n_ranges = num_of_correct_ranges;
 623         export->n_pages_to_print = n_pages_to_print;
 624 }
 625
 626 static void
 627 get_first_and_last_page (EvPrintOperationExport *export,
 628                          gint                   *first,
 629                          gint                   *last)
 630 {
 631         gint i;
 632         gint first_page = G_MAXINT;
 633         gint last_page = G_MININT;
 634         gint max_page = export->n_pages - 1;
 635
 636         if (export->n_ranges == 0) {
 637                 *first = 0;
 638                 *last = max_page;
 639
 640                 return;
 641         }
 642
 643         for (i = 0; i < export->n_ranges; i++) {
 644                 if (export->ranges[i].start < first_page)
 645                         first_page = export->ranges[i].start;
 646                 if (export->ranges[i].end > last_page)
 647                         last_page = export->ranges[i].end;
 648         }
 649
 650         *first = MAX (0, first_page);
 651         *last = MIN (max_page, last_page);
 652 }
 653
 654 static gboolean
 655 export_print_inc_page (EvPrintOperationExport *export)
 656 {
 657         do {
 658                 export->page += export->inc;
 659                 if (export->page == export->end) {
 660                         export->range += export->inc;
 661                         if (export->range == -1 || export->range == export->n_ranges) {
 662                                 export->uncollated++;
 663                                 if (export->uncollated == export->uncollated_copies)
 664                                         return FALSE;
 665
 666                                 export->range = export->inc < 0 ? export->n_ranges - 1 : 0;
 667                         }
 668                         find_range (export);
 669                         export->page = export->start;
 670                 }
 671         } while ((export->page_set == GTK_PAGE_SET_EVEN && export->page % 2 == 0) ||
 672                  (export->page_set == GTK_PAGE_SET_ODD && export->page % 2 == 1));
 673
 674         return TRUE;
 675 }
 676
 677 static void
 678 ev_print_operation_export_clear_temp_file (EvPrintOperationExport *export)
 679 {
 680         if (!export->temp_file)
 681                 return;
 682
 683         g_unlink (export->temp_file);
 684         g_free (export->temp_file);
 685         export->temp_file = NULL;
 686 }
 687
 688 static void
 689 ev_print_operation_export_run_next (EvPrintOperationExport *export)
 690 {
 691         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 692         EvPrintOperation *next;
 693         EvDocument       *document;
 694
 695         /* First pop the current job */
 696         document = op->document;
 697         ev_print_queue_pop (document);
 698
 699         next = ev_print_queue_peek (document);
 700         if (next)
 701                 ev_print_operation_export_begin (EV_PRINT_OPERATION_EXPORT (next));
 702 }
 703
 704 static void
 705 print_job_finished (GtkPrintJob            *print_job,
 706                     EvPrintOperationExport *export,
 707                     GError                 *error)
 708 {
 709         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 710
 711         if (error) {
 712                 g_set_error_literal (&export->error,
 713                                      GTK_PRINT_ERROR,
 714                                      GTK_PRINT_ERROR_GENERAL,
 715                                      error->message);
 716                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
 717         } else {
 718                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
 719         }
 720
 721         ev_print_operation_export_clear_temp_file (export);
 722         g_object_unref (print_job);
 723
 724         ev_print_operation_export_run_next (export);
 725 }
 726
 727 static void
 728 export_print_done (EvPrintOperationExport *export)
 729 {
 730         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 731         GtkPrintSettings *settings;
 732         EvFileExporterCapabilities capabilities;
 733
 734         g_assert (export->temp_file != NULL);
 735
 736         /* Some printers take into account some print settings,
 737          * and others don't. However we have exported the document
 738          * to a ps or pdf file according to such print settings. So,
 739          * we want to send the exported file to printer with those
 740          * settings set to default values.
 741          */
 742         settings = gtk_print_settings_copy (export->print_settings);
 743         capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
 744
 745         gtk_print_settings_set_page_ranges (settings, NULL, 0);
 746         gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
 747         if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
 748                 gtk_print_settings_set_n_copies (settings, 1);
 749         if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
 750                 gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
 751         if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
 752                 gtk_print_settings_set_scale (settings, 1.0);
 753         if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
 754                 gtk_print_settings_set_collate (settings, FALSE);
 755         if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
 756                 gtk_print_settings_set_reverse (settings, FALSE);
 757         if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
 758                 gtk_print_settings_set_number_up (settings, 1);
 759                 gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
 760         }
 761
 762         if (export->print_preview) {
 763                 gchar *uri;
 764                 gchar *print_settings_file = NULL;
 765
 766                 print_settings_file = ev_tmp_filename ("print-settings");
 767                 gtk_print_settings_to_file (settings, print_settings_file, NULL);
 768
 769                 uri = g_filename_to_uri (export->temp_file, NULL, NULL);
 770                 ev_application_open_uri_at_dest (EV_APP,
 771                                                  uri,
 772                                                  gtk_window_get_screen (export->parent_window),
 773                                                  NULL,
 774                                                  EV_WINDOW_MODE_PREVIEW,
 775                                                  NULL,
 776                                                  TRUE,
 777                                                  print_settings_file,
 778                                                  GDK_CURRENT_TIME);
 779                 g_free (print_settings_file);
 780                 g_free (uri);
 781
 782                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
 783                 /* temp_file will be deleted by the previewer */
 784
 785                 ev_print_operation_export_run_next (export);
 786         } else {
 787                 GtkPrintJob *job;
 788                 GError      *error = NULL;
 789
 790                 job = gtk_print_job_new (export->job_name,
 791                                          export->printer,
 792                                          settings,
 793                                          export->page_setup);
 794                 gtk_print_job_set_source_file (job, export->temp_file, &error);
 795                 if (error) {
 796                         g_set_error_literal (&export->error,
 797                                              GTK_PRINT_ERROR,
 798                                              GTK_PRINT_ERROR_GENERAL,
 799                                              error->message);
 800                         g_error_free (error);
 801                         ev_print_operation_export_clear_temp_file (export);
 802                         g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
 803
 804                         ev_print_operation_export_run_next (export);
 805                 } else {
 806                         gtk_print_job_send (job,
 807                                             (GtkPrintJobCompleteFunc)print_job_finished,
 808                                             g_object_ref (export),
 809                                             (GDestroyNotify)g_object_unref);
 810                 }
 811         }
 812         g_object_unref (settings);
 813 }
 814
 815 static void
 816 export_print_page_idle_finished (EvPrintOperationExport *export)
 817 {
 818         export->idle_id = 0;
 819 }
 820
 821 static void
 822 export_job_finished (EvJobExport            *job,
 823                      EvPrintOperationExport *export)
 824 {
 825         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 826
 827         if (export->pages_per_sheet == 1 || export->total % export->pages_per_sheet == 0) {
 828                 ev_document_doc_mutex_lock ();
 829                 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
 830                 ev_document_doc_mutex_unlock ();
 831         }
 832
 833         /* Reschedule */
 834         export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 835                                            (GSourceFunc)export_print_page,
 836                                            export,
 837                                            (GDestroyNotify)export_print_page_idle_finished);
 838 }
 839
 840 static void
 841 export_job_cancelled (EvJobExport            *job,
 842                       EvPrintOperationExport *export)
 843 {
 844         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 845
 846         if (export->idle_id > 0)
 847                 g_source_remove (export->idle_id);
 848         export->idle_id = 0;
 849
 850         g_signal_handlers_disconnect_by_func (export->job_export,
 851                                               export_job_finished,
 852                                               export);
 853         g_signal_handlers_disconnect_by_func (export->job_export,
 854                                               export_job_cancelled,
 855                                               export);
 856         g_object_unref (export->job_export);
 857         export->job_export = NULL;
 858
 859         if (export->fd != -1) {
 860                 close (export->fd);
 861                 export->fd = -1;
 862         }
 863
 864         ev_print_operation_export_clear_temp_file (export);
 865
 866         g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
 867
 868         ev_print_operation_export_run_next (export);
 869 }
 870
 871 static void
 872 update_progress (EvPrintOperationExport *export)
 873 {
 874         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 875
 876         ev_print_operation_update_status (op, export->total,
 877                                           export->n_pages_to_print,
 878                                           export->total / (gdouble)export->n_pages_to_print);
 879 }
 880
 881 static gboolean
 882 export_print_page (EvPrintOperationExport *export)
 883 {
 884         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 885
 886         if (!export->temp_file)
 887                 return FALSE; /* cancelled */
 888
 889         export->total++;
 890         export->collated++;
 891
 892         if (export->collated == export->collated_copies) {
 893                 export->collated = 0;
 894                 if (!export_print_inc_page (export)) {
 895                         ev_document_doc_mutex_lock ();
 896                         if (export->pages_per_sheet > 1 &&
 897                             export->total - 1 % export->pages_per_sheet == 0)
 898                                 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
 899                         ev_file_exporter_end (EV_FILE_EXPORTER (op->document));
 900                         ev_document_doc_mutex_unlock ();
 901
 902                         close (export->fd);
 903                         export->fd = -1;
 904
 905                         update_progress (export);
 906
 907                         export_print_done (export);
 908
 909                         return FALSE;
 910                 }
 911         }
 912
 913         if (export->pages_per_sheet == 1 || export->total % export->pages_per_sheet == 1) {
 914                 ev_document_doc_mutex_lock ();
 915                 ev_file_exporter_begin_page (EV_FILE_EXPORTER (op->document));
 916                 ev_document_doc_mutex_unlock ();
 917         }
 918
 919         if (!export->job_export) {
 920                 export->job_export = ev_job_export_new (op->document);
 921                 g_signal_connect (G_OBJECT (export->job_export), "finished",
 922                                   G_CALLBACK (export_job_finished),
 923                                   (gpointer)export);
 924                 g_signal_connect (G_OBJECT (export->job_export), "cancelled",
 925                                   G_CALLBACK (export_job_cancelled),
 926                                   (gpointer)export);
 927         }
 928
 929         ev_job_export_set_page (EV_JOB_EXPORT (export->job_export), export->page);
 930         ev_job_scheduler_push_job (export->job_export, EV_JOB_PRIORITY_NONE);
 931
 932         update_progress (export);
 933
 934         return FALSE;
 935 }
 936
 937 static void
 938 ev_print_operation_export_begin (EvPrintOperationExport *export)
 939 {
 940         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 941
 942         ev_document_doc_mutex_lock ();
 943         ev_file_exporter_begin (EV_FILE_EXPORTER (op->document), &export->fc);
 944         ev_document_doc_mutex_unlock ();
 945
 946         export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 947                                            (GSourceFunc)export_print_page,
 948                                            export,
 949                                            (GDestroyNotify)export_print_page_idle_finished);
 950 }
 951
 952 static void
 953 ev_print_operation_export_print_dialog_response_cb (GtkDialog              *dialog,
 954                                                     gint                    response,
 955                                                     EvPrintOperationExport *export)
 956 {
 957         GtkPrintPages     print_pages;
 958         GtkPrintSettings *print_settings;
 959         GtkPageSetup     *page_setup;
 960         GtkPrinter       *printer;
 961         gdouble           scale;
 962         gdouble           width;
 963         gdouble           height;
 964         gint              first_page;
 965         gint              last_page;
 966         const gchar      *file_format;
 967         gchar            *filename;
 968         GError           *error = NULL;
 969         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 970
 971         if (response != GTK_RESPONSE_OK &&
 972             response != GTK_RESPONSE_APPLY) {
 973                 gtk_widget_destroy (GTK_WIDGET (dialog));
 974                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
 975
 976                 return;
 977         }
 978
 979         ev_print_operation_update_status (op, -1, -1, 0.0);
 980
 981         export->print_preview = (response == GTK_RESPONSE_APPLY);
 982
 983         printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog));
 984         ev_print_operation_export_set_printer (export, printer);
 985
 986         print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog));
 987         ev_print_operation_export_set_print_settings (op, print_settings);
 988
 989         page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog));
 990         ev_print_operation_export_set_default_page_setup (op, page_setup);
 991
 992         if (!gtk_printer_accepts_ps (export->printer)) {
 993                 gtk_widget_destroy (GTK_WIDGET (dialog));
 994
 995                 g_set_error (&export->error,
 996                              GTK_PRINT_ERROR,
 997                              GTK_PRINT_ERROR_GENERAL,
 998                              "%s", _("Printing is not supported on this printer."));
 999                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1000
1001                 return;
1002         }
1003
1004         file_format = gtk_print_settings_get (print_settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
1005
1006         filename = g_strdup_printf ("evince_print.%s.XXXXXX", file_format);
1007         export->fd = g_file_open_tmp (filename, &export->temp_file, &error);
1008         g_free (filename);
1009         if (export->fd <= -1) {
1010                 gtk_widget_destroy (GTK_WIDGET (dialog));
1011
1012                 g_set_error_literal (&export->error,
1013                                      GTK_PRINT_ERROR,
1014                                      GTK_PRINT_ERROR_GENERAL,
1015                                      error->message);
1016                 g_error_free (error);
1017                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1018
1019                 return;
1020         }
1021
1022         export->current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
1023         export->page_set = gtk_print_settings_get_page_set (print_settings);
1024         print_pages = gtk_print_settings_get_print_pages (print_settings);
1025
1026         switch (print_pages) {
1027         case GTK_PRINT_PAGES_CURRENT:
1028                 export->ranges = &export->one_range;
1029
1030                 export->ranges[0].start = export->current_page;
1031                 export->ranges[0].end = export->current_page;
1032                 export->n_ranges = 1;
1033
1034                 break;
1035         case GTK_PRINT_PAGES_RANGES: {
1036                 gint i;
1037
1038                 export->ranges = gtk_print_settings_get_page_ranges (print_settings, &export->n_ranges);
1039                 for (i = 0; i < export->n_ranges; i++)
1040                         if (export->ranges[i].end == -1 || export->ranges[i].end >= export->n_pages)
1041                                 export->ranges[i].end = export->n_pages - 1;
1042         }
1043                 break;
1044         case GTK_PRINT_PAGES_ALL:
1045                 export->ranges = &export->one_range;
1046
1047                 export->ranges[0].start = 0;
1048                 export->ranges[0].end = export->n_pages - 1;
1049                 export->n_ranges = 1;
1050
1051                 break;
1052         }
1053         clamp_ranges (export);
1054
1055         width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
1056         height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
1057         scale = gtk_print_settings_get_scale (print_settings) * 0.01;
1058         if (scale != 1.0) {
1059                 width *= scale;
1060                 height *= scale;
1061         }
1062
1063         export->pages_per_sheet = gtk_print_settings_get_number_up (print_settings);
1064
1065         export->copies = gtk_print_settings_get_n_copies (print_settings);
1066         export->collate = gtk_print_settings_get_collate (print_settings);
1067         export->reverse = gtk_print_settings_get_reverse (print_settings);
1068
1069         if (export->collate) {
1070                 export->uncollated_copies = export->copies;
1071                 export->collated_copies = 1;
1072         } else {
1073                 export->uncollated_copies = 1;
1074                 export->collated_copies = export->copies;
1075         }
1076
1077         if (export->reverse) {
1078                 export->range = export->n_ranges - 1;
1079                 export->inc = -1;
1080         } else {
1081                 export->range = 0;
1082                 export->inc = 1;
1083         }
1084         find_range (export);
1085
1086         export->page = export->start - export->inc;
1087         export->collated = export->collated_copies - 1;
1088
1089         get_first_and_last_page (export, &first_page, &last_page);
1090
1091         export->fc.format = g_ascii_strcasecmp (file_format, "pdf") == 0 ?
1092                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1093         export->fc.filename = export->temp_file;
1094         export->fc.first_page = MIN (first_page, last_page);
1095         export->fc.last_page = MAX (first_page, last_page);
1096         export->fc.paper_width = width;
1097         export->fc.paper_height = height;
1098         export->fc.duplex = FALSE;
1099         export->fc.pages_per_sheet = MAX (1, export->pages_per_sheet);
1100
1101         if (ev_print_queue_is_empty (op->document))
1102                 ev_print_operation_export_begin (export);
1103
1104         ev_print_queue_push (op);
1105
1106         g_signal_emit (op, signals[BEGIN_PRINT], 0);
1107
1108         gtk_widget_destroy (GTK_WIDGET (dialog));
1109 }
1110
1111 static void
1112 ev_print_operation_export_run (EvPrintOperation *op,
1113                                GtkWindow        *parent)
1114 {
1115         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1116         GtkWidget              *dialog;
1117         GtkPrintCapabilities    capabilities;
1118
1119         ev_print_queue_init ();
1120
1121         export->parent_window = parent;
1122         export->error = NULL;
1123
1124         dialog = gtk_print_unix_dialog_new (_("Print"), parent);
1125         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1126
1127         capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
1128                 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
1129         gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
1130                                                        capabilities);
1131
1132         gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
1133                                                 export->current_page);
1134
1135         gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
1136                                             export->print_settings);
1137
1138         if (export->page_setup)
1139                 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1140                                                       export->page_setup);
1141
1142         g_signal_connect (G_OBJECT (dialog), "response",
1143                           G_CALLBACK (ev_print_operation_export_print_dialog_response_cb),
1144                           export);
1145
1146         gtk_window_present (GTK_WINDOW (dialog));
1147 }
1148
1149 static void
1150 ev_print_operation_export_cancel (EvPrintOperation *op)
1151 {
1152         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1153
1154         if (export->job_export) {
1155                 if (!ev_job_is_finished (export->job_export)) {
1156                         ev_job_cancel (export->job_export);
1157                 } else {
1158                         export_job_cancelled (EV_JOB_EXPORT (export->job_export),
1159                                               export);
1160                 }
1161         }
1162 }
1163
1164 static void
1165 ev_print_operation_export_get_error (EvPrintOperation *op,
1166                                      GError          **error)
1167 {
1168         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1169
1170         g_propagate_error (error, export->error);
1171         export->error = NULL;
1172 }
1173
1174 static void
1175 ev_print_operation_export_finalize (GObject *object)
1176 {
1177         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (object);
1178
1179         if (export->idle_id > 0) {
1180                 g_source_remove (export->idle_id);
1181                 export->idle_id = 0;
1182         }
1183
1184         if (export->fd != -1) {
1185                 close (export->fd);
1186                 export->fd = -1;
1187         }
1188
1189         if (export->ranges) {
1190                 if (export->ranges != &export->one_range)
1191                         g_free (export->ranges);
1192                 export->ranges = NULL;
1193                 export->n_ranges = 0;
1194         }
1195
1196         if (export->temp_file) {
1197                 g_free (export->temp_file);
1198                 export->temp_file = NULL;
1199         }
1200
1201         if (export->job_name) {
1202                 g_free (export->job_name);
1203                 export->job_name = NULL;
1204         }
1205
1206         if (export->job_export) {
1207                 if (!ev_job_is_finished (export->job_export))
1208                         ev_job_cancel (export->job_export);
1209                 g_signal_handlers_disconnect_by_func (export->job_export,
1210                                                       export_job_finished,
1211                                                       export);
1212                 g_signal_handlers_disconnect_by_func (export->job_export,
1213                                                       export_job_cancelled,
1214                                                       export);
1215                 g_object_unref (export->job_export);
1216                 export->job_export = NULL;
1217         }
1218
1219         if (export->error) {
1220                 g_error_free (export->error);
1221                 export->error = NULL;
1222         }
1223
1224         if (export->print_settings) {
1225                 g_object_unref (export->print_settings);
1226                 export->print_settings = NULL;
1227         }
1228
1229         if (export->page_setup) {
1230                 g_object_unref (export->page_setup);
1231                 export->page_setup = NULL;
1232         }
1233
1234         if (export->printer) {
1235                 g_object_unref (export->printer);
1236                 export->printer = NULL;
1237         }
1238
1239         (* G_OBJECT_CLASS (ev_print_operation_export_parent_class)->finalize) (object);
1240 }
1241
1242 static void
1243 ev_print_operation_export_init (EvPrintOperationExport *export)
1244 {
1245 }
1246
1247 static GObject *
1248 ev_print_operation_export_constructor (GType                  type,
1249                                        guint                  n_construct_properties,
1250                                        GObjectConstructParam *construct_params)
1251 {
1252         GObject                *object;
1253         EvPrintOperationExport *export;
1254         EvPrintOperation       *op;
1255
1256         object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,
1257                                                                                        n_construct_properties,
1258                                                                                        construct_params);
1259         export = EV_PRINT_OPERATION_EXPORT (object);
1260         op = EV_PRINT_OPERATION (object);
1261         export->n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1262
1263         return object;
1264 }
1265
1266 static void
1267 ev_print_operation_export_class_init (EvPrintOperationExportClass *klass)
1268 {
1269         GObjectClass          *g_object_class = G_OBJECT_CLASS (klass);
1270         EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1271
1272         ev_print_op_class->set_current_page = ev_print_operation_export_set_current_page;
1273         ev_print_op_class->set_print_settings = ev_print_operation_export_set_print_settings;
1274         ev_print_op_class->get_print_settings = ev_print_operation_export_get_print_settings;
1275         ev_print_op_class->set_default_page_setup = ev_print_operation_export_set_default_page_setup;
1276         ev_print_op_class->get_default_page_setup = ev_print_operation_export_get_default_page_setup;
1277         ev_print_op_class->set_job_name = ev_print_operation_export_set_job_name;
1278         ev_print_op_class->get_job_name = ev_print_operation_export_get_job_name;
1279         ev_print_op_class->run = ev_print_operation_export_run;
1280         ev_print_op_class->cancel = ev_print_operation_export_cancel;
1281         ev_print_op_class->get_error = ev_print_operation_export_get_error;
1282
1283         g_object_class->constructor = ev_print_operation_export_constructor;
1284         g_object_class->finalize = ev_print_operation_export_finalize;
1285 }
1286
1287 /* Factory method */
1288 EvPrintOperation *
1289 ev_print_operation_new (EvDocument *document)
1290 {
1291         /* TODO: EvPrintOperationPrint */
1292
1293         return EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_EXPORT,
1294                                                  "document", document, NULL));
1295 }