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         GError *error = NULL;
 747
 748         g_assert (export->temp_file != NULL);
 749
 750         /* Some printers take into account some print settings,
 751          * and others don't. However we have exported the document
 752          * to a ps or pdf file according to such print settings. So,
 753          * we want to send the exported file to printer with those
 754          * settings set to default values.
 755          */
 756         settings = gtk_print_settings_copy (export->print_settings);
 757         capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
 758
 759         gtk_print_settings_set_page_ranges (settings, NULL, 0);
 760         gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
 761         if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
 762                 gtk_print_settings_set_n_copies (settings, 1);
 763         if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
 764                 gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
 765         if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
 766                 gtk_print_settings_set_scale (settings, 1.0);
 767         if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
 768                 gtk_print_settings_set_collate (settings, FALSE);
 769         if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
 770                 gtk_print_settings_set_reverse (settings, FALSE);
 771         if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
 772                 gtk_print_settings_set_number_up (settings, 1);
 773                 gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
 774         }
 775
 776         if (export->print_preview) {
 777                 GKeyFile *key_file;
 778                 gchar    *data = NULL;
 779                 gsize     data_len;
 780                 gchar    *print_settings_file = NULL;
 781
 782                 key_file = g_key_file_new ();
 783
 784                 gtk_print_settings_to_key_file (settings, key_file, NULL);
 785                 gtk_page_setup_to_key_file (export->page_setup, key_file, NULL);
 786                 g_key_file_set_string (key_file, "Print Job", "title", export->job_name);
 787
 788                 data = g_key_file_to_data (key_file, &data_len, &error);
 789                 if (data) {
 790                         gint fd;
 791
 792                         fd = g_file_open_tmp ("print-settingsXXXXXX", &print_settings_file, &error);
 793                         if (!error)
 794                                 g_file_set_contents (print_settings_file, data, data_len, &error);
 795                         close (fd);
 796
 797                         g_free (data);
 798                 }
 799
 800                 g_key_file_free (key_file);
 801
 802                 if (!error) {
 803                         gint    argc;
 804                         gchar **argv;
 805                         gchar  *cmd;
 806                         gchar  *quoted_filename;
 807                         gchar  *quoted_settings_filename;
 808
 809                         quoted_filename = g_shell_quote (export->temp_file);
 810                         quoted_settings_filename = g_shell_quote (print_settings_file);
 811                         cmd = g_strdup_printf ("evince-previewer --unlink-tempfile --print-settings %s %s",
 812                                                quoted_settings_filename, quoted_filename);
 813
 814                         g_shell_parse_argv (cmd, &argc, &argv, &error);
 815
 816                         g_free (quoted_filename);
 817                         g_free (quoted_settings_filename);
 818                         g_free (cmd);
 819
 820                         if (!error) {
 821                                 gdk_spawn_on_screen (gtk_window_get_screen (export->parent_window),
 822                                                      NULL, argv, NULL,
 823                                                      G_SPAWN_SEARCH_PATH,
 824                                                      NULL, NULL, NULL,
 825                                                      &error);
 826                         }
 827
 828                         g_strfreev (argv);
 829                 }
 830
 831                 if (error) {
 832                         if (print_settings_file)
 833                                 g_unlink (print_settings_file);
 834                         g_free (print_settings_file);
 835                 } else {
 836                         g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
 837                         /* temp_file will be deleted by the previewer */
 838
 839                         ev_print_operation_export_run_next (export);
 840                 }
 841         } else {
 842                 GtkPrintJob *job;
 843
 844                 job = gtk_print_job_new (export->job_name,
 845                                          export->printer,
 846                                          settings,
 847                                          export->page_setup);
 848                 gtk_print_job_set_source_file (job, export->temp_file, &error);
 849                 if (!error){
 850                         gtk_print_job_send (job,
 851                                             (GtkPrintJobCompleteFunc)print_job_finished,
 852                                             g_object_ref (export),
 853                                             (GDestroyNotify)g_object_unref);
 854                 }
 855         }
 856         g_object_unref (settings);
 857
 858         if (error) {
 859                 g_set_error_literal (&export->error,
 860                                      GTK_PRINT_ERROR,
 861                                      GTK_PRINT_ERROR_GENERAL,
 862                                      error->message);
 863                 g_error_free (error);
 864                 ev_print_operation_export_clear_temp_file (export);
 865                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
 866
 867                 ev_print_operation_export_run_next (export);
 868         }
 869 }
 870
 871 static void
 872 export_print_page_idle_finished (EvPrintOperationExport *export)
 873 {
 874         export->idle_id = 0;
 875 }
 876
 877 static void
 878 export_job_finished (EvJobExport            *job,
 879                      EvPrintOperationExport *export)
 880 {
 881         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 882
 883         if (export->pages_per_sheet == 1 || export->total % export->pages_per_sheet == 0) {
 884                 ev_document_doc_mutex_lock ();
 885                 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
 886                 ev_document_doc_mutex_unlock ();
 887         }
 888
 889         /* Reschedule */
 890         export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
 891                                            (GSourceFunc)export_print_page,
 892                                            export,
 893                                            (GDestroyNotify)export_print_page_idle_finished);
 894 }
 895
 896 static void
 897 export_job_cancelled (EvJobExport            *job,
 898                       EvPrintOperationExport *export)
 899 {
 900         export_cancel (export);
 901 }
 902
 903 static void
 904 export_cancel (EvPrintOperationExport *export)
 905 {
 906         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 907
 908         if (export->idle_id > 0)
 909                 g_source_remove (export->idle_id);
 910         export->idle_id = 0;
 911
 912         if (export->job_export) {
 913                 g_signal_handlers_disconnect_by_func (export->job_export,
 914                                                       export_job_finished,
 915                                                       export);
 916                 g_signal_handlers_disconnect_by_func (export->job_export,
 917                                                       export_job_cancelled,
 918                                                       export);
 919                 g_object_unref (export->job_export);
 920                 export->job_export = NULL;
 921         }
 922
 923         if (export->fd != -1) {
 924                 close (export->fd);
 925                 export->fd = -1;
 926         }
 927
 928         ev_print_operation_export_clear_temp_file (export);
 929
 930         g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
 931
 932         ev_print_operation_export_run_next (export);
 933 }
 934
 935 static void
 936 update_progress (EvPrintOperationExport *export)
 937 {
 938         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 939
 940         ev_print_operation_update_status (op, export->total,
 941                                           export->n_pages_to_print,
 942                                           export->total / (gdouble)export->n_pages_to_print);
 943 }
 944
 945 static gboolean
 946 export_print_page (EvPrintOperationExport *export)
 947 {
 948         EvPrintOperation *op = EV_PRINT_OPERATION (export);
 949
 950         if (!export->temp_file)
 951                 return FALSE; /* cancelled */
 952
 953         export->total++;
 954         export->collated++;
 955
 956         if (export->collated == export->collated_copies) {
 957                 export->collated = 0;
 958                 if (!export_print_inc_page (export)) {
 959                         ev_document_doc_mutex_lock ();
 960                         if (export->pages_per_sheet > 1 &&
 961                             export->total - 1 % export->pages_per_sheet == 0)
 962                                 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
 963                         ev_file_exporter_end (EV_FILE_EXPORTER (op->document));
 964                         ev_document_doc_mutex_unlock ();
 965
 966                         close (export->fd);
 967                         export->fd = -1;
 968
 969                         update_progress (export);
 970
 971                         export_print_done (export);
 972
 973                         return FALSE;
 974                 }
 975         }
 976
 977         if (export->pages_per_sheet == 1 || export->total % export->pages_per_sheet == 1) {
 978                 ev_document_doc_mutex_lock ();
 979                 ev_file_exporter_begin_page (EV_FILE_EXPORTER (op->document));
 980                 ev_document_doc_mutex_unlock ();
 981         }
 982
 983         if (!export->job_export) {
 984                 export->job_export = ev_job_export_new (op->document);
 985                 g_signal_connect (export->job_export, "finished",
 986                                   G_CALLBACK (export_job_finished),
 987                                   (gpointer)export);
 988                 g_signal_connect (export->job_export, "cancelled",
 989                                   G_CALLBACK (export_job_cancelled),
 990                                   (gpointer)export);
 991         }
 992
 993         ev_job_export_set_page (EV_JOB_EXPORT (export->job_export), export->page);
 994         ev_job_scheduler_push_job (export->job_export, EV_JOB_PRIORITY_NONE);
 995
 996         update_progress (export);
 997
 998         return FALSE;
 999 }
