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);
1190 export->fc.format = file_format && g_ascii_strcasecmp (file_format, "pdf") == 0 ?
1191 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1192 export->fc.filename = export->temp_file;
1193 export->fc.first_page = MIN (first_page, last_page);
1194 export->fc.last_page = MAX (first_page, last_page);
1195 export->fc.paper_width = width;
1196 export->fc.paper_height = height;
1197 export->fc.duplex = FALSE;
1198 export->fc.pages_per_sheet = export->pages_per_sheet;
1200 if (ev_print_queue_is_empty (op->document))
1201 ev_print_operation_export_begin (export);
1203 ev_print_queue_push (op);
1205 g_signal_emit (op, signals[BEGIN_PRINT], 0);
1207 gtk_widget_destroy (GTK_WIDGET (dialog));
1211 ev_print_operation_export_run (EvPrintOperation *op,
1214 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1216 GtkPrintCapabilities capabilities;
1218 ev_print_queue_init ();
1220 export->parent_window = parent;
1221 export->error = NULL;
1223 dialog = gtk_print_unix_dialog_new (_("Print"), parent);
1224 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1226 capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
1227 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
1228 gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
1231 gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
1232 export->current_page);
1234 gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
1235 export->print_settings);
1237 if (export->page_setup)
1238 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1239 export->page_setup);
1241 g_signal_connect (dialog, "response",
1242 G_CALLBACK (ev_print_operation_export_print_dialog_response_cb),
1245 gtk_window_present (GTK_WINDOW (dialog));
1249 ev_print_operation_export_cancel (EvPrintOperation *op)
1251 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1253 if (export->job_export &&
1254 !ev_job_is_finished (export->job_export)) {
1255 ev_job_cancel (export->job_export);
1257 export_cancel (export);
1262 ev_print_operation_export_get_error (EvPrintOperation *op,
1265 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1267 g_propagate_error (error, export->error);
1268 export->error = NULL;
1272 ev_print_operation_export_finalize (GObject *object)
1274 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (object);
1276 if (export->idle_id > 0) {
1277 g_source_remove (export->idle_id);
1278 export->idle_id = 0;
1281 if (export->fd != -1) {
1286 if (export->ranges) {
1287 if (export->ranges != &export->one_range)
1288 g_free (export->ranges);
1289 export->ranges = NULL;
1290 export->n_ranges = 0;
1293 if (export->temp_file) {
1294 g_free (export->temp_file);
1295 export->temp_file = NULL;
1298 if (export->job_name) {
1299 g_free (export->job_name);
1300 export->job_name = NULL;
1303 if (export->job_export) {
1304 if (!ev_job_is_finished (export->job_export))
1305 ev_job_cancel (export->job_export);
1306 g_signal_handlers_disconnect_by_func (export->job_export,
1307 export_job_finished,
1309 g_signal_handlers_disconnect_by_func (export->job_export,
1310 export_job_cancelled,
1312 g_object_unref (export->job_export);
1313 export->job_export = NULL;
1316 if (export->error) {
1317 g_error_free (export->error);
1318 export->error = NULL;
1321 if (export->print_settings) {
1322 g_object_unref (export->print_settings);
1323 export->print_settings = NULL;
1326 if (export->page_setup) {
1327 g_object_unref (export->page_setup);
1328 export->page_setup = NULL;
1331 if (export->printer) {
1332 g_object_unref (export->printer);
1333 export->printer = NULL;
1336 (* G_OBJECT_CLASS (ev_print_operation_export_parent_class)->finalize) (object);
1340 ev_print_operation_export_init (EvPrintOperationExport *export)
1345 ev_print_operation_export_constructor (GType type,
1346 guint n_construct_properties,
1347 GObjectConstructParam *construct_params)
1350 EvPrintOperationExport *export;
1351 EvPrintOperation *op;
1353 object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,
1354 n_construct_properties,
1356 export = EV_PRINT_OPERATION_EXPORT (object);
1357 op = EV_PRINT_OPERATION (object);
1358 export->n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1364 ev_print_operation_export_class_init (EvPrintOperationExportClass *klass)
1366 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
1367 EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1369 ev_print_op_class->set_current_page = ev_print_operation_export_set_current_page;
1370 ev_print_op_class->set_print_settings = ev_print_operation_export_set_print_settings;
1371 ev_print_op_class->get_print_settings = ev_print_operation_export_get_print_settings;
1372 ev_print_op_class->set_default_page_setup = ev_print_operation_export_set_default_page_setup;
1373 ev_print_op_class->get_default_page_setup = ev_print_operation_export_get_default_page_setup;
1374 ev_print_op_class->set_job_name = ev_print_operation_export_set_job_name;
1375 ev_print_op_class->get_job_name = ev_print_operation_export_get_job_name;
1376 ev_print_op_class->run = ev_print_operation_export_run;
1377 ev_print_op_class->cancel = ev_print_operation_export_cancel;
1378 ev_print_op_class->get_error = ev_print_operation_export_get_error;
1380 g_object_class->constructor = ev_print_operation_export_constructor;
1381 g_object_class->finalize = ev_print_operation_export_finalize;
1384 #endif /* GTKUNIXPRINT_ENABLED */
1386 #if GTK_CHECK_VERSION (2, 17, 1)
1387 /* Print to cairo interface */
1388 #define EV_TYPE_PRINT_OPERATION_PRINT (ev_print_operation_print_get_type())
1389 #define EV_PRINT_OPERATION_PRINT(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PRINT_OPERATION_PRINT, EvPrintOperationPrint))
1390 #define EV_PRINT_OPERATION_PRINT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PRINT_OPERATION_PRINT, EvPrintOperationPrintClass))
1391 #define EV_IS_PRINT_OPERATION_PRINT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PRINT_OPERATION_PRINT))
1393 typedef struct _EvPrintOperationPrint EvPrintOperationPrint;
1394 typedef struct _EvPrintOperationPrintClass EvPrintOperationPrintClass;
1396 static GType ev_print_operation_print_get_type (void) G_GNUC_CONST;
1398 struct _EvPrintOperationPrint {
1399 EvPrintOperation parent;
1401 GtkPrintOperation *op;
1406 struct _EvPrintOperationPrintClass {
1407 EvPrintOperationClass parent_class;
1410 G_DEFINE_TYPE (EvPrintOperationPrint, ev_print_operation_print, EV_TYPE_PRINT_OPERATION)
1413 ev_print_operation_print_set_current_page (EvPrintOperation *op,
1416 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1418 gtk_print_operation_set_current_page (print->op, current_page);
1422 ev_print_operation_print_set_print_settings (EvPrintOperation *op,
1423 GtkPrintSettings *print_settings)
1425 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1427 gtk_print_operation_set_print_settings (print->op, print_settings);
1430 static GtkPrintSettings *
1431 ev_print_operation_print_get_print_settings (EvPrintOperation *op)
1433 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1435 return gtk_print_operation_get_print_settings (print->op);
1439 ev_print_operation_print_set_default_page_setup (EvPrintOperation *op,
1440 GtkPageSetup *page_setup)
1442 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1444 gtk_print_operation_set_default_page_setup (print->op, page_setup);
1447 static GtkPageSetup *
1448 ev_print_operation_print_get_default_page_setup (EvPrintOperation *op)
1450 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1452 return gtk_print_operation_get_default_page_setup (print->op);
1456 ev_print_operation_print_set_job_name (EvPrintOperation *op,
1457 const gchar *job_name)
1459 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1461 g_free (print->job_name);
1462 print->job_name = g_strdup (job_name);
1464 gtk_print_operation_set_job_name (print->op, print->job_name);
1467 static const gchar *
1468 ev_print_operation_print_get_job_name (EvPrintOperation *op)
1470 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1472 if (!print->job_name) {
1475 g_object_get (print->op, "job_name", &name, NULL);
1476 print->job_name = name;
1479 return print->job_name;
1483 ev_print_operation_print_run (EvPrintOperation *op,
1486 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1488 gtk_print_operation_run (print->op,
1489 GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
1494 ev_print_operation_print_cancel (EvPrintOperation *op)
1496 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1498 gtk_print_operation_cancel (print->op);
1502 ev_print_operation_print_get_error (EvPrintOperation *op,
1505 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1507 gtk_print_operation_get_error (print->op, error);
1511 ev_print_operation_print_begin_print (EvPrintOperationPrint *print,
1512 GtkPrintContext *context)
1514 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1517 n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1518 gtk_print_operation_set_n_pages (print->op, n_pages);
1520 /* FIXME: gtk_print should provide the progress */
1521 ev_print_operation_update_status (op, -1, n_pages, 0);
1523 g_signal_emit (op, signals[BEGIN_PRINT], 0);
1527 ev_print_operation_print_done (EvPrintOperationPrint *print,
1528 GtkPrintOperationResult result)
1530 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1532 /* FIXME: gtk_print should provide the progress */
1533 ev_print_operation_update_status (op, 0, 1, 1.0);
1535 g_signal_emit (op, signals[DONE], 0, result);
1539 print_job_finished (EvJobPrint *job,
1540 EvPrintOperationPrint *print)
1542 gtk_print_operation_draw_page_finish (print->op);
1543 ev_job_print_set_cairo (job, NULL);
1547 print_job_cancelled (EvJobPrint *job,
1548 EvPrintOperationPrint *print)
1550 gtk_print_operation_cancel (print->op);
1554 ev_print_operation_print_draw_page (EvPrintOperationPrint *print,
1555 GtkPrintContext *context,
1558 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1560 gdouble cr_width, cr_height;
1563 gtk_print_operation_set_defer_drawing (print->op);
1565 if (!print->job_print) {
1566 print->job_print = ev_job_print_new (op->document);
1567 g_signal_connect (G_OBJECT (print->job_print), "finished",
1568 G_CALLBACK (print_job_finished),
1570 g_signal_connect (G_OBJECT (print->job_print), "cancelled",
1571 G_CALLBACK (print_job_cancelled),
1575 ev_job_print_set_page (EV_JOB_PRINT (print->job_print), page);
1577 cr = gtk_print_context_get_cairo_context (context);
1578 cr_width = gtk_print_context_get_width (context);
1579 cr_height = gtk_print_context_get_height (context);
1580 ev_page_cache_get_size (ev_page_cache_get (op->document),
1583 cairo_scale (cr, cr_width / (gdouble)width, cr_height / (gdouble)height);
1585 ev_job_print_set_cairo (EV_JOB_PRINT (print->job_print), cr);
1586 ev_job_scheduler_push_job (print->job_print, EV_JOB_PRIORITY_NONE);
1590 ev_print_operation_print_finalize (GObject *object)
1592 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (object);
1595 g_object_unref (print->op);
1599 if (print->job_name) {
1600 g_free (print->job_name);
1601 print->job_name = NULL;
1604 if (print->job_print) {
1605 if (!ev_job_is_finished (print->job_print))
1606 ev_job_cancel (print->job_print);
1607 g_signal_handlers_disconnect_by_func (print->job_print,
1610 g_signal_handlers_disconnect_by_func (print->job_print,
1611 print_job_cancelled,
1613 g_object_unref (print->job_print);
1614 print->job_print = NULL;
1617 (* G_OBJECT_CLASS (ev_print_operation_print_parent_class)->finalize) (object);
1621 ev_print_operation_print_init (EvPrintOperationPrint *print)
1623 print->op = gtk_print_operation_new ();
1624 g_signal_connect_swapped (print->op, "begin_print",
1625 G_CALLBACK (ev_print_operation_print_begin_print),
1627 g_signal_connect_swapped (print->op, "done",
1628 G_CALLBACK (ev_print_operation_print_done),
1630 g_signal_connect_swapped (print->op, "draw_page",
1631 G_CALLBACK (ev_print_operation_print_draw_page),
1633 gtk_print_operation_set_allow_async (print->op, TRUE);
1637 ev_print_operation_print_class_init (EvPrintOperationPrintClass *klass)
1639 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
1640 EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1642 ev_print_op_class->set_current_page = ev_print_operation_print_set_current_page;
1643 ev_print_op_class->set_print_settings = ev_print_operation_print_set_print_settings;
1644 ev_print_op_class->get_print_settings = ev_print_operation_print_get_print_settings;
1645 ev_print_op_class->set_default_page_setup = ev_print_operation_print_set_default_page_setup;
1646 ev_print_op_class->get_default_page_setup = ev_print_operation_print_get_default_page_setup;
1647 ev_print_op_class->set_job_name = ev_print_operation_print_set_job_name;
1648 ev_print_op_class->get_job_name = ev_print_operation_print_get_job_name;
1649 ev_print_op_class->run = ev_print_operation_print_run;
1650 ev_print_op_class->cancel = ev_print_operation_print_cancel;
1651 ev_print_op_class->get_error = ev_print_operation_print_get_error;
1653 g_object_class->finalize = ev_print_operation_print_finalize;
1655 #endif /* GTK_CHECK_VERSION (2, 17, 1) */
1657 gboolean ev_print_operation_exists_for_document (EvDocument *document)
1659 #if GTKUNIXPRINT_ENABLED
1660 #if GTK_CHECK_VERSION (2, 17, 1)
1661 return (EV_IS_FILE_EXPORTER(document) || EV_IS_DOCUMENT_PRINT(document));
1663 return EV_IS_FILE_EXPORTER(document);
1665 #else /* ! GTKUNIXPRINT_ENABLED */
1666 #if GTK_CHECK_VERSION (2, 17, 1)
1667 return EV_IS_DOCUMENT_PRINT(document);
1671 #endif /* GTKUNIXPRINT_ENABLED */
1674 /* Factory method */
1676 ev_print_operation_new (EvDocument *document)
1678 EvPrintOperation *op = NULL;
1680 g_return_val_if_fail (ev_print_operation_exists_for_document (document), NULL);
1682 #if GTK_CHECK_VERSION (2, 17, 1)
1683 if (EV_IS_DOCUMENT_PRINT (document))
1684 op = EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_PRINT,
1685 "document", document, NULL));
1688 #if GTKUNIXPRINT_ENABLED
1689 op = EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_EXPORT,
1690 "document", document, NULL));