1 /* this file is part of evince, a gnome document viewer
3 * Copyright (C) 2008 Carlos Garcia Campos <carlosgc@gnome.org>
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.
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.
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.
22 #include "ev-print-operation.h"
24 #if GTKUNIXPRINT_ENABLED
25 #include <gtk/gtkunixprint.h>
27 #include <glib/gi18n.h>
28 #include <glib/gstdio.h>
31 #include "ev-page-cache.h"
32 #include "ev-file-exporter.h"
34 #include "ev-job-scheduler.h"
35 #include "ev-application.h"
36 #include "ev-file-helpers.h"
37 #include "ev-document-print.h"
51 static guint signals[LAST_SIGNAL] = { 0 };
53 struct _EvPrintOperation {
63 struct _EvPrintOperationClass {
64 GObjectClass parent_class;
66 void (* set_current_page) (EvPrintOperation *op,
68 void (* set_print_settings) (EvPrintOperation *op,
69 GtkPrintSettings *print_settings);
70 GtkPrintSettings *(* get_print_settings) (EvPrintOperation *op);
71 void (* set_default_page_setup) (EvPrintOperation *op,
72 GtkPageSetup *page_setup);
73 GtkPageSetup *(* get_default_page_setup) (EvPrintOperation *op);
74 void (* set_job_name) (EvPrintOperation *op,
75 const gchar *job_name);
76 const gchar *(* get_job_name) (EvPrintOperation *op);
77 void (* run) (EvPrintOperation *op,
79 void (* cancel) (EvPrintOperation *op);
80 void (* get_error) (EvPrintOperation *op,
84 void (* done) (EvPrintOperation *op,
85 GtkPrintOperationResult result);
86 void (* begin_print) (EvPrintOperation *op);
87 void (* status_changed) (EvPrintOperation *op);
90 G_DEFINE_ABSTRACT_TYPE (EvPrintOperation, ev_print_operation, G_TYPE_OBJECT)
93 ev_print_operation_finalize (GObject *object)
95 EvPrintOperation *op = EV_PRINT_OPERATION (object);
98 g_object_unref (op->document);
107 (* G_OBJECT_CLASS (ev_print_operation_parent_class)->finalize) (object);
111 ev_print_operation_set_property (GObject *object,
116 EvPrintOperation *op = EV_PRINT_OPERATION (object);
120 op->document = g_value_dup_object (value);
123 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
128 ev_print_operation_init (EvPrintOperation *op)
133 ev_print_operation_class_init (EvPrintOperationClass *klass)
135 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
137 g_object_class->set_property = ev_print_operation_set_property;
138 g_object_class->finalize = ev_print_operation_finalize;
140 g_object_class_install_property (g_object_class,
142 g_param_spec_object ("document",
144 "The document to print",
147 G_PARAM_CONSTRUCT_ONLY));
149 g_signal_new ("done",
150 G_TYPE_FROM_CLASS (g_object_class),
152 G_STRUCT_OFFSET (EvPrintOperationClass, done),
154 g_cclosure_marshal_VOID__ENUM,
156 GTK_TYPE_PRINT_OPERATION_RESULT);
157 signals[BEGIN_PRINT] =
158 g_signal_new ("begin_print",
159 G_TYPE_FROM_CLASS (g_object_class),
161 G_STRUCT_OFFSET (EvPrintOperationClass, begin_print),
163 g_cclosure_marshal_VOID__VOID,
165 signals[STATUS_CHANGED] =
166 g_signal_new ("status_changed",
167 G_TYPE_FROM_CLASS (g_object_class),
169 G_STRUCT_OFFSET (EvPrintOperationClass, status_changed),
171 g_cclosure_marshal_VOID__VOID,
177 ev_print_operation_set_current_page (EvPrintOperation *op,
180 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
182 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
183 g_return_if_fail (current_page >= 0);
185 class->set_current_page (op, current_page);
189 ev_print_operation_set_print_settings (EvPrintOperation *op,
190 GtkPrintSettings *print_settings)
192 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
194 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
195 g_return_if_fail (GTK_IS_PRINT_SETTINGS (print_settings));
197 class->set_print_settings (op, print_settings);
201 ev_print_operation_get_print_settings (EvPrintOperation *op)
203 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
205 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
207 return class->get_print_settings (op);
211 ev_print_operation_set_default_page_setup (EvPrintOperation *op,
212 GtkPageSetup *page_setup)
214 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
216 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
217 g_return_if_fail (GTK_IS_PAGE_SETUP (page_setup));
219 class->set_default_page_setup (op, page_setup);
223 ev_print_operation_get_default_page_setup (EvPrintOperation *op)
225 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
227 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
229 return class->get_default_page_setup (op);
233 ev_print_operation_set_job_name (EvPrintOperation *op,
234 const gchar *job_name)
236 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
238 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
239 g_return_if_fail (job_name != NULL);
241 class->set_job_name (op, job_name);
245 ev_print_operation_get_job_name (EvPrintOperation *op)
247 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
249 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
251 return class->get_job_name (op);
255 ev_print_operation_run (EvPrintOperation *op,
258 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
260 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
262 class->run (op, parent);
266 ev_print_operation_cancel (EvPrintOperation *op)
268 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
270 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
276 ev_print_operation_get_error (EvPrintOperation *op,
279 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
281 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
283 class->get_error (op, error);
287 ev_print_operation_get_status (EvPrintOperation *op)
289 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
291 return op->status ? op->status : "";
295 ev_print_operation_get_progress (EvPrintOperation *op)
297 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), 0.0);
302 #if GTK_CHECK_VERSION (2, 17, 1) | GTKUNIXPRINT_ENABLED
304 ev_print_operation_update_status (EvPrintOperation *op,
309 if (op->status && op->progress == progress)
316 op->status = g_strdup (_("Preparing to print ..."));
317 } else if (page > n_pages) {
318 op->status = g_strdup (_("Finishing..."));
320 op->status = g_strdup_printf (_("Printing page %d of %d..."),
324 op->progress = MIN (1.0, progress);
326 g_signal_emit (op, signals[STATUS_CHANGED], 0);
330 #if GTKUNIXPRINT_ENABLED
332 /* Export interface */
333 #define EV_TYPE_PRINT_OPERATION_EXPORT (ev_print_operation_export_get_type())
334 #define EV_PRINT_OPERATION_EXPORT(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PRINT_OPERATION_EXPORT, EvPrintOperationExport))
335 #define EV_PRINT_OPERATION_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PRINT_OPERATION_EXPORT, EvPrintOperationExportClass))
336 #define EV_IS_PRINT_OPERATION_EXPORT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PRINT_OPERATION_EXPORT))
338 typedef struct _EvPrintOperationExport EvPrintOperationExport;
339 typedef struct _EvPrintOperationExportClass EvPrintOperationExportClass;
341 static GType ev_print_operation_export_get_type (void) G_GNUC_CONST;
343 static void ev_print_operation_export_begin (EvPrintOperationExport *export);
344 static gboolean export_print_page (EvPrintOperationExport *export);
345 static void export_cancel (EvPrintOperationExport *export);
347 struct _EvPrintOperationExport {
348 EvPrintOperation parent;
350 GtkWindow *parent_window;
354 gboolean print_preview;
358 GtkPageSetup *page_setup;
359 GtkPrintSettings *print_settings;
364 gint pages_per_sheet;
372 EvFileExporterContext fc;
373 gint n_pages_to_print;
374 gint uncollated_copies;
375 gint collated_copies;
376 gint uncollated, collated, total, blank;
378 gint range, n_ranges;
379 GtkPageRange *ranges;
380 GtkPageRange one_range;
382 gint page, start, end, inc;
385 struct _EvPrintOperationExportClass {
386 EvPrintOperationClass parent_class;
389 G_DEFINE_TYPE (EvPrintOperationExport, ev_print_operation_export, EV_TYPE_PRINT_OPERATION)
391 /* Internal print queue */
392 static GHashTable *print_queue = NULL;
395 queue_free (GQueue *queue)
397 g_queue_foreach (queue, (GFunc)g_object_unref, NULL);
398 g_queue_free (queue);
402 ev_print_queue_init (void)
404 if (G_UNLIKELY (print_queue == NULL)) {
405 print_queue = g_hash_table_new_full (g_direct_hash,
408 (GDestroyNotify)queue_free);
413 remove_document_queue (gpointer data,
417 g_hash_table_remove (print_queue, document);
421 ev_print_queue_is_empty (EvDocument *document)
425 queue = g_hash_table_lookup (print_queue, document);
426 return (!queue || g_queue_is_empty (queue));
430 ev_print_queue_push (EvPrintOperation *op)
434 queue = g_hash_table_lookup (print_queue, op->document);
436 queue = g_queue_new ();
437 g_hash_table_insert (print_queue,
440 g_object_weak_ref (G_OBJECT (op->document),
441 (GWeakNotify)remove_document_queue,
445 g_queue_push_head (queue, g_object_ref (op));
448 static EvPrintOperation *
449 ev_print_queue_pop (EvDocument *document)
451 EvPrintOperation *op;
454 queue = g_hash_table_lookup (print_queue, document);
455 if (!queue || g_queue_is_empty (queue))
458 op = g_queue_pop_tail (queue);
464 static EvPrintOperation *
465 ev_print_queue_peek (EvDocument *document)
469 queue = g_hash_table_lookup (print_queue, document);
470 if (!queue || g_queue_is_empty (queue))
473 return g_queue_peek_tail (queue);
477 ev_print_operation_export_set_current_page (EvPrintOperation *op,
480 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
482 g_return_if_fail (current_page < export->n_pages);
484 export->current_page = current_page;
488 ev_print_operation_export_set_print_settings (EvPrintOperation *op,
489 GtkPrintSettings *print_settings)
491 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
493 if (print_settings == export->print_settings)
496 g_object_ref (print_settings);
497 if (export->print_settings)
498 g_object_unref (export->print_settings);
499 export->print_settings = print_settings;
502 static GtkPrintSettings *
503 ev_print_operation_export_get_print_settings (EvPrintOperation *op)
505 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
507 return export->print_settings;
511 ev_print_operation_export_set_default_page_setup (EvPrintOperation *op,
512 GtkPageSetup *page_setup)
514 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
516 if (page_setup == export->page_setup)
519 g_object_ref (page_setup);
520 if (export->page_setup)
521 g_object_unref (export->page_setup);
522 export->page_setup = page_setup;
525 static GtkPageSetup *
526 ev_print_operation_export_get_default_page_setup (EvPrintOperation *op)
528 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
530 return export->page_setup;
534 ev_print_operation_export_set_job_name (EvPrintOperation *op,
535 const gchar *job_name)
537 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
539 g_free (export->job_name);
540 export->job_name = g_strdup (job_name);
544 ev_print_operation_export_get_job_name (EvPrintOperation *op)
546 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
548 return export->job_name;
552 ev_print_operation_export_set_printer (EvPrintOperationExport *export,
555 if (printer == export->printer)
558 g_object_ref (printer);
560 g_object_unref (export->printer);
561 export->printer = printer;
565 find_range (EvPrintOperationExport *export)
569 range = &export->ranges[export->range];
571 if (export->inc < 0) {
572 export->start = range->end;
573 export->end = range->start - 1;
575 export->start = range->start;
576 export->end = range->end + 1;
581 clamp_ranges (EvPrintOperationExport *export)
583 gint num_of_correct_ranges = 0;
584 gint n_pages_to_print = 0;
586 gboolean null_flag = FALSE;
588 for (i = 0; i < export->n_ranges; i++) {
591 if ((export->ranges[i].start >= 0) &&
592 (export->ranges[i].start < export->n_pages) &&
593 (export->ranges[i].end >= 0) &&
594 (export->ranges[i].end < export->n_pages)) {
595 export->ranges[num_of_correct_ranges] = export->ranges[i];
596 num_of_correct_ranges++;
597 } else if ((export->ranges[i].start >= 0) &&
598 (export->ranges[i].start < export->n_pages) &&
599 (export->ranges[i].end >= export->n_pages)) {
600 export->ranges[i].end = export->n_pages - 1;
601 export->ranges[num_of_correct_ranges] = export->ranges[i];
602 num_of_correct_ranges++;
603 } else if ((export->ranges[i].end >= 0) &&
604 (export->ranges[i].end < export->n_pages) &&
605 (export->ranges[i].start < 0)) {
606 export->ranges[i].start = 0;
607 export->ranges[num_of_correct_ranges] = export->ranges[i];
608 num_of_correct_ranges++;
611 n_pages = export->ranges[i].end - export->ranges[i].start + 1;
612 if (export->page_set == GTK_PAGE_SET_ALL) {
613 n_pages_to_print += n_pages;
614 } else if (n_pages % 2 == 0) {
615 n_pages_to_print += n_pages / 2;
616 } else if (export->page_set == GTK_PAGE_SET_EVEN) {
617 if (n_pages==1 && export->ranges[i].start % 2 == 0)
620 n_pages_to_print += export->ranges[i].start % 2 == 0 ?
621 n_pages / 2 : (n_pages / 2) + 1;
622 } else if (export->page_set == GTK_PAGE_SET_ODD) {
623 if (n_pages==1 && export->ranges[i].start % 2 != 0)
626 n_pages_to_print += export->ranges[i].start % 2 == 0 ?
627 (n_pages / 2) + 1 : n_pages / 2;
631 if (null_flag && !n_pages_to_print) {
634 export->n_ranges = num_of_correct_ranges;
635 export->n_pages_to_print = n_pages_to_print;
641 get_first_and_last_page (EvPrintOperationExport *export,
646 gint first_page = G_MAXINT;
647 gint last_page = G_MININT;
648 gint max_page = export->n_pages - 1;
650 if (export->n_ranges == 0) {
657 for (i = 0; i < export->n_ranges; i++) {
658 if (export->ranges[i].start < first_page)
659 first_page = export->ranges[i].start;
660 if (export->ranges[i].end > last_page)
661 last_page = export->ranges[i].end;
664 *first = MAX (0, first_page);
665 *last = MIN (max_page, last_page);
669 export_print_inc_page (EvPrintOperationExport *export)
672 export->page += export->inc;
673 if (export->page == export->end) {
674 export->range += export->inc;
675 if (export->range == -1 || export->range == export->n_ranges) {
676 export->uncollated++;
677 if (export->uncollated == export->uncollated_copies)
680 export->range = export->inc < 0 ? export->n_ranges - 1 : 0;
683 export->page = export->start;
685 } while ((export->page_set == GTK_PAGE_SET_EVEN && (export->page / export->pages_per_sheet) % 2 == 0) ||
686 (export->page_set == GTK_PAGE_SET_ODD && (export->page / export->pages_per_sheet) % 2 == 1));
692 ev_print_operation_export_clear_temp_file (EvPrintOperationExport *export)
694 if (!export->temp_file)
697 g_unlink (export->temp_file);
698 g_free (export->temp_file);
699 export->temp_file = NULL;
703 ev_print_operation_export_run_next (EvPrintOperationExport *export)
705 EvPrintOperation *op = EV_PRINT_OPERATION (export);
706 EvPrintOperation *next;
707 EvDocument *document;
709 /* First pop the current job */
710 document = op->document;
711 ev_print_queue_pop (document);
713 next = ev_print_queue_peek (document);
715 ev_print_operation_export_begin (EV_PRINT_OPERATION_EXPORT (next));
719 gtk_print_job_finished (GtkPrintJob *print_job,
720 EvPrintOperationExport *export,
723 EvPrintOperation *op = EV_PRINT_OPERATION (export);
726 g_set_error_literal (&export->error,
728 GTK_PRINT_ERROR_GENERAL,
730 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
732 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
735 ev_print_operation_export_clear_temp_file (export);
736 g_object_unref (print_job);
738 ev_print_operation_export_run_next (export);
742 export_print_done (EvPrintOperationExport *export)
744 EvPrintOperation *op = EV_PRINT_OPERATION (export);
745 GtkPrintSettings *settings;
746 EvFileExporterCapabilities capabilities;
747 GError *error = NULL;
749 g_assert (export->temp_file != NULL);
751 /* Some printers take into account some print settings,
752 * and others don't. However we have exported the document
753 * to a ps or pdf file according to such print settings. So,
754 * we want to send the exported file to printer with those
755 * settings set to default values.
757 settings = gtk_print_settings_copy (export->print_settings);
758 capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
760 gtk_print_settings_set_page_ranges (settings, NULL, 0);
761 gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
762 if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
763 gtk_print_settings_set_n_copies (settings, 1);
764 if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
765 gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
766 if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
767 gtk_print_settings_set_scale (settings, 1.0);
768 if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
769 gtk_print_settings_set_collate (settings, FALSE);
770 if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
771 gtk_print_settings_set_reverse (settings, FALSE);
772 if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
773 gtk_print_settings_set_number_up (settings, 1);
774 gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
777 if (export->print_preview) {
781 gchar *print_settings_file = NULL;
783 key_file = g_key_file_new ();
785 gtk_print_settings_to_key_file (settings, key_file, NULL);
786 gtk_page_setup_to_key_file (export->page_setup, key_file, NULL);
787 g_key_file_set_string (key_file, "Print Job", "title", export->job_name);
789 data = g_key_file_to_data (key_file, &data_len, &error);
793 fd = g_file_open_tmp ("print-settingsXXXXXX", &print_settings_file, &error);
795 g_file_set_contents (print_settings_file, data, data_len, &error);
801 g_key_file_free (key_file);
807 gchar *quoted_filename;
808 gchar *quoted_settings_filename;
810 quoted_filename = g_shell_quote (export->temp_file);
811 quoted_settings_filename = g_shell_quote (print_settings_file);
812 cmd = g_strdup_printf ("evince-previewer --unlink-tempfile --print-settings %s %s",
813 quoted_settings_filename, quoted_filename);
815 g_shell_parse_argv (cmd, &argc, &argv, &error);
817 g_free (quoted_filename);
818 g_free (quoted_settings_filename);
822 gdk_spawn_on_screen (gtk_window_get_screen (export->parent_window),
833 if (print_settings_file)
834 g_unlink (print_settings_file);
835 g_free (print_settings_file);
837 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
838 /* temp_file will be deleted by the previewer */
840 ev_print_operation_export_run_next (export);
845 job = gtk_print_job_new (export->job_name,
849 gtk_print_job_set_source_file (job, export->temp_file, &error);
851 gtk_print_job_send (job,
852 (GtkPrintJobCompleteFunc)gtk_print_job_finished,
853 g_object_ref (export),
854 (GDestroyNotify)g_object_unref);
857 g_object_unref (settings);
860 g_set_error_literal (&export->error,
862 GTK_PRINT_ERROR_GENERAL,
864 g_error_free (error);
865 ev_print_operation_export_clear_temp_file (export);
866 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
868 ev_print_operation_export_run_next (export);
873 export_print_page_idle_finished (EvPrintOperationExport *export)
879 export_job_finished (EvJobExport *job,
880 EvPrintOperationExport *export)
882 EvPrintOperation *op = EV_PRINT_OPERATION (export);
884 if (export->pages_per_sheet == 1 || (export->total + export->blank) % export->pages_per_sheet == 0 ) {
885 ev_document_doc_mutex_lock ();
886 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
887 ev_document_doc_mutex_unlock ();
891 export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
892 (GSourceFunc)export_print_page,
894 (GDestroyNotify)export_print_page_idle_finished);
898 export_job_cancelled (EvJobExport *job,
899 EvPrintOperationExport *export)
901 export_cancel (export);
905 export_cancel (EvPrintOperationExport *export)
907 EvPrintOperation *op = EV_PRINT_OPERATION (export);
909 if (export->idle_id > 0)
910 g_source_remove (export->idle_id);
913 if (export->job_export) {
914 g_signal_handlers_disconnect_by_func (export->job_export,
917 g_signal_handlers_disconnect_by_func (export->job_export,
918 export_job_cancelled,
920 g_object_unref (export->job_export);
921 export->job_export = NULL;
924 if (export->fd != -1) {
929 ev_print_operation_export_clear_temp_file (export);
931 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
933 ev_print_operation_export_run_next (export);
937 update_progress (EvPrintOperationExport *export)
939 EvPrintOperation *op = EV_PRINT_OPERATION (export);
941 ev_print_operation_update_status (op, export->total,
942 export->n_pages_to_print,
943 export->total / (gdouble)export->n_pages_to_print);
947 export_print_page (EvPrintOperationExport *export)
949 EvPrintOperation *op = EV_PRINT_OPERATION (export);
951 if (!export->temp_file)
952 return FALSE; /* cancelled */
957 /* when printing multiple collated copies & multiple pages per sheet we want to
958 prevent the next copy bleeding into the last sheet of the previous one
959 we therefore check whether we've reached the last page in a document
960 if that is the case and the given sheet is not filled with pages,
961 we introduce a few blank pages to finish off the sheet
962 to make sure nothing goes wrong, the final condition ensures that
963 we're not at the end of a sheet, otherwise we'd introduce a blank sheet! */
965 if (export->collate == 1 && export->total > 1 && export->pages_per_sheet > 1 &&
966 (export->page + 1) % export->n_pages == 0 && (export->total - 1 + export->blank) % export->pages_per_sheet != 0) {
967 ev_document_doc_mutex_lock ();
968 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
969 /* keep track of how many blank pages have been added */
970 export->blank += export->pages_per_sheet - (export->total - 1 + export->blank) % export->pages_per_sheet;
971 ev_document_doc_mutex_unlock ();
975 if (export->collated == export->collated_copies) {
976 export->collated = 0;
977 if (!export_print_inc_page (export)) {
978 ev_document_doc_mutex_lock ();
979 ev_file_exporter_end (EV_FILE_EXPORTER (op->document));
980 ev_document_doc_mutex_unlock ();
984 update_progress (export);
985 export_print_done (export);
991 if (export->pages_per_sheet == 1 || (export->total + export->blank) % export->pages_per_sheet == 1) {
992 ev_document_doc_mutex_lock ();
993 ev_file_exporter_begin_page (EV_FILE_EXPORTER (op->document));
994 ev_document_doc_mutex_unlock ();
997 if (!export->job_export) {
998 export->job_export = ev_job_export_new (op->document);
999 g_signal_connect (export->job_export, "finished",
1000 G_CALLBACK (export_job_finished),
1002 g_signal_connect (export->job_export, "cancelled",
1003 G_CALLBACK (export_job_cancelled),
1007 ev_job_export_set_page (EV_JOB_EXPORT (export->job_export), export->page);
1008 ev_job_scheduler_push_job (export->job_export, EV_JOB_PRIORITY_NONE);
1010 update_progress (export);
1016 ev_print_operation_export_begin (EvPrintOperationExport *export)
1018 EvPrintOperation *op = EV_PRINT_OPERATION (export);
1020 if (!export->temp_file)
1021 return; /* cancelled */
1023 ev_document_doc_mutex_lock ();
1024 ev_file_exporter_begin (EV_FILE_EXPORTER (op->document), &export->fc);
1025 ev_document_doc_mutex_unlock ();
1027 export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
1028 (GSourceFunc)export_print_page,
1030 (GDestroyNotify)export_print_page_idle_finished);
1034 ev_print_operation_export_print_dialog_response_cb (GtkDialog *dialog,
1036 EvPrintOperationExport *export)
1038 GtkPrintPages print_pages;
1039 GtkPrintSettings *print_settings;
1040 GtkPageSetup *page_setup;
1041 GtkPrinter *printer;
1047 const gchar *file_format;
1049 GError *error = NULL;
1050 EvPrintOperation *op = EV_PRINT_OPERATION (export);
1052 if (response != GTK_RESPONSE_OK &&
1053 response != GTK_RESPONSE_APPLY) {
1054 gtk_widget_destroy (GTK_WIDGET (dialog));
1055 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
1060 export->print_preview = (response == GTK_RESPONSE_APPLY);
1062 printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog));
1063 ev_print_operation_export_set_printer (export, printer);
1065 print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog));
1066 ev_print_operation_export_set_print_settings (op, print_settings);
1068 page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog));
1069 ev_print_operation_export_set_default_page_setup (op, page_setup);
1071 if (!gtk_printer_accepts_ps (export->printer)) {
1072 gtk_widget_destroy (GTK_WIDGET (dialog));
1074 g_set_error_literal (&export->error,
1076 GTK_PRINT_ERROR_GENERAL,
1077 _("Printing is not supported on this printer."));
1078 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1083 file_format = gtk_print_settings_get (print_settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
1085 filename = g_strdup_printf ("evince_print.%s.XXXXXX", file_format);
1086 export->fd = g_file_open_tmp (filename, &export->temp_file, &error);
1088 if (export->fd <= -1) {
1089 gtk_widget_destroy (GTK_WIDGET (dialog));
1091 g_set_error_literal (&export->error,
1093 GTK_PRINT_ERROR_GENERAL,
1095 g_error_free (error);
1096 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1101 export->current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
1102 export->page_set = gtk_print_settings_get_page_set (print_settings);
1103 print_pages = gtk_print_settings_get_print_pages (print_settings);
1105 switch (print_pages) {
1106 case GTK_PRINT_PAGES_CURRENT:
1107 export->ranges = &export->one_range;
1109 export->ranges[0].start = export->current_page;
1110 export->ranges[0].end = export->current_page;
1111 export->n_ranges = 1;
1114 case GTK_PRINT_PAGES_RANGES: {
1117 export->ranges = gtk_print_settings_get_page_ranges (print_settings, &export->n_ranges);
1118 for (i = 0; i < export->n_ranges; i++)
1119 if (export->ranges[i].end == -1 || export->ranges[i].end >= export->n_pages)
1120 export->ranges[i].end = export->n_pages - 1;
1124 g_warning ("Unsupported print pages setting\n");
1125 case GTK_PRINT_PAGES_ALL:
1126 export->ranges = &export->one_range;
1128 export->ranges[0].start = 0;
1129 export->ranges[0].end = export->n_pages - 1;
1130 export->n_ranges = 1;
1135 if (export->n_ranges < 1 || !clamp_ranges (export)) {
1136 GtkWidget *message_dialog;
1138 message_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
1140 GTK_MESSAGE_WARNING,
1142 "%s", _("Invalid page selection"));
1143 gtk_window_set_title (GTK_WINDOW (message_dialog), _("Warning"));
1144 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message_dialog),
1145 "%s", _("Your print range selection does not include any page"));
1146 g_signal_connect (message_dialog, "response",
1147 G_CALLBACK (gtk_widget_destroy),
1149 gtk_widget_show (message_dialog);
1152 } else ev_print_operation_update_status (op, -1, -1, 0.0);
1154 width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
1155 height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
1156 scale = gtk_print_settings_get_scale (print_settings) * 0.01;
1162 export->pages_per_sheet = MAX (1, gtk_print_settings_get_number_up (print_settings));
1164 export->copies = gtk_print_settings_get_n_copies (print_settings);
1165 export->collate = gtk_print_settings_get_collate (print_settings);
1166 export->reverse = gtk_print_settings_get_reverse (print_settings);
1168 if (export->collate) {
1169 export->uncollated_copies = export->copies;
1170 export->collated_copies = 1;
1172 export->uncollated_copies = 1;
1173 export->collated_copies = export->copies;
1176 if (export->reverse) {
1177 export->range = export->n_ranges - 1;
1183 find_range (export);
1185 export->page = export->start - export->inc;
1186 export->collated = export->collated_copies - 1;
1188 get_first_and_last_page (export, &first_page, &last_page);
1191 export->fc.format = g_ascii_strcasecmp (file_format, "pdf") == 0 ?
1192 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1194 export->fc.format = gtk_printer_accepts_pdf (printer) ?
1195 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1197 export->fc.filename = export->temp_file;
1198 export->fc.first_page = MIN (first_page, last_page);
1199 export->fc.last_page = MAX (first_page, last_page);
1200 export->fc.paper_width = width;
1201 export->fc.paper_height = height;
1202 export->fc.duplex = FALSE;
1203 export->fc.pages_per_sheet = export->pages_per_sheet;
1205 if (ev_print_queue_is_empty (op->document))
1206 ev_print_operation_export_begin (export);
1208 ev_print_queue_push (op);
1210 g_signal_emit (op, signals[BEGIN_PRINT], 0);
1212 gtk_widget_destroy (GTK_WIDGET (dialog));
1216 ev_print_operation_export_run (EvPrintOperation *op,
1219 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1221 GtkPrintCapabilities capabilities;
1223 ev_print_queue_init ();
1225 export->parent_window = parent;
1226 export->error = NULL;
1228 dialog = gtk_print_unix_dialog_new (_("Print"), parent);
1229 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1231 capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
1232 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
1233 gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
1236 gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
1237 export->current_page);
1239 gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
1240 export->print_settings);
1242 if (export->page_setup)
1243 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1244 export->page_setup);
1246 g_signal_connect (dialog, "response",
1247 G_CALLBACK (ev_print_operation_export_print_dialog_response_cb),
1250 gtk_window_present (GTK_WINDOW (dialog));
1254 ev_print_operation_export_cancel (EvPrintOperation *op)
1256 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1258 if (export->job_export &&
1259 !ev_job_is_finished (export->job_export)) {
1260 ev_job_cancel (export->job_export);
1262 export_cancel (export);
1267 ev_print_operation_export_get_error (EvPrintOperation *op,
1270 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1272 g_propagate_error (error, export->error);
1273 export->error = NULL;
1277 ev_print_operation_export_finalize (GObject *object)
1279 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (object);
1281 if (export->idle_id > 0) {
1282 g_source_remove (export->idle_id);
1283 export->idle_id = 0;
1286 if (export->fd != -1) {
1291 if (export->ranges) {
1292 if (export->ranges != &export->one_range)
1293 g_free (export->ranges);
1294 export->ranges = NULL;
1295 export->n_ranges = 0;
1298 if (export->temp_file) {
1299 g_free (export->temp_file);
1300 export->temp_file = NULL;
1303 if (export->job_name) {
1304 g_free (export->job_name);
1305 export->job_name = NULL;
1308 if (export->job_export) {
1309 if (!ev_job_is_finished (export->job_export))
1310 ev_job_cancel (export->job_export);
1311 g_signal_handlers_disconnect_by_func (export->job_export,
1312 export_job_finished,
1314 g_signal_handlers_disconnect_by_func (export->job_export,
1315 export_job_cancelled,
1317 g_object_unref (export->job_export);
1318 export->job_export = NULL;
1321 if (export->error) {
1322 g_error_free (export->error);
1323 export->error = NULL;
1326 if (export->print_settings) {
1327 g_object_unref (export->print_settings);
1328 export->print_settings = NULL;
1331 if (export->page_setup) {
1332 g_object_unref (export->page_setup);
1333 export->page_setup = NULL;
1336 if (export->printer) {
1337 g_object_unref (export->printer);
1338 export->printer = NULL;
1341 (* G_OBJECT_CLASS (ev_print_operation_export_parent_class)->finalize) (object);
1345 ev_print_operation_export_init (EvPrintOperationExport *export)
1350 ev_print_operation_export_constructor (GType type,
1351 guint n_construct_properties,
1352 GObjectConstructParam *construct_params)
1355 EvPrintOperationExport *export;
1356 EvPrintOperation *op;
1358 object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,
1359 n_construct_properties,
1361 export = EV_PRINT_OPERATION_EXPORT (object);
1362 op = EV_PRINT_OPERATION (object);
1363 export->n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1369 ev_print_operation_export_class_init (EvPrintOperationExportClass *klass)
1371 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
1372 EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1374 ev_print_op_class->set_current_page = ev_print_operation_export_set_current_page;
1375 ev_print_op_class->set_print_settings = ev_print_operation_export_set_print_settings;
1376 ev_print_op_class->get_print_settings = ev_print_operation_export_get_print_settings;
1377 ev_print_op_class->set_default_page_setup = ev_print_operation_export_set_default_page_setup;
1378 ev_print_op_class->get_default_page_setup = ev_print_operation_export_get_default_page_setup;
1379 ev_print_op_class->set_job_name = ev_print_operation_export_set_job_name;
1380 ev_print_op_class->get_job_name = ev_print_operation_export_get_job_name;
1381 ev_print_op_class->run = ev_print_operation_export_run;
1382 ev_print_op_class->cancel = ev_print_operation_export_cancel;
1383 ev_print_op_class->get_error = ev_print_operation_export_get_error;
1385 g_object_class->constructor = ev_print_operation_export_constructor;
1386 g_object_class->finalize = ev_print_operation_export_finalize;
1389 #endif /* GTKUNIXPRINT_ENABLED */
1391 #if GTK_CHECK_VERSION (2, 17, 1)
1392 /* Print to cairo interface */
1393 #define EV_TYPE_PRINT_OPERATION_PRINT (ev_print_operation_print_get_type())
1394 #define EV_PRINT_OPERATION_PRINT(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PRINT_OPERATION_PRINT, EvPrintOperationPrint))
1395 #define EV_PRINT_OPERATION_PRINT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PRINT_OPERATION_PRINT, EvPrintOperationPrintClass))
1396 #define EV_IS_PRINT_OPERATION_PRINT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PRINT_OPERATION_PRINT))
1398 typedef struct _EvPrintOperationPrint EvPrintOperationPrint;
1399 typedef struct _EvPrintOperationPrintClass EvPrintOperationPrintClass;
1401 static GType ev_print_operation_print_get_type (void) G_GNUC_CONST;
1403 struct _EvPrintOperationPrint {
1404 EvPrintOperation parent;
1406 GtkPrintOperation *op;
1411 struct _EvPrintOperationPrintClass {
1412 EvPrintOperationClass parent_class;
1415 G_DEFINE_TYPE (EvPrintOperationPrint, ev_print_operation_print, EV_TYPE_PRINT_OPERATION)
1418 ev_print_operation_print_set_current_page (EvPrintOperation *op,
1421 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1423 gtk_print_operation_set_current_page (print->op, current_page);
1427 ev_print_operation_print_set_print_settings (EvPrintOperation *op,
1428 GtkPrintSettings *print_settings)
1430 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1432 gtk_print_operation_set_print_settings (print->op, print_settings);
1435 static GtkPrintSettings *
1436 ev_print_operation_print_get_print_settings (EvPrintOperation *op)
1438 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1440 return gtk_print_operation_get_print_settings (print->op);
1444 ev_print_operation_print_set_default_page_setup (EvPrintOperation *op,
1445 GtkPageSetup *page_setup)
1447 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1449 gtk_print_operation_set_default_page_setup (print->op, page_setup);
1452 static GtkPageSetup *
1453 ev_print_operation_print_get_default_page_setup (EvPrintOperation *op)
1455 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1457 return gtk_print_operation_get_default_page_setup (print->op);
1461 ev_print_operation_print_set_job_name (EvPrintOperation *op,
1462 const gchar *job_name)
1464 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1466 g_free (print->job_name);
1467 print->job_name = g_strdup (job_name);
1469 gtk_print_operation_set_job_name (print->op, print->job_name);
1472 static const gchar *
1473 ev_print_operation_print_get_job_name (EvPrintOperation *op)
1475 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1477 if (!print->job_name) {
1480 g_object_get (print->op, "job_name", &name, NULL);
1481 print->job_name = name;
1484 return print->job_name;
1488 ev_print_operation_print_run (EvPrintOperation *op,
1491 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1493 gtk_print_operation_run (print->op,
1494 GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
1499 ev_print_operation_print_cancel (EvPrintOperation *op)
1501 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1503 gtk_print_operation_cancel (print->op);
1507 ev_print_operation_print_get_error (EvPrintOperation *op,
1510 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1512 gtk_print_operation_get_error (print->op, error);
1516 ev_print_operation_print_begin_print (EvPrintOperationPrint *print,
1517 GtkPrintContext *context)
1519 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1522 n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1523 gtk_print_operation_set_n_pages (print->op, n_pages);
1525 /* FIXME: gtk_print should provide the progress */
1526 ev_print_operation_update_status (op, -1, n_pages, 0);
1528 g_signal_emit (op, signals[BEGIN_PRINT], 0);
1532 ev_print_operation_print_done (EvPrintOperationPrint *print,
1533 GtkPrintOperationResult result)
1535 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1537 /* FIXME: gtk_print should provide the progress */
1538 ev_print_operation_update_status (op, 0, 1, 1.0);
1540 g_signal_emit (op, signals[DONE], 0, result);
1544 print_job_finished (EvJobPrint *job,
1545 EvPrintOperationPrint *print)
1547 gtk_print_operation_draw_page_finish (print->op);
1548 ev_job_print_set_cairo (job, NULL);
1552 print_job_cancelled (EvJobPrint *job,
1553 EvPrintOperationPrint *print)
1555 gtk_print_operation_cancel (print->op);
1559 ev_print_operation_print_draw_page (EvPrintOperationPrint *print,
1560 GtkPrintContext *context,
1563 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1565 gdouble cr_width, cr_height;
1568 gtk_print_operation_set_defer_drawing (print->op);
1570 if (!print->job_print) {
1571 print->job_print = ev_job_print_new (op->document);
1572 g_signal_connect (G_OBJECT (print->job_print), "finished",
1573 G_CALLBACK (print_job_finished),
1575 g_signal_connect (G_OBJECT (print->job_print), "cancelled",
1576 G_CALLBACK (print_job_cancelled),
1580 ev_job_print_set_page (EV_JOB_PRINT (print->job_print), page);
1582 cr = gtk_print_context_get_cairo_context (context);
1583 cr_width = gtk_print_context_get_width (context);
1584 cr_height = gtk_print_context_get_height (context);
1585 ev_page_cache_get_size (ev_page_cache_get (op->document),
1588 cairo_scale (cr, cr_width / (gdouble)width, cr_height / (gdouble)height);
1590 ev_job_print_set_cairo (EV_JOB_PRINT (print->job_print), cr);
1591 ev_job_scheduler_push_job (print->job_print, EV_JOB_PRIORITY_NONE);
1595 ev_print_operation_print_finalize (GObject *object)
1597 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (object);
1600 g_object_unref (print->op);
1604 if (print->job_name) {
1605 g_free (print->job_name);
1606 print->job_name = NULL;
1609 if (print->job_print) {
1610 if (!ev_job_is_finished (print->job_print))
1611 ev_job_cancel (print->job_print);
1612 g_signal_handlers_disconnect_by_func (print->job_print,
1615 g_signal_handlers_disconnect_by_func (print->job_print,
1616 print_job_cancelled,
1618 g_object_unref (print->job_print);
1619 print->job_print = NULL;
1622 (* G_OBJECT_CLASS (ev_print_operation_print_parent_class)->finalize) (object);
1626 ev_print_operation_print_init (EvPrintOperationPrint *print)
1628 print->op = gtk_print_operation_new ();
1629 g_signal_connect_swapped (print->op, "begin_print",
1630 G_CALLBACK (ev_print_operation_print_begin_print),
1632 g_signal_connect_swapped (print->op, "done",
1633 G_CALLBACK (ev_print_operation_print_done),
1635 g_signal_connect_swapped (print->op, "draw_page",
1636 G_CALLBACK (ev_print_operation_print_draw_page),
1638 gtk_print_operation_set_allow_async (print->op, TRUE);
1642 ev_print_operation_print_class_init (EvPrintOperationPrintClass *klass)
1644 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
1645 EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1647 ev_print_op_class->set_current_page = ev_print_operation_print_set_current_page;
1648 ev_print_op_class->set_print_settings = ev_print_operation_print_set_print_settings;
1649 ev_print_op_class->get_print_settings = ev_print_operation_print_get_print_settings;
1650 ev_print_op_class->set_default_page_setup = ev_print_operation_print_set_default_page_setup;
1651 ev_print_op_class->get_default_page_setup = ev_print_operation_print_get_default_page_setup;
1652 ev_print_op_class->set_job_name = ev_print_operation_print_set_job_name;
1653 ev_print_op_class->get_job_name = ev_print_operation_print_get_job_name;
1654 ev_print_op_class->run = ev_print_operation_print_run;
1655 ev_print_op_class->cancel = ev_print_operation_print_cancel;
1656 ev_print_op_class->get_error = ev_print_operation_print_get_error;
1658 g_object_class->finalize = ev_print_operation_print_finalize;
1660 #endif /* GTK_CHECK_VERSION (2, 17, 1) */
1662 gboolean ev_print_operation_exists_for_document (EvDocument *document)
1664 #if GTKUNIXPRINT_ENABLED
1665 #if GTK_CHECK_VERSION (2, 17, 1)
1666 return (EV_IS_FILE_EXPORTER(document) || EV_IS_DOCUMENT_PRINT(document));
1668 return EV_IS_FILE_EXPORTER(document);
1670 #else /* ! GTKUNIXPRINT_ENABLED */
1671 #if GTK_CHECK_VERSION (2, 17, 1)
1672 return EV_IS_DOCUMENT_PRINT(document);
1676 #endif /* GTKUNIXPRINT_ENABLED */
1679 /* Factory method */
1681 ev_print_operation_new (EvDocument *document)
1683 EvPrintOperation *op = NULL;
1685 g_return_val_if_fail (ev_print_operation_exists_for_document (document), NULL);
1687 #if GTK_CHECK_VERSION (2, 17, 1)
1688 if (EV_IS_DOCUMENT_PRINT (document))
1689 op = EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_PRINT,
1690 "document", document, NULL));
1693 #if GTKUNIXPRINT_ENABLED
1694 op = EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_EXPORT,
1695 "document", document, NULL));