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 gboolean
 580 clamp_ranges (EvPrintOperationExport *export)
 581 {
 582         gint num_of_correct_ranges = 0;
 583         gint n_pages_to_print = 0;
 584         gint i;
 585         gboolean null_flag = FALSE;
 586
 587         for (i = 0; i < export->n_ranges; i++) {
 588                 gint n_pages;
 589
 590                 if ((export->ranges[i].start >= 0) &&
 591                     (export->ranges[i].start < export->n_pages) &&
 592                     (export->ranges[i].end >= 0) &&
 593                     (export->ranges[i].end < export->n_pages)) {
 594                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 595                         num_of_correct_ranges++;
 596                 } else if ((export->ranges[i].start >= 0) &&
 597                            (export->ranges[i].start < export->n_pages) &&
 598                            (export->ranges[i].end >= export->n_pages)) {
 599                         export->ranges[i].end = export->n_pages - 1;
 600                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 601                         num_of_correct_ranges++;
 602                 } else if ((export->ranges[i].end >= 0) &&
 603                            (export->ranges[i].end < export->n_pages) &&
 604                            (export->ranges[i].start < 0)) {
 605                         export->ranges[i].start = 0;
 606                         export->ranges[num_of_correct_ranges] = export->ranges[i];
 607                         num_of_correct_ranges++;
 608                 }
 609
 610                 n_pages = export->ranges[i].end - export->ranges[i].start + 1;
 611                 if (export->page_set == GTK_PAGE_SET_ALL) {
 612                         n_pages_to_print += n_pages;
 613                 } else if (n_pages % 2 == 0) {
 614                         n_pages_to_print += n_pages / 2;
 615                 } else if (export->page_set == GTK_PAGE_SET_EVEN) {
 616                         if (n_pages==1 && export->ranges[i].start % 2 == 0)
 617                                 null_flag = TRUE;
 618                         else
 619                                 n_pages_to_print += export->ranges[i].start % 2 == 0 ?
 620                                 n_pages / 2 : (n_pages / 2) + 1;
 621                 } else if (export->page_set == GTK_PAGE_SET_ODD) {
 622                         if (n_pages==1 && export->ranges[i].start % 2 != 0)
 623                                 null_flag = TRUE;
 624                         else
 625                                 n_pages_to_print += export->ranges[i].start % 2 == 0 ?
 626                                 (n_pages / 2) + 1 : n_pages / 2;
 627                 }
 628         }
 629
 630         if (null_flag && !n_pages_to_print) {
 631                 return FALSE;
 632         } else {
 633                 export->n_ranges = num_of_correct_ranges;
 634                 export->n_pages_to_print = n_pages_to_print;
 635                 return TRUE;
 636         }
 637 }
 638
 639 static void
 640 get_first_and_last_page (EvPrintOperationExport *export,
 641                          gint                   *first,
 642                          gint                   *last)
 643 {
 644         gint i;
 645         gint first_page = G_MAXINT;
 646         gint last_page = G_MININT;
 647         gint max_page = export->n_pages - 1;
 648
 649         if (export->n_ranges == 0) {
 650                 *first = 0;
 651                 *last = max_page;
 652
 653                 return;
 654         }
 655
 656         for (i = 0; i < export->n_ranges; i++) {
 657                 if (export->ranges[i].start < first_page)
 658                         first_page = export->ranges[i].start;
 659                 if (export->ranges[i].end > last_page)
 660                         last_page = export->ranges[i].end;
 661         }
 662
 663         *first = MAX (0, first_page);
 664         *last = MIN (max_page, last_page);
 665 }
 666
 667 static gboolean
 668 export_print_inc_page (EvPrintOperationExport *export)
 669 {
 670         do {
 671                 export->page += export->inc;
 672                 if (export->page == export->end) {
 673                         export->range += export->inc;
 674                         if (export->range == -1 || export->range == export->n_ranges) {
 675                                 export->uncollated++;
 676                                 if (export->uncollated == export->uncollated_copies)
 677                                         return FALSE;
 678
 679                                 export->range = export->inc < 0 ? export->n_ranges - 1 : 0;
 680                         }
 681                         find_range (export);
 682                         export->page = export->start;
 683                 }
 684         } while ((export->page_set == GTK_PAGE_SET_EVEN && export->page % 2 == 0) ||
 685                  (export->page_set == GTK_PAGE_SET_ODD && export->page % 2 == 1));
 686
 687         return TRUE;
 688 }
 689
 690 static void
 691 ev_print_operation_export_clear_temp_file (EvPrintOperationExport *export)
 692 {
 693         if (!export->temp_file)
 694                 return;
 695
 696         g_unlink (export->temp_file);
 697         g_free (export->temp_file);
 698         export->temp_file = NULL;
 699 }
 700
 701 static void
 702 ev_print_operation_export_run_next (EvPrintOperationExport *export)
 703 {
 704         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 705         EvPrintOperation *next;
 706         EvDocument       *document;
 707
 708         /* First pop the current job */
 709         document = op->document;
 710         ev_print_queue_pop (document);
 711
 712         next = ev_print_queue_peek (document);
 713         if (next)
 714                 ev_print_operation_export_begin (EV_PRINT_OPERATION_EXPORT (next));
 715 }
 716
 717 static void
 718 print_job_finished (GtkPrintJob            *print_job,
 719                     EvPrintOperationExport *export,
 720                     GError                 *error)
 721 {
 722         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 723
 724         if (error) {
 725                 g_set_error_literal (&export->error,
 726                                      GTK_PRINT_ERROR,
 727                                      GTK_PRINT_ERROR_GENERAL,
 728                                      error->message);
 729                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
 730         } else {
 731                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
 732         }
 733
 734         ev_print_operation_export_clear_temp_file (export);
 735         g_object_unref (print_job);
 736
 737         ev_print_operation_export_run_next (export);
 738 }
 739
 740 static void
 741 export_print_done (EvPrintOperationExport *export)
 742 {
 743         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 744         GtkPrintSettings *settings;
 745         EvFileExporterCapabilities capabilities;
 746
 747         g_assert (export->temp_file != NULL);
 748
 749         /* Some printers take into account some print settings,
 750          * and others don't. However we have exported the document
 751          * to a ps or pdf file according to such print settings. So,
 752          * we want to send the exported file to printer with those
 753          * settings set to default values.
 754          */
 755         settings = gtk_print_settings_copy (export->print_settings);
 756         capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
 757
 758         gtk_print_settings_set_page_ranges (settings, NULL, 0);
 759         gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
 760         if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
 761                 gtk_print_settings_set_n_copies (settings, 1);
 762         if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
 763                 gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
 764         if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
 765                 gtk_print_settings_set_scale (settings, 1.0);
 766         if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
 767                 gtk_print_settings_set_collate (settings, FALSE);
 768         if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
 769                 gtk_print_settings_set_reverse (settings, FALSE);
 770         if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
 771                 gtk_print_settings_set_number_up (settings, 1);
 772                 gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
 773         }
 774
 775         if (export->print_preview) {
 776                 gchar *uri;
 777                 gchar *print_settings_file = NULL;
 778
 779                 print_settings_file = ev_tmp_filename ("print-settings");
 780                 gtk_print_settings_to_file (settings, print_settings_file, NULL);
 781
 782                 uri = g_filename_to_uri (export->temp_file, NULL, NULL);
 783                 ev_application_open_uri_at_dest (EV_APP,
 784                                                  uri,
 785                                                  gtk_window_get_screen (export->parent_window),
 786                                                  NULL,
 787                                                  EV_WINDOW_MODE_PREVIEW,
 788                                                  NULL,
 789                                                  TRUE,
 790                                                  print_settings_file,
 791                                                  GDK_CURRENT_TIME);
 792                 g_free (print_settings_file);
 793                 g_free (uri);
 794
 795                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
 796                 /* temp_file will be deleted by the previewer */
 797
 798                 ev_print_operation_export_run_next (export);
 799         } else {
 800                 GtkPrintJob *job;
 801                 GError      *error = NULL;
 802
 803                 job = gtk_print_job_new (export->job_name,
 804                                          export->printer,
 805                                          settings,
 806                                          export->page_setup);
 807                 gtk_print_job_set_source_file (job, export->temp_file, &error);
 808                 if (error) {
 809                         g_set_error_literal (&export->error,
 810                                              GTK_PRINT_ERROR,
 811                                              GTK_PRINT_ERROR_GENERAL,
 812                                              error->message);
 813                         g_error_free (error);
 814                         ev_print_operation_export_clear_temp_file (export);
 815                         g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
 816
 817                         ev_print_operation_export_run_next (export);
 818                 } else {
 819                         gtk_print_job_send (job,
 820                                             (GtkPrintJobCompleteFunc)print_job_finished,
 821                                             g_object_ref (export),
 822                                             (GDestroyNotify)g_object_unref);
 823                 }
 824         }
 825         g_object_unref (settings);
 826 }
 827
 828 static void
 829 export_print_page_idle_finished (EvPrintOperationExport *export)
 830 {
 831         export->idle_id = 0;
 832 }
 833
 834 static void
 835 export_job_finished (EvJobExport            *job,
 836                      EvPrintOperationExport *export)
 837 {
 838         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 839
 840         if (export->pages_per_sheet == 1 || export->total % export->pages_per_sheet == 0) {
 841                 ev_document_doc_mutex_lock ();
 842                 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
 843                 ev_document_doc_mutex_unlock ();
 844         }
 845
 846         /* Reschedule */
 847         export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 848                                            (GSourceFunc)export_print_page,
 849                                            export,
 850                                            (GDestroyNotify)export_print_page_idle_finished);
 851 }
 852
 853 static void
 854 export_job_cancelled (EvJobExport            *job,
 855                       EvPrintOperationExport *export)
 856 {
 857         export_cancel (export);
 858 }
 859
 860 static void
 861 export_cancel (EvPrintOperationExport *export)
 862 {
 863         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 864
 865         if (export->idle_id > 0)
 866                 g_source_remove (export->idle_id);
 867         export->idle_id = 0;
 868
 869         if (export->job_export) {
 870                 g_signal_handlers_disconnect_by_func (export->job_export,
 871                                                       export_job_finished,
 872                                                       export);
 873                 g_signal_handlers_disconnect_by_func (export->job_export,
 874                                                       export_job_cancelled,
 875                                                       export);
 876                 g_object_unref (export->job_export);
 877                 export->job_export = NULL;
 878         }
 879
 880         if (export->fd != -1) {
 881                 close (export->fd);
 882                 export->fd = -1;
 883         }
 884
 885         ev_print_operation_export_clear_temp_file (export);
 886
 887         g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
 888
 889         ev_print_operation_export_run_next (export);
 890 }
 891
 892 static void
 893 update_progress (EvPrintOperationExport *export)
 894 {
 895         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 896
 897         ev_print_operation_update_status (op, export->total,
 898                                           export->n_pages_to_print,
 899                                           export->total / (gdouble)export->n_pages_to_print);
 900 }
 901
 902 static gboolean
 903 export_print_page (EvPrintOperationExport *export)
 904 {
 905         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 906
 907         if (!export->temp_file)
 908                 return FALSE; /* cancelled */
 909
 910         export->total++;
 911         export->collated++;
 912
 913         if (export->collated == export->collated_copies) {
 914                 export->collated = 0;
 915                 if (!export_print_inc_page (export)) {
 916                         ev_document_doc_mutex_lock ();
 917                         if (export->pages_per_sheet > 1 &&
 918                             export->total - 1 % export->pages_per_sheet == 0)
 919                                 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
 920                         ev_file_exporter_end (EV_FILE_EXPORTER (op->document));
 921                         ev_document_doc_mutex_unlock ();
 922
 923                         close (export->fd);
 924                         export->fd = -1;
 925
 926                         update_progress (export);
 927
 928                         export_print_done (export);
 929
 930                         return FALSE;
 931                 }
 932         }
 933
 934         if (export->pages_per_sheet == 1 || export->total % export->pages_per_sheet == 1) {
 935                 ev_document_doc_mutex_lock ();
 936                 ev_file_exporter_begin_page (EV_FILE_EXPORTER (op->document));
 937                 ev_document_doc_mutex_unlock ();
 938         }
 939
 940         if (!export->job_export) {
 941                 export->job_export = ev_job_export_new (op->document);
 942                 g_signal_connect (export->job_export, "finished",
 943                                   G_CALLBACK (export_job_finished),
 944                                   (gpointer)export);
 945                 g_signal_connect (export->job_export, "cancelled",
 946                                   G_CALLBACK (export_job_cancelled),
 947                                   (gpointer)export);
 948         }
 949
 950         ev_job_export_set_page (EV_JOB_EXPORT (export->job_export), export->page);
 951         ev_job_scheduler_push_job (export->job_export, EV_JOB_PRIORITY_NONE);
 952
 953         update_progress (export);
 954
 955         return FALSE;
 956 }
 957
 958 static void
 959 ev_print_operation_export_begin (EvPrintOperationExport *export)
 960 {
 961         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 962
 963         if (!export->temp_file)
 964                 return; /* cancelled */
 965
 966         ev_document_doc_mutex_lock ();
 967         ev_file_exporter_begin (EV_FILE_EXPORTER (op->document), &export->fc);
 968         ev_document_doc_mutex_unlock ();
 969
 970         export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 971                                            (GSourceFunc)export_print_page,
 972                                            export,
 973                                            (GDestroyNotify)export_print_page_idle_finished);
 974 }
 975
 976 static void
 977 ev_print_operation_export_print_dialog_response_cb (GtkDialog              *dialog,
 978                                                     gint                    response,
 979                                                     EvPrintOperationExport *export)
 980 {
 981         GtkPrintPages     print_pages;
 982         GtkPrintSettings *print_settings;
 983         GtkPageSetup     *page_setup;
 984         GtkPrinter       *printer;
 985         gdouble           scale;
 986         gdouble           width;
 987         gdouble           height;
 988         gint              first_page;
 989         gint              last_page;
 990         const gchar      *file_format;
 991         gchar            *filename;
 992         GError           *error = NULL;
 993         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 994
 995         if (response != GTK_RESPONSE_OK &&
 996             response != GTK_RESPONSE_APPLY) {
 997                 gtk_widget_destroy (GTK_WIDGET (dialog));
 998                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
 999
1000                 return;
1001         }
1002
1003         export->print_preview = (response == GTK_RESPONSE_APPLY);
1004
1005         printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog));
1006         ev_print_operation_export_set_printer (export, printer);
1007
1008         print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog));
1009         ev_print_operation_export_set_print_settings (op, print_settings);
1010
1011         page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog));
1012         ev_print_operation_export_set_default_page_setup (op, page_setup);
1013
1014         if (!gtk_printer_accepts_ps (export->printer)) {
1015                 gtk_widget_destroy (GTK_WIDGET (dialog));
1016
1017                 g_set_error_literal (&export->error,
1018                                      GTK_PRINT_ERROR,
1019                                      GTK_PRINT_ERROR_GENERAL,
1020                                      _("Printing is not supported on this printer."));
1021                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1022
1023                 return;
1024         }
1025
1026         file_format = gtk_print_settings_get (print_settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
1027
1028         filename = g_strdup_printf ("evince_print.%s.XXXXXX", file_format);
1029         export->fd = g_file_open_tmp (filename, &export->temp_file, &error);
1030         g_free (filename);
1031         if (export->fd <= -1) {
1032                 gtk_widget_destroy (GTK_WIDGET (dialog));
1033
1034                 g_set_error_literal (&export->error,
1035                                      GTK_PRINT_ERROR,
1036                                      GTK_PRINT_ERROR_GENERAL,
1037                                      error->message);
1038                 g_error_free (error);
1039                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1040
1041                 return;
1042         }
1043
1044         export->current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
1045         export->page_set = gtk_print_settings_get_page_set (print_settings);
1046         print_pages = gtk_print_settings_get_print_pages (print_settings);
1047
1048         switch (print_pages) {
1049         case GTK_PRINT_PAGES_CURRENT:
1050                 export->ranges = &export->one_range;
1051
1052                 export->ranges[0].start = export->current_page;
1053                 export->ranges[0].end = export->current_page;
1054                 export->n_ranges = 1;
1055
1056                 break;
1057         case GTK_PRINT_PAGES_RANGES: {
1058                 gint i;
1059
1060                 export->ranges = gtk_print_settings_get_page_ranges (print_settings, &export->n_ranges);
1061                 for (i = 0; i < export->n_ranges; i++)
1062                         if (export->ranges[i].end == -1 || export->ranges[i].end >= export->n_pages)
1063                                 export->ranges[i].end = export->n_pages - 1;
1064         }
1065                 break;
1066         case GTK_PRINT_PAGES_ALL:
1067                 export->ranges = &export->one_range;
1068
1069                 export->ranges[0].start = 0;
1070                 export->ranges[0].end = export->n_pages - 1;
1071                 export->n_ranges = 1;
1072
1073                 break;
1074         }
1075         if (!clamp_ranges (export)) {
1076                 GtkWidget *message_dialog;
1077
1078                 message_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
1079                                                  GTK_DIALOG_MODAL,
1080                                                  GTK_MESSAGE_WARNING,
1081                                                  GTK_BUTTONS_CLOSE,
1082                                                  "%s", _("Invalid page selection"));
1083                 gtk_window_set_title (GTK_WINDOW (message_dialog), _("Warning"));
1084                 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message_dialog),
1085                                                           "%s", _("Your print range selection does not include any page"));
1086                 g_signal_connect (message_dialog, "response",
1087                                   G_CALLBACK (gtk_widget_destroy),
1088                                   NULL);
1089                 gtk_widget_show (message_dialog);
1090
1091                 return;
1092         } else  ev_print_operation_update_status (op, -1, -1, 0.0);
1093
1094         width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
1095         height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
1096         scale = gtk_print_settings_get_scale (print_settings) * 0.01;
1097         if (scale != 1.0) {
1098                 width *= scale;
1099                 height *= scale;
1100         }
1101
1102         export->pages_per_sheet = MAX (1, gtk_print_settings_get_number_up (print_settings));
1103
1104         export->copies = gtk_print_settings_get_n_copies (print_settings);
1105         export->collate = gtk_print_settings_get_collate (print_settings);
1106         export->reverse = gtk_print_settings_get_reverse (print_settings);
1107
1108         if (export->collate) {
1109                 export->uncollated_copies = export->copies;
1110                 export->collated_copies = 1;
1111         } else {
1112                 export->uncollated_copies = 1;
1113                 export->collated_copies = export->copies;
1114         }
1115
1116         if (export->reverse) {
1117                 export->range = export->n_ranges - 1;
1118                 export->inc = -1;
1119         } else {
1120                 export->range = 0;
1121                 export->inc = 1;
1122         }
1123         find_range (export);
1124
1125         export->page = export->start - export->inc;
1126         export->collated = export->collated_copies - 1;
1127
1128         get_first_and_last_page (export, &first_page, &last_page);
1129
1130         export->fc.format = file_format && g_ascii_strcasecmp (file_format, "pdf") == 0 ?
1131                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1132         export->fc.filename = export->temp_file;
1133         export->fc.first_page = MIN (first_page, last_page);
1134         export->fc.last_page = MAX (first_page, last_page);
1135         export->fc.paper_width = width;
1136         export->fc.paper_height = height;
1137         export->fc.duplex = FALSE;
1138         export->fc.pages_per_sheet = export->pages_per_sheet;
1139
1140         if (ev_print_queue_is_empty (op->document))
1141                 ev_print_operation_export_begin (export);
1142
1143         ev_print_queue_push (op);
1144
1145         g_signal_emit (op, signals[BEGIN_PRINT], 0);
1146
1147         gtk_widget_destroy (GTK_WIDGET (dialog));
1148 }
1149
1150 static void
1151 ev_print_operation_export_run (EvPrintOperation *op,
1152                                GtkWindow        *parent)
1153 {
1154         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1155         GtkWidget              *dialog;
1156         GtkPrintCapabilities    capabilities;
1157
1158         ev_print_queue_init ();
1159
1160         export->parent_window = parent;
1161         export->error = NULL;
1162
1163         dialog = gtk_print_unix_dialog_new (_("Print"), parent);
1164         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1165
1166         capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
1167                 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
1168         gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
1169                                                        capabilities);
1170
1171         gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
1172                                                 export->current_page);
1173
1174         gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
1175                                             export->print_settings);
1176
1177         if (export->page_setup)
1178                 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1179                                                       export->page_setup);
1180
1181         g_signal_connect (dialog, "response",
1182                           G_CALLBACK (ev_print_operation_export_print_dialog_response_cb),
1183                           export);
1184
1185         gtk_window_present (GTK_WINDOW (dialog));
1186 }
1187
1188 static void
1189 ev_print_operation_export_cancel (EvPrintOperation *op)
1190 {
1191         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1192
1193         if (export->job_export &&
1194             !ev_job_is_finished (export->job_export)) {
1195                 ev_job_cancel (export->job_export);
1196         } else {
1197                 export_cancel (export);
1198         }
1199 }
1200
1201 static void
1202 ev_print_operation_export_get_error (EvPrintOperation *op,
1203                                      GError          **error)
1204 {
1205         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1206
1207         g_propagate_error (error, export->error);
1208         export->error = NULL;
1209 }
1210
1211 static void
1212 ev_print_operation_export_finalize (GObject *object)
1213 {
1214         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (object);
1215
1216         if (export->idle_id > 0) {
1217                 g_source_remove (export->idle_id);
1218                 export->idle_id = 0;
1219         }
1220
1221         if (export->fd != -1) {
1222                 close (export->fd);
1223                 export->fd = -1;
1224         }
1225
1226         if (export->ranges) {
1227                 if (export->ranges != &export->one_range)
1228                         g_free (export->ranges);
1229                 export->ranges = NULL;
1230                 export->n_ranges = 0;
1231         }
1232
1233         if (export->temp_file) {
1234                 g_free (export->temp_file);
1235                 export->temp_file = NULL;
1236         }
1237
1238         if (export->job_name) {
1239                 g_free (export->job_name);
1240                 export->job_name = NULL;
1241         }
1242
1243         if (export->job_export) {
1244                 if (!ev_job_is_finished (export->job_export))
1245                         ev_job_cancel (export->job_export);
1246                 g_signal_handlers_disconnect_by_func (export->job_export,
1247                                                       export_job_finished,
1248                                                       export);
1249                 g_signal_handlers_disconnect_by_func (export->job_export,
1250                                                       export_job_cancelled,
1251                                                       export);
1252                 g_object_unref (export->job_export);
1253                 export->job_export = NULL;
1254         }
1255
1256         if (export->error) {
1257                 g_error_free (export->error);
1258                 export->error = NULL;
1259         }
1260
1261         if (export->print_settings) {
1262                 g_object_unref (export->print_settings);
1263                 export->print_settings = NULL;
1264         }
1265
1266         if (export->page_setup) {
1267                 g_object_unref (export->page_setup);
1268                 export->page_setup = NULL;
1269         }
1270
1271         if (export->printer) {
1272                 g_object_unref (export->printer);
1273                 export->printer = NULL;
1274         }
1275
1276         (* G_OBJECT_CLASS (ev_print_operation_export_parent_class)->finalize) (object);
1277 }
1278
1279 static void
1280 ev_print_operation_export_init (EvPrintOperationExport *export)
1281 {
1282 }
1283
1284 static GObject *
1285 ev_print_operation_export_constructor (GType                  type,
1286                                        guint                  n_construct_properties,
1287                                        GObjectConstructParam *construct_params)
1288 {
1289         GObject                *object;
1290         EvPrintOperationExport *export;
1291         EvPrintOperation       *op;
1292
1293         object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,
1294                                                                                        n_construct_properties,
1295                                                                                        construct_params);
1296         export = EV_PRINT_OPERATION_EXPORT (object);
1297         op = EV_PRINT_OPERATION (object);
1298         export->n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1299
1300         return object;
1301 }
1302
1303 static void
1304 ev_print_operation_export_class_init (EvPrintOperationExportClass *klass)
1305 {
1306         GObjectClass          *g_object_class = G_OBJECT_CLASS (klass);
1307         EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1308
1309         ev_print_op_class->set_current_page = ev_print_operation_export_set_current_page;
1310         ev_print_op_class->set_print_settings = ev_print_operation_export_set_print_settings;
1311         ev_print_op_class->get_print_settings = ev_print_operation_export_get_print_settings;
1312         ev_print_op_class->set_default_page_setup = ev_print_operation_export_set_default_page_setup;
1313         ev_print_op_class->get_default_page_setup = ev_print_operation_export_get_default_page_setup;
1314         ev_print_op_class->set_job_name = ev_print_operation_export_set_job_name;
1315         ev_print_op_class->get_job_name = ev_print_operation_export_get_job_name;
1316         ev_print_op_class->run = ev_print_operation_export_run;
1317         ev_print_op_class->cancel = ev_print_operation_export_cancel;
1318         ev_print_op_class->get_error = ev_print_operation_export_get_error;
1319
1320         g_object_class->constructor = ev_print_operation_export_constructor;
1321         g_object_class->finalize = ev_print_operation_export_finalize;
1322 }
1323
1324 /* Factory method */
1325 EvPrintOperation *
1326 ev_print_operation_new (EvDocument *document)
1327 {
1328         /* TODO: EvPrintOperationPrint */
1329
1330         return EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_EXPORT,
1331                                                  "document", document, NULL));
1332 }