1000
1001 static void
1002 ev_print_operation_export_begin (EvPrintOperationExport *export)
1003 {
1004         EvPrintOperation *op = EV_PRINT_OPERATION (export);
1005
1006         if (!export->temp_file)
1007                 return; /* cancelled */
1008
1009         ev_document_doc_mutex_lock ();
1010         ev_file_exporter_begin (EV_FILE_EXPORTER (op->document), &export->fc);
1011         ev_document_doc_mutex_unlock ();
1012
1013         export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
1014                                            (GSourceFunc)export_print_page,
1015                                            export,
1016                                            (GDestroyNotify)export_print_page_idle_finished);
1017 }
1018
1019 static void
1020 ev_print_operation_export_print_dialog_response_cb (GtkDialog              *dialog,
1021                                                     gint                    response,
1022                                                     EvPrintOperationExport *export)
1023 {
1024         GtkPrintPages     print_pages;
1025         GtkPrintSettings *print_settings;
1026         GtkPageSetup     *page_setup;
1027         GtkPrinter       *printer;
1028         gdouble           scale;
1029         gdouble           width;
1030         gdouble           height;
1031         gint              first_page;
1032         gint              last_page;
1033         const gchar      *file_format;
1034         gchar            *filename;
1035         GError           *error = NULL;
1036         EvPrintOperation *op = EV_PRINT_OPERATION (export);
1037
1038         if (response != GTK_RESPONSE_OK &&
1039             response != GTK_RESPONSE_APPLY) {
1040                 gtk_widget_destroy (GTK_WIDGET (dialog));
1041                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
1042
1043                 return;
1044         }
1045
1046         export->print_preview = (response == GTK_RESPONSE_APPLY);
1047
1048         printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog));
1049         ev_print_operation_export_set_printer (export, printer);
1050
1051         print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog));
1052         ev_print_operation_export_set_print_settings (op, print_settings);
1053
1054         page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog));
1055         ev_print_operation_export_set_default_page_setup (op, page_setup);
1056
1057         if (!gtk_printer_accepts_ps (export->printer)) {
1058                 gtk_widget_destroy (GTK_WIDGET (dialog));
1059
1060                 g_set_error_literal (&export->error,
1061                                      GTK_PRINT_ERROR,
1062                                      GTK_PRINT_ERROR_GENERAL,
1063                                      _("Printing is not supported on this printer."));
1064                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1065
1066                 return;
1067         }
1068
1069         file_format = gtk_print_settings_get (print_settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
1070
1071         filename = g_strdup_printf ("evince_print.%s.XXXXXX", file_format);
1072         export->fd = g_file_open_tmp (filename, &export->temp_file, &error);
1073         g_free (filename);
1074         if (export->fd <= -1) {
1075                 gtk_widget_destroy (GTK_WIDGET (dialog));
1076
1077                 g_set_error_literal (&export->error,
1078                                      GTK_PRINT_ERROR,
1079                                      GTK_PRINT_ERROR_GENERAL,
1080                                      error->message);
1081                 g_error_free (error);
1082                 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1083
1084                 return;
1085         }
1086
1087         export->current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
1088         export->page_set = gtk_print_settings_get_page_set (print_settings);
1089         print_pages = gtk_print_settings_get_print_pages (print_settings);
1090
1091         switch (print_pages) {
1092         case GTK_PRINT_PAGES_CURRENT:
1093                 export->ranges = &export->one_range;
1094
1095                 export->ranges[0].start = export->current_page;
1096                 export->ranges[0].end = export->current_page;
1097                 export->n_ranges = 1;
1098
1099                 break;
1100         case GTK_PRINT_PAGES_RANGES: {
1101                 gint i;
1102
1103                 export->ranges = gtk_print_settings_get_page_ranges (print_settings, &export->n_ranges);
1104                 for (i = 0; i < export->n_ranges; i++)
1105                         if (export->ranges[i].end == -1 || export->ranges[i].end >= export->n_pages)
1106                                 export->ranges[i].end = export->n_pages - 1;
1107         }
1108                 break;
1109         case GTK_PRINT_PAGES_ALL:
1110                 export->ranges = &export->one_range;
1111
1112                 export->ranges[0].start = 0;
1113                 export->ranges[0].end = export->n_pages - 1;
1114                 export->n_ranges = 1;
1115
1116                 break;
1117         }
1118         if (!clamp_ranges (export)) {
1119                 GtkWidget *message_dialog;
1120
1121                 message_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
1122                                                  GTK_DIALOG_MODAL,
1123                                                  GTK_MESSAGE_WARNING,
1124                                                  GTK_BUTTONS_CLOSE,
1125                                                  "%s", _("Invalid page selection"));
1126                 gtk_window_set_title (GTK_WINDOW (message_dialog), _("Warning"));
1127                 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message_dialog),
1128                                                           "%s", _("Your print range selection does not include any page"));
1129                 g_signal_connect (message_dialog, "response",
1130                                   G_CALLBACK (gtk_widget_destroy),
1131                                   NULL);
1132                 gtk_widget_show (message_dialog);
1133
1134                 return;
1135         } else  ev_print_operation_update_status (op, -1, -1, 0.0);
1136
1137         width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
1138         height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
1139         scale = gtk_print_settings_get_scale (print_settings) * 0.01;
1140         if (scale != 1.0) {
1141                 width *= scale;
1142                 height *= scale;
1143         }
1144
1145         export->pages_per_sheet = MAX (1, gtk_print_settings_get_number_up (print_settings));
1146
1147         export->copies = gtk_print_settings_get_n_copies (print_settings);
1148         export->collate = gtk_print_settings_get_collate (print_settings);
1149         export->reverse = gtk_print_settings_get_reverse (print_settings);
1150
1151         if (export->collate) {
1152                 export->uncollated_copies = export->copies;
1153                 export->collated_copies = 1;
1154         } else {
1155                 export->uncollated_copies = 1;
1156                 export->collated_copies = export->copies;
1157         }
1158
1159         if (export->reverse) {
1160                 export->range = export->n_ranges - 1;
1161                 export->inc = -1;
1162         } else {
1163                 export->range = 0;
1164                 export->inc = 1;
1165         }
1166         find_range (export);
1167
1168         export->page = export->start - export->inc;
1169         export->collated = export->collated_copies - 1;
1170
1171         get_first_and_last_page (export, &first_page, &last_page);
1172
1173         export->fc.format = file_format && g_ascii_strcasecmp (file_format, "pdf") == 0 ?
1174                 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1175         export->fc.filename = export->temp_file;
1176         export->fc.first_page = MIN (first_page, last_page);
1177         export->fc.last_page = MAX (first_page, last_page);
1178         export->fc.paper_width = width;
1179         export->fc.paper_height = height;
1180         export->fc.duplex = FALSE;
1181         export->fc.pages_per_sheet = export->pages_per_sheet;
1182
1183         if (ev_print_queue_is_empty (op->document))
1184                 ev_print_operation_export_begin (export);
1185
1186         ev_print_queue_push (op);
1187
1188         g_signal_emit (op, signals[BEGIN_PRINT], 0);
1189
1190         gtk_widget_destroy (GTK_WIDGET (dialog));
1191 }
1192
1193 static void
1194 ev_print_operation_export_run (EvPrintOperation *op,
1195                                GtkWindow        *parent)
1196 {
1197         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1198         GtkWidget              *dialog;
1199         GtkPrintCapabilities    capabilities;
1200
1201         ev_print_queue_init ();
1202
1203         export->parent_window = parent;
1204         export->error = NULL;
1205
1206         dialog = gtk_print_unix_dialog_new (_("Print"), parent);
1207         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1208
1209         capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
1210                 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
1211         gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
1212                                                        capabilities);
1213
1214         gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
1215                                                 export->current_page);
1216
1217         gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
1218                                             export->print_settings);
1219
1220         if (export->page_setup)
1221                 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1222                                                       export->page_setup);
1223
1224         g_signal_connect (dialog, "response",
1225                           G_CALLBACK (ev_print_operation_export_print_dialog_response_cb),
1226                           export);
1227
1228         gtk_window_present (GTK_WINDOW (dialog));
1229 }
1230
1231 static void
1232 ev_print_operation_export_cancel (EvPrintOperation *op)
1233 {
1234         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1235
1236         if (export->job_export &&
1237             !ev_job_is_finished (export->job_export)) {
1238                 ev_job_cancel (export->job_export);
1239         } else {
1240                 export_cancel (export);
1241         }
1242 }
1243
1244 static void
1245 ev_print_operation_export_get_error (EvPrintOperation *op,
1246                                      GError          **error)
1247 {
1248         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1249
1250         g_propagate_error (error, export->error);
1251         export->error = NULL;
1252 }
1253
1254 static void
1255 ev_print_operation_export_finalize (GObject *object)
1256 {
1257         EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (object);
1258
1259         if (export->idle_id > 0) {
1260                 g_source_remove (export->idle_id);
1261                 export->idle_id = 0;
1262         }
1263
1264         if (export->fd != -1) {
1265                 close (export->fd);
1266                 export->fd = -1;
1267         }
1268
1269         if (export->ranges) {
1270                 if (export->ranges != &export->one_range)
1271                         g_free (export->ranges);
1272                 export->ranges = NULL;
1273                 export->n_ranges = 0;
1274         }
1275
1276         if (export->temp_file) {
1277                 g_free (export->temp_file);
1278                 export->temp_file = NULL;
1279         }
1280
1281         if (export->job_name) {
1282                 g_free (export->job_name);
1283                 export->job_name = NULL;
1284         }
1285
1286         if (export->job_export) {
1287                 if (!ev_job_is_finished (export->job_export))
1288                         ev_job_cancel (export->job_export);
1289                 g_signal_handlers_disconnect_by_func (export->job_export,
1290                                                       export_job_finished,
1291                                                       export);
1292                 g_signal_handlers_disconnect_by_func (export->job_export,
1293                                                       export_job_cancelled,
1294                                                       export);
1295                 g_object_unref (export->job_export);
1296                 export->job_export = NULL;
1297         }
1298
1299         if (export->error) {
1300                 g_error_free (export->error);
1301                 export->error = NULL;
1302         }
1303
1304         if (export->print_settings) {
1305                 g_object_unref (export->print_settings);
1306                 export->print_settings = NULL;
1307         }
1308
1309         if (export->page_setup) {
1310                 g_object_unref (export->page_setup);
1311                 export->page_setup = NULL;
1312         }
1313
1314         if (export->printer) {
1315                 g_object_unref (export->printer);
1316                 export->printer = NULL;
1317         }
1318
1319         (* G_OBJECT_CLASS (ev_print_operation_export_parent_class)->finalize) (object);
1320 }
1321
1322 static void
1323 ev_print_operation_export_init (EvPrintOperationExport *export)
1324 {
1325 }
1326
1327 static GObject *
1328 ev_print_operation_export_constructor (GType                  type,
1329                                        guint                  n_construct_properties,
1330                                        GObjectConstructParam *construct_params)
1331 {
1332         GObject                *object;
1333         EvPrintOperationExport *export;
1334         EvPrintOperation       *op;
1335
1336         object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,
1337                                                                                        n_construct_properties,
1338                                                                                        construct_params);
1339         export = EV_PRINT_OPERATION_EXPORT (object);
1340         op = EV_PRINT_OPERATION (object);
1341         export->n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1342
1343         return object;
1344 }
1345
1346 static void
1347 ev_print_operation_export_class_init (EvPrintOperationExportClass *klass)
1348 {
1349         GObjectClass          *g_object_class = G_OBJECT_CLASS (klass);
1350         EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1351
1352         ev_print_op_class->set_current_page = ev_print_operation_export_set_current_page;
1353         ev_print_op_class->set_print_settings = ev_print_operation_export_set_print_settings;
1354         ev_print_op_class->get_print_settings = ev_print_operation_export_get_print_settings;
1355         ev_print_op_class->set_default_page_setup = ev_print_operation_export_set_default_page_setup;
1356         ev_print_op_class->get_default_page_setup = ev_print_operation_export_get_default_page_setup;
1357         ev_print_op_class->set_job_name = ev_print_operation_export_set_job_name;
1358         ev_print_op_class->get_job_name = ev_print_operation_export_get_job_name;
1359         ev_print_op_class->run = ev_print_operation_export_run;
1360         ev_print_op_class->cancel = ev_print_operation_export_cancel;
1361         ev_print_op_class->get_error = ev_print_operation_export_get_error;
1362
1363         g_object_class->constructor = ev_print_operation_export_constructor;
1364         g_object_class->finalize = ev_print_operation_export_finalize;
1365 }
1366
1367 /* Factory method */
1368 EvPrintOperation *
1369 ev_print_operation_new (EvDocument *document)
1370 {
1371         /* TODO: EvPrintOperationPrint */
1372
1373         return EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_EXPORT,
1374                                                  "document", document, NULL));
1375 }