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-file-exporter.h"
33 #include "ev-job-scheduler.h"
34 #include "ev-application.h"
35 #include "ev-file-helpers.h"
36 #include "ev-document-print.h"
50 static guint signals[LAST_SIGNAL] = { 0 };
52 struct _EvPrintOperation {
62 struct _EvPrintOperationClass {
63 GObjectClass parent_class;
65 void (* set_current_page) (EvPrintOperation *op,
67 void (* set_print_settings) (EvPrintOperation *op,
68 GtkPrintSettings *print_settings);
69 GtkPrintSettings *(* get_print_settings) (EvPrintOperation *op);
70 void (* set_default_page_setup) (EvPrintOperation *op,
71 GtkPageSetup *page_setup);
72 GtkPageSetup *(* get_default_page_setup) (EvPrintOperation *op);
73 void (* set_job_name) (EvPrintOperation *op,
74 const gchar *job_name);
75 const gchar *(* get_job_name) (EvPrintOperation *op);
76 void (* run) (EvPrintOperation *op,
78 void (* cancel) (EvPrintOperation *op);
79 void (* get_error) (EvPrintOperation *op,
81 void (* set_embed_page_setup) (EvPrintOperation *op,
83 gboolean (* get_embed_page_setup) (EvPrintOperation *op);
86 void (* done) (EvPrintOperation *op,
87 GtkPrintOperationResult result);
88 void (* begin_print) (EvPrintOperation *op);
89 void (* status_changed) (EvPrintOperation *op);
92 G_DEFINE_ABSTRACT_TYPE (EvPrintOperation, ev_print_operation, G_TYPE_OBJECT)
95 ev_print_operation_finalize (GObject *object)
97 EvPrintOperation *op = EV_PRINT_OPERATION (object);
100 g_object_unref (op->document);
109 (* G_OBJECT_CLASS (ev_print_operation_parent_class)->finalize) (object);
113 ev_print_operation_set_property (GObject *object,
118 EvPrintOperation *op = EV_PRINT_OPERATION (object);
122 op->document = g_value_dup_object (value);
125 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
130 ev_print_operation_init (EvPrintOperation *op)
135 ev_print_operation_class_init (EvPrintOperationClass *klass)
137 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
139 g_object_class->set_property = ev_print_operation_set_property;
140 g_object_class->finalize = ev_print_operation_finalize;
142 g_object_class_install_property (g_object_class,
144 g_param_spec_object ("document",
146 "The document to print",
149 G_PARAM_CONSTRUCT_ONLY));
151 g_signal_new ("done",
152 G_TYPE_FROM_CLASS (g_object_class),
154 G_STRUCT_OFFSET (EvPrintOperationClass, done),
156 g_cclosure_marshal_VOID__ENUM,
158 GTK_TYPE_PRINT_OPERATION_RESULT);
159 signals[BEGIN_PRINT] =
160 g_signal_new ("begin_print",
161 G_TYPE_FROM_CLASS (g_object_class),
163 G_STRUCT_OFFSET (EvPrintOperationClass, begin_print),
165 g_cclosure_marshal_VOID__VOID,
167 signals[STATUS_CHANGED] =
168 g_signal_new ("status_changed",
169 G_TYPE_FROM_CLASS (g_object_class),
171 G_STRUCT_OFFSET (EvPrintOperationClass, status_changed),
173 g_cclosure_marshal_VOID__VOID,
179 ev_print_operation_set_current_page (EvPrintOperation *op,
182 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
184 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
185 g_return_if_fail (current_page >= 0);
187 class->set_current_page (op, current_page);
191 ev_print_operation_set_print_settings (EvPrintOperation *op,
192 GtkPrintSettings *print_settings)
194 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
196 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
197 g_return_if_fail (GTK_IS_PRINT_SETTINGS (print_settings));
199 class->set_print_settings (op, print_settings);
203 ev_print_operation_get_print_settings (EvPrintOperation *op)
205 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
207 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
209 return class->get_print_settings (op);
213 ev_print_operation_set_default_page_setup (EvPrintOperation *op,
214 GtkPageSetup *page_setup)
216 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
218 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
219 g_return_if_fail (GTK_IS_PAGE_SETUP (page_setup));
221 class->set_default_page_setup (op, page_setup);
225 ev_print_operation_get_default_page_setup (EvPrintOperation *op)
227 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
229 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
231 return class->get_default_page_setup (op);
235 ev_print_operation_set_job_name (EvPrintOperation *op,
236 const gchar *job_name)
238 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
240 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
241 g_return_if_fail (job_name != NULL);
243 class->set_job_name (op, job_name);
247 ev_print_operation_get_job_name (EvPrintOperation *op)
249 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
251 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
253 return class->get_job_name (op);
257 ev_print_operation_run (EvPrintOperation *op,
260 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
262 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
264 class->run (op, parent);
268 ev_print_operation_cancel (EvPrintOperation *op)
270 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
272 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
278 ev_print_operation_get_error (EvPrintOperation *op,
281 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
283 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
285 class->get_error (op, error);
289 ev_print_operation_set_embed_page_setup (EvPrintOperation *op,
292 #if GTK_CHECK_VERSION (2, 17, 4)
293 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
295 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
297 class->set_embed_page_setup (op, embed);
302 ev_print_operation_get_embed_page_setup (EvPrintOperation *op)
304 #if GTK_CHECK_VERSION (2, 17, 4)
305 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
307 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), FALSE);
309 return class->get_embed_page_setup (op);
316 ev_print_operation_get_status (EvPrintOperation *op)
318 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
320 return op->status ? op->status : "";
324 ev_print_operation_get_progress (EvPrintOperation *op)
326 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), 0.0);
331 #if GTK_CHECK_VERSION (2, 17, 1) | GTKUNIXPRINT_ENABLED
333 ev_print_operation_update_status (EvPrintOperation *op,
338 if (op->status && op->progress == progress)
345 op->status = g_strdup (_("Preparing to print ..."));
346 } else if (page > n_pages) {
347 op->status = g_strdup (_("Finishing..."));
349 op->status = g_strdup_printf (_("Printing page %d of %d..."),
353 op->progress = MIN (1.0, progress);
355 g_signal_emit (op, signals[STATUS_CHANGED], 0);
359 #if GTKUNIXPRINT_ENABLED
361 /* Export interface */
362 #define EV_TYPE_PRINT_OPERATION_EXPORT (ev_print_operation_export_get_type())
363 #define EV_PRINT_OPERATION_EXPORT(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PRINT_OPERATION_EXPORT, EvPrintOperationExport))
364 #define EV_PRINT_OPERATION_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PRINT_OPERATION_EXPORT, EvPrintOperationExportClass))
365 #define EV_IS_PRINT_OPERATION_EXPORT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PRINT_OPERATION_EXPORT))
367 typedef struct _EvPrintOperationExport EvPrintOperationExport;
368 typedef struct _EvPrintOperationExportClass EvPrintOperationExportClass;
370 static GType ev_print_operation_export_get_type (void) G_GNUC_CONST;
372 static void ev_print_operation_export_begin (EvPrintOperationExport *export);
373 static gboolean export_print_page (EvPrintOperationExport *export);
374 static void export_cancel (EvPrintOperationExport *export);
376 struct _EvPrintOperationExport {
377 EvPrintOperation parent;
379 GtkWindow *parent_window;
383 gboolean print_preview;
387 GtkPageSetup *page_setup;
388 GtkPrintSettings *print_settings;
393 gint pages_per_sheet;
397 gboolean embed_page_setup;
402 EvFileExporterContext fc;
403 gint n_pages_to_print;
404 gint uncollated_copies;
405 gint collated_copies;
406 gint uncollated, collated, total;
408 gint sheet, page_count;
410 gint range, n_ranges;
411 GtkPageRange *ranges;
412 GtkPageRange one_range;
414 gint page, start, end, inc;
417 struct _EvPrintOperationExportClass {
418 EvPrintOperationClass parent_class;
421 G_DEFINE_TYPE (EvPrintOperationExport, ev_print_operation_export, EV_TYPE_PRINT_OPERATION)
423 /* Internal print queue */
424 static GHashTable *print_queue = NULL;
427 queue_free (GQueue *queue)
429 g_queue_foreach (queue, (GFunc)g_object_unref, NULL);
430 g_queue_free (queue);
434 ev_print_queue_init (void)
436 if (G_UNLIKELY (print_queue == NULL)) {
437 print_queue = g_hash_table_new_full (g_direct_hash,
440 (GDestroyNotify)queue_free);
445 remove_document_queue (gpointer data,
449 g_hash_table_remove (print_queue, document);
453 ev_print_queue_is_empty (EvDocument *document)
457 queue = g_hash_table_lookup (print_queue, document);
458 return (!queue || g_queue_is_empty (queue));
462 ev_print_queue_push (EvPrintOperation *op)
466 queue = g_hash_table_lookup (print_queue, op->document);
468 queue = g_queue_new ();
469 g_hash_table_insert (print_queue,
472 g_object_weak_ref (G_OBJECT (op->document),
473 (GWeakNotify)remove_document_queue,
477 g_queue_push_head (queue, g_object_ref (op));
480 static EvPrintOperation *
481 ev_print_queue_pop (EvDocument *document)
483 EvPrintOperation *op;
486 queue = g_hash_table_lookup (print_queue, document);
487 if (!queue || g_queue_is_empty (queue))
490 op = g_queue_pop_tail (queue);
496 static EvPrintOperation *
497 ev_print_queue_peek (EvDocument *document)
501 queue = g_hash_table_lookup (print_queue, document);
502 if (!queue || g_queue_is_empty (queue))
505 return g_queue_peek_tail (queue);
509 ev_print_operation_export_set_current_page (EvPrintOperation *op,
512 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
514 g_return_if_fail (current_page < export->n_pages);
516 export->current_page = current_page;
520 ev_print_operation_export_set_print_settings (EvPrintOperation *op,
521 GtkPrintSettings *print_settings)
523 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
525 if (print_settings == export->print_settings)
528 g_object_ref (print_settings);
529 if (export->print_settings)
530 g_object_unref (export->print_settings);
531 export->print_settings = print_settings;
534 static GtkPrintSettings *
535 ev_print_operation_export_get_print_settings (EvPrintOperation *op)
537 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
539 return export->print_settings;
543 ev_print_operation_export_set_default_page_setup (EvPrintOperation *op,
544 GtkPageSetup *page_setup)
546 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
548 if (page_setup == export->page_setup)
551 g_object_ref (page_setup);
552 if (export->page_setup)
553 g_object_unref (export->page_setup);
554 export->page_setup = page_setup;
557 static GtkPageSetup *
558 ev_print_operation_export_get_default_page_setup (EvPrintOperation *op)
560 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
562 return export->page_setup;
566 ev_print_operation_export_set_job_name (EvPrintOperation *op,
567 const gchar *job_name)
569 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
571 g_free (export->job_name);
572 export->job_name = g_strdup (job_name);
576 ev_print_operation_export_get_job_name (EvPrintOperation *op)
578 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
580 return export->job_name;
584 ev_print_operation_export_set_printer (EvPrintOperationExport *export,
587 if (printer == export->printer)
590 g_object_ref (printer);
592 g_object_unref (export->printer);
593 export->printer = printer;
597 find_range (EvPrintOperationExport *export)
601 range = &export->ranges[export->range];
603 if (export->inc < 0) {
604 export->start = range->end;
605 export->end = range->start - 1;
607 export->start = range->start;
608 export->end = range->end + 1;
613 clamp_ranges (EvPrintOperationExport *export)
615 gint num_of_correct_ranges = 0;
616 gint n_pages_to_print = 0;
618 gboolean null_flag = FALSE;
620 for (i = 0; i < export->n_ranges; i++) {
623 if ((export->ranges[i].start >= 0) &&
624 (export->ranges[i].start < export->n_pages) &&
625 (export->ranges[i].end >= 0) &&
626 (export->ranges[i].end < export->n_pages)) {
627 export->ranges[num_of_correct_ranges] = export->ranges[i];
628 num_of_correct_ranges++;
629 } else if ((export->ranges[i].start >= 0) &&
630 (export->ranges[i].start < export->n_pages) &&
631 (export->ranges[i].end >= export->n_pages)) {
632 export->ranges[i].end = export->n_pages - 1;
633 export->ranges[num_of_correct_ranges] = export->ranges[i];
634 num_of_correct_ranges++;
635 } else if ((export->ranges[i].end >= 0) &&
636 (export->ranges[i].end < export->n_pages) &&
637 (export->ranges[i].start < 0)) {
638 export->ranges[i].start = 0;
639 export->ranges[num_of_correct_ranges] = export->ranges[i];
640 num_of_correct_ranges++;
643 n_pages = export->ranges[i].end - export->ranges[i].start + 1;
644 if (export->page_set == GTK_PAGE_SET_ALL) {
645 n_pages_to_print += n_pages;
646 } else if (n_pages % 2 == 0) {
647 n_pages_to_print += n_pages / 2;
648 } else if (export->page_set == GTK_PAGE_SET_EVEN) {
649 if (n_pages==1 && export->ranges[i].start % 2 == 0)
652 n_pages_to_print += export->ranges[i].start % 2 == 0 ?
653 n_pages / 2 : (n_pages / 2) + 1;
654 } else if (export->page_set == GTK_PAGE_SET_ODD) {
655 if (n_pages==1 && export->ranges[i].start % 2 != 0)
658 n_pages_to_print += export->ranges[i].start % 2 == 0 ?
659 (n_pages / 2) + 1 : n_pages / 2;
663 if (null_flag && !n_pages_to_print) {
666 export->n_ranges = num_of_correct_ranges;
667 export->n_pages_to_print = n_pages_to_print;
673 get_first_and_last_page (EvPrintOperationExport *export,
678 gint first_page = G_MAXINT;
679 gint last_page = G_MININT;
680 gint max_page = export->n_pages - 1;
682 if (export->n_ranges == 0) {
689 for (i = 0; i < export->n_ranges; i++) {
690 if (export->ranges[i].start < first_page)
691 first_page = export->ranges[i].start;
692 if (export->ranges[i].end > last_page)
693 last_page = export->ranges[i].end;
696 *first = MAX (0, first_page);
697 *last = MIN (max_page, last_page);
701 export_print_inc_page (EvPrintOperationExport *export)
704 export->page += export->inc;
706 /* note: when NOT collating, page_count is increased in export_print_page */
707 if (export->collate) {
708 export->page_count++;
709 export->sheet = 1 + (export->page_count - 1) / export->pages_per_sheet;
712 if (export->page == export->end) {
713 export->range += export->inc;
714 if (export->range == -1 || export->range == export->n_ranges) {
715 export->uncollated++;
717 /* when printing multiple collated copies & multiple pages per sheet we want to
718 * prevent the next copy bleeding into the last sheet of the previous one
719 * we've reached the last range to be printed now, so this is the time to do it */
720 if (export->pages_per_sheet > 1 && export->collate == 1 &&
721 (export->page_count - 1) % export->pages_per_sheet != 0) {
723 EvPrintOperation *op = EV_PRINT_OPERATION (export);
724 ev_document_doc_mutex_lock ();
726 /* keep track of all blanks but only actualise those
727 * which are in the current odd / even sheet set */
729 export->page_count += export->pages_per_sheet - (export->page_count - 1) % export->pages_per_sheet;
730 if (export->page_set == GTK_PAGE_SET_ALL ||
731 (export->page_set == GTK_PAGE_SET_EVEN && export->sheet % 2 == 0) ||
732 (export->page_set == GTK_PAGE_SET_ODD && export->sheet % 2 == 1) ) {
733 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
735 ev_document_doc_mutex_unlock ();
736 export->sheet = 1 + (export->page_count - 1) / export->pages_per_sheet;
739 if (export->uncollated == export->uncollated_copies)
742 export->range = export->inc < 0 ? export->n_ranges - 1 : 0;
745 export->page = export->start;
748 /* in/decrement the page number until we reach the first page on the next EVEN or ODD sheet
749 * if we're not collating, we have to make sure that this is done only once! */
750 } while ( export->collate == 1 &&
751 ((export->page_set == GTK_PAGE_SET_EVEN && export->sheet % 2 == 1) ||
752 (export->page_set == GTK_PAGE_SET_ODD && export->sheet % 2 == 0)));
758 ev_print_operation_export_clear_temp_file (EvPrintOperationExport *export)
760 if (!export->temp_file)
763 g_unlink (export->temp_file);
764 g_free (export->temp_file);
765 export->temp_file = NULL;
769 ev_print_operation_export_run_next (EvPrintOperationExport *export)
771 EvPrintOperation *op = EV_PRINT_OPERATION (export);
772 EvPrintOperation *next;
773 EvDocument *document;
775 /* First pop the current job */
776 document = op->document;
777 ev_print_queue_pop (document);
779 next = ev_print_queue_peek (document);
781 ev_print_operation_export_begin (EV_PRINT_OPERATION_EXPORT (next));
785 gtk_print_job_finished (GtkPrintJob *print_job,
786 EvPrintOperationExport *export,
789 EvPrintOperation *op = EV_PRINT_OPERATION (export);
792 g_set_error_literal (&export->error,
794 GTK_PRINT_ERROR_GENERAL,
796 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
798 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
801 ev_print_operation_export_clear_temp_file (export);
802 g_object_unref (print_job);
804 ev_print_operation_export_run_next (export);
808 export_print_done (EvPrintOperationExport *export)
810 EvPrintOperation *op = EV_PRINT_OPERATION (export);
811 GtkPrintSettings *settings;
812 EvFileExporterCapabilities capabilities;
813 GError *error = NULL;
815 g_assert (export->temp_file != NULL);
817 /* Some printers take into account some print settings,
818 * and others don't. However we have exported the document
819 * to a ps or pdf file according to such print settings. So,
820 * we want to send the exported file to printer with those
821 * settings set to default values.
823 settings = gtk_print_settings_copy (export->print_settings);
824 capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
826 gtk_print_settings_set_page_ranges (settings, NULL, 0);
827 gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
828 if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
829 gtk_print_settings_set_n_copies (settings, 1);
830 if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
831 gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
832 if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
833 gtk_print_settings_set_scale (settings, 1.0);
834 if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
835 gtk_print_settings_set_collate (settings, FALSE);
836 if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
837 gtk_print_settings_set_reverse (settings, FALSE);
838 if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
839 gtk_print_settings_set_number_up (settings, 1);
840 gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
843 if (export->print_preview) {
847 gchar *print_settings_file = NULL;
849 key_file = g_key_file_new ();
851 gtk_print_settings_to_key_file (settings, key_file, NULL);
852 gtk_page_setup_to_key_file (export->page_setup, key_file, NULL);
853 g_key_file_set_string (key_file, "Print Job", "title", export->job_name);
855 data = g_key_file_to_data (key_file, &data_len, &error);
859 fd = g_file_open_tmp ("print-settingsXXXXXX", &print_settings_file, &error);
861 g_file_set_contents (print_settings_file, data, data_len, &error);
867 g_key_file_free (key_file);
873 gchar *quoted_filename;
874 gchar *quoted_settings_filename;
876 quoted_filename = g_shell_quote (export->temp_file);
877 quoted_settings_filename = g_shell_quote (print_settings_file);
878 cmd = g_strdup_printf ("evince-previewer --unlink-tempfile --print-settings %s %s",
879 quoted_settings_filename, quoted_filename);
881 g_shell_parse_argv (cmd, &argc, &argv, &error);
883 g_free (quoted_filename);
884 g_free (quoted_settings_filename);
888 gdk_spawn_on_screen (gtk_window_get_screen (export->parent_window),
899 if (print_settings_file)
900 g_unlink (print_settings_file);
901 g_free (print_settings_file);
903 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
904 /* temp_file will be deleted by the previewer */
906 ev_print_operation_export_run_next (export);
911 job = gtk_print_job_new (export->job_name,
915 gtk_print_job_set_source_file (job, export->temp_file, &error);
917 gtk_print_job_send (job,
918 (GtkPrintJobCompleteFunc)gtk_print_job_finished,
919 g_object_ref (export),
920 (GDestroyNotify)g_object_unref);
923 g_object_unref (settings);
926 g_set_error_literal (&export->error,
928 GTK_PRINT_ERROR_GENERAL,
930 g_error_free (error);
931 ev_print_operation_export_clear_temp_file (export);
932 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
934 ev_print_operation_export_run_next (export);
939 export_print_page_idle_finished (EvPrintOperationExport *export)
945 export_job_finished (EvJobExport *job,
946 EvPrintOperationExport *export)
948 EvPrintOperation *op = EV_PRINT_OPERATION (export);
950 if (export->pages_per_sheet == 1 ||
951 ( export->page_count % export->pages_per_sheet == 0 &&
952 ( export->page_set == GTK_PAGE_SET_ALL ||
953 ( export->page_set == GTK_PAGE_SET_EVEN && export->sheet % 2 == 0 ) ||
954 ( export->page_set == GTK_PAGE_SET_ODD && export->sheet % 2 == 1 ) ) ) ) {
956 ev_document_doc_mutex_lock ();
957 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
958 ev_document_doc_mutex_unlock ();
962 export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
963 (GSourceFunc)export_print_page,
965 (GDestroyNotify)export_print_page_idle_finished);
969 export_job_cancelled (EvJobExport *job,
970 EvPrintOperationExport *export)
972 export_cancel (export);
976 export_cancel (EvPrintOperationExport *export)
978 EvPrintOperation *op = EV_PRINT_OPERATION (export);
980 if (export->idle_id > 0)
981 g_source_remove (export->idle_id);
984 if (export->job_export) {
985 g_signal_handlers_disconnect_by_func (export->job_export,
988 g_signal_handlers_disconnect_by_func (export->job_export,
989 export_job_cancelled,
991 g_object_unref (export->job_export);
992 export->job_export = NULL;
995 if (export->fd != -1) {
1000 ev_print_operation_export_clear_temp_file (export);
1002 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
1004 ev_print_operation_export_run_next (export);
1008 update_progress (EvPrintOperationExport *export)
1010 EvPrintOperation *op = EV_PRINT_OPERATION (export);
1012 ev_print_operation_update_status (op, export->total,
1013 export->n_pages_to_print,
1014 export->total / (gdouble)export->n_pages_to_print);
1018 export_print_page (EvPrintOperationExport *export)
1020 EvPrintOperation *op = EV_PRINT_OPERATION (export);
1022 if (!export->temp_file)
1023 return FALSE; /* cancelled */
1028 /* note: when collating, page_count is increased in export_print_inc_page */
1029 if (!export->collate) {
1030 export->page_count++;
1031 export->sheet = 1 + (export->page_count - 1) / export->pages_per_sheet;
1034 if (export->collated == export->collated_copies) {
1035 export->collated = 0;
1036 if (!export_print_inc_page (export)) {
1037 ev_document_doc_mutex_lock ();
1038 ev_file_exporter_end (EV_FILE_EXPORTER (op->document));
1039 ev_document_doc_mutex_unlock ();
1043 update_progress (export);
1044 export_print_done (export);
1050 /* we're not collating and we've reached a sheet from the wrong sheet set */
1051 if (!export->collate &&
1052 ((export->page_set == GTK_PAGE_SET_EVEN && export->sheet % 2 != 0) ||
1053 (export->page_set == GTK_PAGE_SET_ODD && export->sheet % 2 != 1))) {
1056 export->page_count++;
1058 export->sheet = 1 + (export->page_count - 1) / export->pages_per_sheet;
1060 if (export->collated == export->collated_copies) {
1061 export->collated = 0;
1063 if (!export_print_inc_page (export)) {
1064 ev_document_doc_mutex_lock ();
1065 ev_file_exporter_end (EV_FILE_EXPORTER (op->document));
1066 ev_document_doc_mutex_unlock ();
1071 update_progress (export);
1073 export_print_done (export);
1078 } while ((export->page_set == GTK_PAGE_SET_EVEN && export->sheet % 2 != 0) ||
1079 (export->page_set == GTK_PAGE_SET_ODD && export->sheet % 2 != 1));
1083 if (export->pages_per_sheet == 1 ||
1084 (export->page_count % export->pages_per_sheet == 1 &&
1085 (export->page_set == GTK_PAGE_SET_ALL ||
1086 (export->page_set == GTK_PAGE_SET_EVEN && export->sheet % 2 == 0) ||
1087 (export->page_set == GTK_PAGE_SET_ODD && export->sheet % 2 == 1)))) {
1088 ev_document_doc_mutex_lock ();
1089 ev_file_exporter_begin_page (EV_FILE_EXPORTER (op->document));
1090 ev_document_doc_mutex_unlock ();
1093 if (!export->job_export) {
1094 export->job_export = ev_job_export_new (op->document);
1095 g_signal_connect (export->job_export, "finished",
1096 G_CALLBACK (export_job_finished),
1098 g_signal_connect (export->job_export, "cancelled",
1099 G_CALLBACK (export_job_cancelled),
1103 ev_job_export_set_page (EV_JOB_EXPORT (export->job_export), export->page);
1104 ev_job_scheduler_push_job (export->job_export, EV_JOB_PRIORITY_NONE);
1106 update_progress (export);
1112 ev_print_operation_export_begin (EvPrintOperationExport *export)
1114 EvPrintOperation *op = EV_PRINT_OPERATION (export);
1116 if (!export->temp_file)
1117 return; /* cancelled */
1119 ev_document_doc_mutex_lock ();
1120 ev_file_exporter_begin (EV_FILE_EXPORTER (op->document), &export->fc);
1121 ev_document_doc_mutex_unlock ();
1123 export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
1124 (GSourceFunc)export_print_page,
1126 (GDestroyNotify)export_print_page_idle_finished);
1130 ev_print_operation_export_print_dialog_response_cb (GtkDialog *dialog,
1132 EvPrintOperationExport *export)
1134 GtkPrintPages print_pages;
1135 GtkPrintSettings *print_settings;
1136 GtkPageSetup *page_setup;
1137 GtkPrinter *printer;
1143 const gchar *file_format;
1145 GError *error = NULL;
1146 EvPrintOperation *op = EV_PRINT_OPERATION (export);
1148 if (response != GTK_RESPONSE_OK &&
1149 response != GTK_RESPONSE_APPLY) {
1150 gtk_widget_destroy (GTK_WIDGET (dialog));
1151 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
1156 export->print_preview = (response == GTK_RESPONSE_APPLY);
1158 printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog));
1159 ev_print_operation_export_set_printer (export, printer);
1161 print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog));
1162 ev_print_operation_export_set_print_settings (op, print_settings);
1164 page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog));
1165 ev_print_operation_export_set_default_page_setup (op, page_setup);
1167 if (!gtk_printer_accepts_ps (export->printer)) {
1168 gtk_widget_destroy (GTK_WIDGET (dialog));
1170 g_set_error_literal (&export->error,
1172 GTK_PRINT_ERROR_GENERAL,
1173 _("Printing is not supported on this printer."));
1174 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1179 file_format = gtk_print_settings_get (print_settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
1181 filename = g_strdup_printf ("evince_print.%s.XXXXXX", file_format != NULL ? file_format : "");
1182 export->fd = g_file_open_tmp (filename, &export->temp_file, &error);
1184 if (export->fd <= -1) {
1185 gtk_widget_destroy (GTK_WIDGET (dialog));
1187 g_set_error_literal (&export->error,
1189 GTK_PRINT_ERROR_GENERAL,
1191 g_error_free (error);
1192 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1197 export->current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
1198 export->page_set = gtk_print_settings_get_page_set (print_settings);
1199 print_pages = gtk_print_settings_get_print_pages (print_settings);
1201 switch (print_pages) {
1202 case GTK_PRINT_PAGES_CURRENT:
1203 export->ranges = &export->one_range;
1205 export->ranges[0].start = export->current_page;
1206 export->ranges[0].end = export->current_page;
1207 export->n_ranges = 1;
1210 case GTK_PRINT_PAGES_RANGES: {
1213 export->ranges = gtk_print_settings_get_page_ranges (print_settings, &export->n_ranges);
1214 for (i = 0; i < export->n_ranges; i++)
1215 if (export->ranges[i].end == -1 || export->ranges[i].end >= export->n_pages)
1216 export->ranges[i].end = export->n_pages - 1;
1220 g_warning ("Unsupported print pages setting\n");
1221 case GTK_PRINT_PAGES_ALL:
1222 export->ranges = &export->one_range;
1224 export->ranges[0].start = 0;
1225 export->ranges[0].end = export->n_pages - 1;
1226 export->n_ranges = 1;
1231 if (export->n_ranges < 1 || !clamp_ranges (export)) {
1232 GtkWidget *message_dialog;
1234 message_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
1236 GTK_MESSAGE_WARNING,
1238 "%s", _("Invalid page selection"));
1239 gtk_window_set_title (GTK_WINDOW (message_dialog), _("Warning"));
1240 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message_dialog),
1241 "%s", _("Your print range selection does not include any page"));
1242 g_signal_connect (message_dialog, "response",
1243 G_CALLBACK (gtk_widget_destroy),
1245 gtk_widget_show (message_dialog);
1248 } else ev_print_operation_update_status (op, -1, -1, 0.0);
1250 width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
1251 height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
1252 scale = gtk_print_settings_get_scale (print_settings) * 0.01;
1258 export->pages_per_sheet = MAX (1, gtk_print_settings_get_number_up (print_settings));
1260 export->copies = gtk_print_settings_get_n_copies (print_settings);
1261 export->collate = gtk_print_settings_get_collate (print_settings);
1262 export->reverse = gtk_print_settings_get_reverse (print_settings);
1264 if (export->collate) {
1265 export->uncollated_copies = export->copies;
1266 export->collated_copies = 1;
1268 export->uncollated_copies = 1;
1269 export->collated_copies = export->copies;
1272 if (export->reverse) {
1273 export->range = export->n_ranges - 1;
1279 find_range (export);
1281 export->page = export->start - export->inc;
1282 export->collated = export->collated_copies - 1;
1284 get_first_and_last_page (export, &first_page, &last_page);
1286 export->fc.format = file_format && g_ascii_strcasecmp (file_format, "pdf") == 0 ?
1287 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1288 export->fc.filename = export->temp_file;
1289 export->fc.first_page = MIN (first_page, last_page);
1290 export->fc.last_page = MAX (first_page, last_page);
1291 export->fc.paper_width = width;
1292 export->fc.paper_height = height;
1293 export->fc.duplex = FALSE;
1294 export->fc.pages_per_sheet = export->pages_per_sheet;
1296 if (ev_print_queue_is_empty (op->document))
1297 ev_print_operation_export_begin (export);
1299 ev_print_queue_push (op);
1301 g_signal_emit (op, signals[BEGIN_PRINT], 0);
1303 gtk_widget_destroy (GTK_WIDGET (dialog));
1307 ev_print_operation_export_run (EvPrintOperation *op,
1310 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1312 GtkPrintCapabilities capabilities;
1314 ev_print_queue_init ();
1316 export->parent_window = parent;
1317 export->error = NULL;
1319 dialog = gtk_print_unix_dialog_new (_("Print"), parent);
1320 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1322 capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
1323 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
1324 gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
1326 #if GTK_CHECK_VERSION (2, 17, 4)
1327 gtk_print_unix_dialog_set_embed_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1328 export->embed_page_setup);
1331 gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
1332 export->current_page);
1334 gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
1335 export->print_settings);
1337 if (export->page_setup)
1338 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1339 export->page_setup);
1341 g_signal_connect (dialog, "response",
1342 G_CALLBACK (ev_print_operation_export_print_dialog_response_cb),
1345 gtk_window_present (GTK_WINDOW (dialog));
1349 ev_print_operation_export_cancel (EvPrintOperation *op)
1351 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1353 if (export->job_export &&
1354 !ev_job_is_finished (export->job_export)) {
1355 ev_job_cancel (export->job_export);
1357 export_cancel (export);
1362 ev_print_operation_export_get_error (EvPrintOperation *op,
1365 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1367 g_propagate_error (error, export->error);
1368 export->error = NULL;
1372 ev_print_operation_export_set_embed_page_setup (EvPrintOperation *op,
1375 #if GTK_CHECK_VERSION (2, 17, 4)
1376 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1378 export->embed_page_setup = embed;
1383 ev_print_operation_export_get_embed_page_setup (EvPrintOperation *op)
1385 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1387 return export->embed_page_setup;
1391 ev_print_operation_export_finalize (GObject *object)
1393 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (object);
1395 if (export->idle_id > 0) {
1396 g_source_remove (export->idle_id);
1397 export->idle_id = 0;
1400 if (export->fd != -1) {
1405 if (export->ranges) {
1406 if (export->ranges != &export->one_range)
1407 g_free (export->ranges);
1408 export->ranges = NULL;
1409 export->n_ranges = 0;
1412 if (export->temp_file) {
1413 g_free (export->temp_file);
1414 export->temp_file = NULL;
1417 if (export->job_name) {
1418 g_free (export->job_name);
1419 export->job_name = NULL;
1422 if (export->job_export) {
1423 if (!ev_job_is_finished (export->job_export))
1424 ev_job_cancel (export->job_export);
1425 g_signal_handlers_disconnect_by_func (export->job_export,
1426 export_job_finished,
1428 g_signal_handlers_disconnect_by_func (export->job_export,
1429 export_job_cancelled,
1431 g_object_unref (export->job_export);
1432 export->job_export = NULL;
1435 if (export->error) {
1436 g_error_free (export->error);
1437 export->error = NULL;
1440 if (export->print_settings) {
1441 g_object_unref (export->print_settings);
1442 export->print_settings = NULL;
1445 if (export->page_setup) {
1446 g_object_unref (export->page_setup);
1447 export->page_setup = NULL;
1450 if (export->printer) {
1451 g_object_unref (export->printer);
1452 export->printer = NULL;
1455 (* G_OBJECT_CLASS (ev_print_operation_export_parent_class)->finalize) (object);
1459 ev_print_operation_export_init (EvPrintOperationExport *export)
1461 /* sheets are counted from 1 to be physical */
1466 ev_print_operation_export_constructor (GType type,
1467 guint n_construct_properties,
1468 GObjectConstructParam *construct_params)
1471 EvPrintOperationExport *export;
1472 EvPrintOperation *op;
1474 object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,
1475 n_construct_properties,
1477 export = EV_PRINT_OPERATION_EXPORT (object);
1478 op = EV_PRINT_OPERATION (object);
1479 export->n_pages = ev_document_get_n_pages (op->document);
1485 ev_print_operation_export_class_init (EvPrintOperationExportClass *klass)
1487 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
1488 EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1490 ev_print_op_class->set_current_page = ev_print_operation_export_set_current_page;
1491 ev_print_op_class->set_print_settings = ev_print_operation_export_set_print_settings;
1492 ev_print_op_class->get_print_settings = ev_print_operation_export_get_print_settings;
1493 ev_print_op_class->set_default_page_setup = ev_print_operation_export_set_default_page_setup;
1494 ev_print_op_class->get_default_page_setup = ev_print_operation_export_get_default_page_setup;
1495 ev_print_op_class->set_job_name = ev_print_operation_export_set_job_name;
1496 ev_print_op_class->get_job_name = ev_print_operation_export_get_job_name;
1497 ev_print_op_class->run = ev_print_operation_export_run;
1498 ev_print_op_class->cancel = ev_print_operation_export_cancel;
1499 ev_print_op_class->get_error = ev_print_operation_export_get_error;
1500 ev_print_op_class->set_embed_page_setup = ev_print_operation_export_set_embed_page_setup;
1501 ev_print_op_class->get_embed_page_setup = ev_print_operation_export_get_embed_page_setup;
1503 g_object_class->constructor = ev_print_operation_export_constructor;
1504 g_object_class->finalize = ev_print_operation_export_finalize;
1507 #endif /* GTKUNIXPRINT_ENABLED */
1509 #if GTK_CHECK_VERSION (2, 17, 1)
1510 /* Print to cairo interface */
1511 #define EV_TYPE_PRINT_OPERATION_PRINT (ev_print_operation_print_get_type())
1512 #define EV_PRINT_OPERATION_PRINT(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PRINT_OPERATION_PRINT, EvPrintOperationPrint))
1513 #define EV_PRINT_OPERATION_PRINT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PRINT_OPERATION_PRINT, EvPrintOperationPrintClass))
1514 #define EV_IS_PRINT_OPERATION_PRINT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PRINT_OPERATION_PRINT))
1516 typedef struct _EvPrintOperationPrint EvPrintOperationPrint;
1517 typedef struct _EvPrintOperationPrintClass EvPrintOperationPrintClass;
1519 static GType ev_print_operation_print_get_type (void) G_GNUC_CONST;
1521 struct _EvPrintOperationPrint {
1522 EvPrintOperation parent;
1524 GtkPrintOperation *op;
1525 gint n_pages_to_print;
1531 struct _EvPrintOperationPrintClass {
1532 EvPrintOperationClass parent_class;
1535 G_DEFINE_TYPE (EvPrintOperationPrint, ev_print_operation_print, EV_TYPE_PRINT_OPERATION)
1538 ev_print_operation_print_set_current_page (EvPrintOperation *op,
1541 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1543 gtk_print_operation_set_current_page (print->op, current_page);
1547 ev_print_operation_print_set_print_settings (EvPrintOperation *op,
1548 GtkPrintSettings *print_settings)
1550 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1552 gtk_print_operation_set_print_settings (print->op, print_settings);
1555 static GtkPrintSettings *
1556 ev_print_operation_print_get_print_settings (EvPrintOperation *op)
1558 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1560 return gtk_print_operation_get_print_settings (print->op);
1564 ev_print_operation_print_set_default_page_setup (EvPrintOperation *op,
1565 GtkPageSetup *page_setup)
1567 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1569 gtk_print_operation_set_default_page_setup (print->op, page_setup);
1572 static GtkPageSetup *
1573 ev_print_operation_print_get_default_page_setup (EvPrintOperation *op)
1575 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1577 return gtk_print_operation_get_default_page_setup (print->op);
1581 ev_print_operation_print_set_job_name (EvPrintOperation *op,
1582 const gchar *job_name)
1584 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1586 g_free (print->job_name);
1587 print->job_name = g_strdup (job_name);
1589 gtk_print_operation_set_job_name (print->op, print->job_name);
1592 static const gchar *
1593 ev_print_operation_print_get_job_name (EvPrintOperation *op)
1595 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1597 if (!print->job_name) {
1600 g_object_get (print->op, "job_name", &name, NULL);
1601 print->job_name = name;
1604 return print->job_name;
1608 ev_print_operation_print_run (EvPrintOperation *op,
1611 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1613 gtk_print_operation_run (print->op,
1614 GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
1619 ev_print_operation_print_cancel (EvPrintOperation *op)
1621 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1623 gtk_print_operation_cancel (print->op);
1627 ev_print_operation_print_get_error (EvPrintOperation *op,
1630 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1632 gtk_print_operation_get_error (print->op, error);
1636 ev_print_operation_print_set_embed_page_setup (EvPrintOperation *op,
1639 #if GTK_CHECK_VERSION (2, 17, 4)
1640 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1642 gtk_print_operation_set_embed_page_setup (print->op, embed);
1647 ev_print_operation_print_get_embed_page_setup (EvPrintOperation *op)
1649 #if GTK_CHECK_VERSION (2, 17, 4)
1650 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1652 return gtk_print_operation_get_embed_page_setup (print->op);
1659 ev_print_operation_print_begin_print (EvPrintOperationPrint *print,
1660 GtkPrintContext *context)
1662 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1665 n_pages = ev_document_get_n_pages (op->document);
1666 gtk_print_operation_set_n_pages (print->op, n_pages);
1667 ev_print_operation_update_status (op, -1, n_pages, 0);
1669 g_signal_emit (op, signals[BEGIN_PRINT], 0);
1673 ev_print_operation_print_done (EvPrintOperationPrint *print,
1674 GtkPrintOperationResult result)
1676 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1678 ev_print_operation_update_status (op, 0, print->n_pages_to_print, 1.0);
1680 g_signal_emit (op, signals[DONE], 0, result);
1684 ev_print_operation_print_status_changed (EvPrintOperationPrint *print)
1686 #ifdef HAVE_GTK_PRINT_OPERATION_GET_N_PAGES_TO_PRINT
1687 GtkPrintStatus status;
1689 status = gtk_print_operation_get_status (print->op);
1690 if (status == GTK_PRINT_STATUS_GENERATING_DATA)
1691 print->n_pages_to_print = gtk_print_operation_get_n_pages_to_print (print->op);
1696 print_job_finished (EvJobPrint *job,
1697 EvPrintOperationPrint *print)
1699 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1701 gtk_print_operation_draw_page_finish (print->op);
1702 #ifdef HAVE_GTK_PRINT_OPERATION_GET_N_PAGES_TO_PRINT
1704 ev_print_operation_update_status (op, print->total,
1705 print->n_pages_to_print,
1706 print->total / (gdouble)print->n_pages_to_print);
1708 ev_job_print_set_cairo (job, NULL);
1712 print_job_cancelled (EvJobPrint *job,
1713 EvPrintOperationPrint *print)
1715 gtk_print_operation_cancel (print->op);
1719 ev_print_operation_print_request_page_setup (EvPrintOperationPrint *print,
1720 GtkPrintContext *context,
1722 GtkPageSetup *setup)
1724 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1725 gdouble width, height;
1727 ev_document_get_page_size (op->document, page_nr,
1730 gtk_page_setup_set_orientation (setup, GTK_PAGE_ORIENTATION_LANDSCAPE);
1732 gtk_page_setup_set_orientation (setup, GTK_PAGE_ORIENTATION_PORTRAIT);
1736 ev_print_operation_print_draw_page (EvPrintOperationPrint *print,
1737 GtkPrintContext *context,
1740 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1742 gdouble cr_width, cr_height;
1743 gdouble width, height, scale;
1745 gtk_print_operation_set_defer_drawing (print->op);
1747 if (!print->job_print) {
1748 print->job_print = ev_job_print_new (op->document);
1749 g_signal_connect (G_OBJECT (print->job_print), "finished",
1750 G_CALLBACK (print_job_finished),
1752 g_signal_connect (G_OBJECT (print->job_print), "cancelled",
1753 G_CALLBACK (print_job_cancelled),
1757 ev_job_print_set_page (EV_JOB_PRINT (print->job_print), page);
1759 cr = gtk_print_context_get_cairo_context (context);
1760 cr_width = gtk_print_context_get_width (context);
1761 cr_height = gtk_print_context_get_height (context);
1762 ev_document_get_page_size (op->document, page,
1764 if (cr_width / width < cr_height / height)
1765 scale = cr_width / width;
1767 scale = cr_height / height;
1768 cairo_scale (cr, scale, scale);
1770 ev_job_print_set_cairo (EV_JOB_PRINT (print->job_print), cr);
1771 ev_job_scheduler_push_job (print->job_print, EV_JOB_PRIORITY_NONE);
1775 ev_print_operation_print_finalize (GObject *object)
1777 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (object);
1780 g_object_unref (print->op);
1784 if (print->job_name) {
1785 g_free (print->job_name);
1786 print->job_name = NULL;
1789 if (print->job_print) {
1790 if (!ev_job_is_finished (print->job_print))
1791 ev_job_cancel (print->job_print);
1792 g_signal_handlers_disconnect_by_func (print->job_print,
1795 g_signal_handlers_disconnect_by_func (print->job_print,
1796 print_job_cancelled,
1798 g_object_unref (print->job_print);
1799 print->job_print = NULL;
1802 (* G_OBJECT_CLASS (ev_print_operation_print_parent_class)->finalize) (object);
1806 ev_print_operation_print_init (EvPrintOperationPrint *print)
1808 print->op = gtk_print_operation_new ();
1809 g_signal_connect_swapped (print->op, "begin_print",
1810 G_CALLBACK (ev_print_operation_print_begin_print),
1812 g_signal_connect_swapped (print->op, "done",
1813 G_CALLBACK (ev_print_operation_print_done),
1815 g_signal_connect_swapped (print->op, "draw_page",
1816 G_CALLBACK (ev_print_operation_print_draw_page),
1818 g_signal_connect_swapped (print->op, "status_changed",
1819 G_CALLBACK (ev_print_operation_print_status_changed),
1821 g_signal_connect_swapped (print->op, "request_page_setup",
1822 G_CALLBACK (ev_print_operation_print_request_page_setup),
1824 gtk_print_operation_set_allow_async (print->op, TRUE);
1828 ev_print_operation_print_class_init (EvPrintOperationPrintClass *klass)
1830 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
1831 EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1833 ev_print_op_class->set_current_page = ev_print_operation_print_set_current_page;
1834 ev_print_op_class->set_print_settings = ev_print_operation_print_set_print_settings;
1835 ev_print_op_class->get_print_settings = ev_print_operation_print_get_print_settings;
1836 ev_print_op_class->set_default_page_setup = ev_print_operation_print_set_default_page_setup;
1837 ev_print_op_class->get_default_page_setup = ev_print_operation_print_get_default_page_setup;
1838 ev_print_op_class->set_job_name = ev_print_operation_print_set_job_name;
1839 ev_print_op_class->get_job_name = ev_print_operation_print_get_job_name;
1840 ev_print_op_class->run = ev_print_operation_print_run;
1841 ev_print_op_class->cancel = ev_print_operation_print_cancel;
1842 ev_print_op_class->get_error = ev_print_operation_print_get_error;
1843 ev_print_op_class->set_embed_page_setup = ev_print_operation_print_set_embed_page_setup;
1844 ev_print_op_class->get_embed_page_setup = ev_print_operation_print_get_embed_page_setup;
1846 g_object_class->finalize = ev_print_operation_print_finalize;
1848 #endif /* GTK_CHECK_VERSION (2, 17, 1) */
1850 gboolean ev_print_operation_exists_for_document (EvDocument *document)
1852 #if GTKUNIXPRINT_ENABLED
1853 #if GTK_CHECK_VERSION (2, 17, 1)
1854 return (EV_IS_FILE_EXPORTER(document) || EV_IS_DOCUMENT_PRINT(document));
1856 return EV_IS_FILE_EXPORTER(document);
1858 #else /* ! GTKUNIXPRINT_ENABLED */
1859 #if GTK_CHECK_VERSION (2, 17, 1)
1860 return EV_IS_DOCUMENT_PRINT(document);
1864 #endif /* GTKUNIXPRINT_ENABLED */
1867 /* Factory method */
1869 ev_print_operation_new (EvDocument *document)
1871 EvPrintOperation *op = NULL;
1873 g_return_val_if_fail (ev_print_operation_exists_for_document (document), NULL);
1875 #if GTK_CHECK_VERSION (2, 17, 1)
1876 if (EV_IS_DOCUMENT_PRINT (document))
1877 op = EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_PRINT,
1878 "document", document, NULL));
1881 #if GTKUNIXPRINT_ENABLED
1882 op = EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_EXPORT,
1883 "document", document, NULL));