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 #include <gtk/gtkunixprint.h>
25 #include <glib/gi18n.h>
26 #include <glib/gstdio.h>
29 #include "ev-page-cache.h"
30 #include "ev-file-exporter.h"
32 #include "ev-job-scheduler.h"
33 #include "ev-application.h"
34 #include "ev-file-helpers.h"
35 #include "ev-document-print.h"
49 static guint signals[LAST_SIGNAL] = { 0 };
51 struct _EvPrintOperation {
61 struct _EvPrintOperationClass {
62 GObjectClass parent_class;
64 void (* set_current_page) (EvPrintOperation *op,
66 void (* set_print_settings) (EvPrintOperation *op,
67 GtkPrintSettings *print_settings);
68 GtkPrintSettings *(* get_print_settings) (EvPrintOperation *op);
69 void (* set_default_page_setup) (EvPrintOperation *op,
70 GtkPageSetup *page_setup);
71 GtkPageSetup *(* get_default_page_setup) (EvPrintOperation *op);
72 void (* set_job_name) (EvPrintOperation *op,
73 const gchar *job_name);
74 const gchar *(* get_job_name) (EvPrintOperation *op);
75 void (* run) (EvPrintOperation *op,
77 void (* cancel) (EvPrintOperation *op);
78 void (* get_error) (EvPrintOperation *op,
82 void (* done) (EvPrintOperation *op,
83 GtkPrintOperationResult result);
84 void (* begin_print) (EvPrintOperation *op);
85 void (* status_changed) (EvPrintOperation *op);
88 G_DEFINE_ABSTRACT_TYPE (EvPrintOperation, ev_print_operation, G_TYPE_OBJECT)
91 ev_print_operation_finalize (GObject *object)
93 EvPrintOperation *op = EV_PRINT_OPERATION (object);
96 g_object_unref (op->document);
105 (* G_OBJECT_CLASS (ev_print_operation_parent_class)->finalize) (object);
109 ev_print_operation_set_property (GObject *object,
114 EvPrintOperation *op = EV_PRINT_OPERATION (object);
118 op->document = g_value_dup_object (value);
121 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
126 ev_print_operation_init (EvPrintOperation *op)
131 ev_print_operation_class_init (EvPrintOperationClass *klass)
133 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
135 g_object_class->set_property = ev_print_operation_set_property;
136 g_object_class->finalize = ev_print_operation_finalize;
138 g_object_class_install_property (g_object_class,
140 g_param_spec_object ("document",
142 "The document to print",
145 G_PARAM_CONSTRUCT_ONLY));
147 g_signal_new ("done",
148 G_TYPE_FROM_CLASS (g_object_class),
150 G_STRUCT_OFFSET (EvPrintOperationClass, done),
152 g_cclosure_marshal_VOID__ENUM,
154 GTK_TYPE_PRINT_OPERATION_RESULT);
155 signals[BEGIN_PRINT] =
156 g_signal_new ("begin_print",
157 G_TYPE_FROM_CLASS (g_object_class),
159 G_STRUCT_OFFSET (EvPrintOperationClass, begin_print),
161 g_cclosure_marshal_VOID__VOID,
163 signals[STATUS_CHANGED] =
164 g_signal_new ("status_changed",
165 G_TYPE_FROM_CLASS (g_object_class),
167 G_STRUCT_OFFSET (EvPrintOperationClass, status_changed),
169 g_cclosure_marshal_VOID__VOID,
175 ev_print_operation_set_current_page (EvPrintOperation *op,
178 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
180 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
181 g_return_if_fail (current_page >= 0);
183 class->set_current_page (op, current_page);
187 ev_print_operation_set_print_settings (EvPrintOperation *op,
188 GtkPrintSettings *print_settings)
190 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
192 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
193 g_return_if_fail (GTK_IS_PRINT_SETTINGS (print_settings));
195 class->set_print_settings (op, print_settings);
199 ev_print_operation_get_print_settings (EvPrintOperation *op)
201 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
203 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
205 return class->get_print_settings (op);
209 ev_print_operation_set_default_page_setup (EvPrintOperation *op,
210 GtkPageSetup *page_setup)
212 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
214 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
215 g_return_if_fail (GTK_IS_PAGE_SETUP (page_setup));
217 class->set_default_page_setup (op, page_setup);
221 ev_print_operation_get_default_page_setup (EvPrintOperation *op)
223 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
225 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
227 return class->get_default_page_setup (op);
231 ev_print_operation_set_job_name (EvPrintOperation *op,
232 const gchar *job_name)
234 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
236 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
237 g_return_if_fail (job_name != NULL);
239 class->set_job_name (op, job_name);
243 ev_print_operation_get_job_name (EvPrintOperation *op)
245 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
247 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
249 return class->get_job_name (op);
253 ev_print_operation_run (EvPrintOperation *op,
256 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
258 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
260 class->run (op, parent);
264 ev_print_operation_cancel (EvPrintOperation *op)
266 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
268 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
274 ev_print_operation_get_error (EvPrintOperation *op,
277 EvPrintOperationClass *class = EV_PRINT_OPERATION_GET_CLASS (op);
279 g_return_if_fail (EV_IS_PRINT_OPERATION (op));
281 class->get_error (op, error);
285 ev_print_operation_get_status (EvPrintOperation *op)
287 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), NULL);
289 return op->status ? op->status : "";
293 ev_print_operation_get_progress (EvPrintOperation *op)
295 g_return_val_if_fail (EV_IS_PRINT_OPERATION (op), 0.0);
301 ev_print_operation_update_status (EvPrintOperation *op,
306 if (op->status && op->progress == progress)
313 op->status = g_strdup (_("Preparing to print ..."));
314 } else if (page > n_pages) {
315 op->status = g_strdup (_("Finishing..."));
317 op->status = g_strdup_printf (_("Printing page %d of %d..."),
321 op->progress = MIN (1.0, progress);
323 g_signal_emit (op, signals[STATUS_CHANGED], 0);
326 /* Export interface */
327 #define EV_TYPE_PRINT_OPERATION_EXPORT (ev_print_operation_export_get_type())
328 #define EV_PRINT_OPERATION_EXPORT(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PRINT_OPERATION_EXPORT, EvPrintOperationExport))
329 #define EV_PRINT_OPERATION_EXPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PRINT_OPERATION_EXPORT, EvPrintOperationExportClass))
330 #define EV_IS_PRINT_OPERATION_EXPORT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PRINT_OPERATION_EXPORT))
332 typedef struct _EvPrintOperationExport EvPrintOperationExport;
333 typedef struct _EvPrintOperationExportClass EvPrintOperationExportClass;
335 static GType ev_print_operation_export_get_type (void) G_GNUC_CONST;
337 static void ev_print_operation_export_begin (EvPrintOperationExport *export);
338 static gboolean export_print_page (EvPrintOperationExport *export);
339 static void export_cancel (EvPrintOperationExport *export);
341 struct _EvPrintOperationExport {
342 EvPrintOperation parent;
344 GtkWindow *parent_window;
348 gboolean print_preview;
352 GtkPageSetup *page_setup;
353 GtkPrintSettings *print_settings;
358 gint pages_per_sheet;
366 EvFileExporterContext fc;
367 gint n_pages_to_print;
368 gint uncollated_copies;
369 gint collated_copies;
370 gint uncollated, collated, total, blank;
372 gint range, n_ranges;
373 GtkPageRange *ranges;
374 GtkPageRange one_range;
376 gint page, start, end, inc;
379 struct _EvPrintOperationExportClass {
380 EvPrintOperationClass parent_class;
383 G_DEFINE_TYPE (EvPrintOperationExport, ev_print_operation_export, EV_TYPE_PRINT_OPERATION)
385 /* Internal print queue */
386 static GHashTable *print_queue = NULL;
389 queue_free (GQueue *queue)
391 g_queue_foreach (queue, (GFunc)g_object_unref, NULL);
392 g_queue_free (queue);
396 ev_print_queue_init (void)
398 if (G_UNLIKELY (print_queue == NULL)) {
399 print_queue = g_hash_table_new_full (g_direct_hash,
402 (GDestroyNotify)queue_free);
407 remove_document_queue (gpointer data,
411 g_hash_table_remove (print_queue, document);
415 ev_print_queue_is_empty (EvDocument *document)
419 queue = g_hash_table_lookup (print_queue, document);
420 return (!queue || g_queue_is_empty (queue));
424 ev_print_queue_push (EvPrintOperation *op)
428 queue = g_hash_table_lookup (print_queue, op->document);
430 queue = g_queue_new ();
431 g_hash_table_insert (print_queue,
434 g_object_weak_ref (G_OBJECT (op->document),
435 (GWeakNotify)remove_document_queue,
439 g_queue_push_head (queue, g_object_ref (op));
442 static EvPrintOperation *
443 ev_print_queue_pop (EvDocument *document)
445 EvPrintOperation *op;
448 queue = g_hash_table_lookup (print_queue, document);
449 if (!queue || g_queue_is_empty (queue))
452 op = g_queue_pop_tail (queue);
458 static EvPrintOperation *
459 ev_print_queue_peek (EvDocument *document)
463 queue = g_hash_table_lookup (print_queue, document);
464 if (!queue || g_queue_is_empty (queue))
467 return g_queue_peek_tail (queue);
471 ev_print_operation_export_set_current_page (EvPrintOperation *op,
474 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
476 g_return_if_fail (current_page < export->n_pages);
478 export->current_page = current_page;
482 ev_print_operation_export_set_print_settings (EvPrintOperation *op,
483 GtkPrintSettings *print_settings)
485 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
487 if (print_settings == export->print_settings)
490 g_object_ref (print_settings);
491 if (export->print_settings)
492 g_object_unref (export->print_settings);
493 export->print_settings = print_settings;
496 static GtkPrintSettings *
497 ev_print_operation_export_get_print_settings (EvPrintOperation *op)
499 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
501 return export->print_settings;
505 ev_print_operation_export_set_default_page_setup (EvPrintOperation *op,
506 GtkPageSetup *page_setup)
508 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
510 if (page_setup == export->page_setup)
513 g_object_ref (page_setup);
514 if (export->page_setup)
515 g_object_unref (export->page_setup);
516 export->page_setup = page_setup;
519 static GtkPageSetup *
520 ev_print_operation_export_get_default_page_setup (EvPrintOperation *op)
522 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
524 return export->page_setup;
528 ev_print_operation_export_set_job_name (EvPrintOperation *op,
529 const gchar *job_name)
531 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
533 g_free (export->job_name);
534 export->job_name = g_strdup (job_name);
538 ev_print_operation_export_get_job_name (EvPrintOperation *op)
540 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
542 return export->job_name;
546 ev_print_operation_export_set_printer (EvPrintOperationExport *export,
549 if (printer == export->printer)
552 g_object_ref (printer);
554 g_object_unref (export->printer);
555 export->printer = printer;
559 find_range (EvPrintOperationExport *export)
563 range = &export->ranges[export->range];
565 if (export->inc < 0) {
566 export->start = range->end;
567 export->end = range->start - 1;
569 export->start = range->start;
570 export->end = range->end + 1;
575 clamp_ranges (EvPrintOperationExport *export)
577 gint num_of_correct_ranges = 0;
578 gint n_pages_to_print = 0;
580 gboolean null_flag = FALSE;
582 for (i = 0; i < export->n_ranges; i++) {
585 if ((export->ranges[i].start >= 0) &&
586 (export->ranges[i].start < export->n_pages) &&
587 (export->ranges[i].end >= 0) &&
588 (export->ranges[i].end < export->n_pages)) {
589 export->ranges[num_of_correct_ranges] = export->ranges[i];
590 num_of_correct_ranges++;
591 } else if ((export->ranges[i].start >= 0) &&
592 (export->ranges[i].start < export->n_pages) &&
593 (export->ranges[i].end >= export->n_pages)) {
594 export->ranges[i].end = export->n_pages - 1;
595 export->ranges[num_of_correct_ranges] = export->ranges[i];
596 num_of_correct_ranges++;
597 } else if ((export->ranges[i].end >= 0) &&
598 (export->ranges[i].end < export->n_pages) &&
599 (export->ranges[i].start < 0)) {
600 export->ranges[i].start = 0;
601 export->ranges[num_of_correct_ranges] = export->ranges[i];
602 num_of_correct_ranges++;
605 n_pages = export->ranges[i].end - export->ranges[i].start + 1;
606 if (export->page_set == GTK_PAGE_SET_ALL) {
607 n_pages_to_print += n_pages;
608 } else if (n_pages % 2 == 0) {
609 n_pages_to_print += n_pages / 2;
610 } else if (export->page_set == GTK_PAGE_SET_EVEN) {
611 if (n_pages==1 && export->ranges[i].start % 2 == 0)
614 n_pages_to_print += export->ranges[i].start % 2 == 0 ?
615 n_pages / 2 : (n_pages / 2) + 1;
616 } else if (export->page_set == GTK_PAGE_SET_ODD) {
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) + 1 : n_pages / 2;
625 if (null_flag && !n_pages_to_print) {
628 export->n_ranges = num_of_correct_ranges;
629 export->n_pages_to_print = n_pages_to_print;
635 get_first_and_last_page (EvPrintOperationExport *export,
640 gint first_page = G_MAXINT;
641 gint last_page = G_MININT;
642 gint max_page = export->n_pages - 1;
644 if (export->n_ranges == 0) {
651 for (i = 0; i < export->n_ranges; i++) {
652 if (export->ranges[i].start < first_page)
653 first_page = export->ranges[i].start;
654 if (export->ranges[i].end > last_page)
655 last_page = export->ranges[i].end;
658 *first = MAX (0, first_page);
659 *last = MIN (max_page, last_page);
663 export_print_inc_page (EvPrintOperationExport *export)
666 export->page += export->inc;
667 if (export->page == export->end) {
668 export->range += export->inc;
669 if (export->range == -1 || export->range == export->n_ranges) {
670 export->uncollated++;
671 if (export->uncollated == export->uncollated_copies)
674 export->range = export->inc < 0 ? export->n_ranges - 1 : 0;
677 export->page = export->start;
679 } while ((export->page_set == GTK_PAGE_SET_EVEN && (export->page / export->pages_per_sheet) % 2 == 0) ||
680 (export->page_set == GTK_PAGE_SET_ODD && (export->page / export->pages_per_sheet) % 2 == 1));
686 ev_print_operation_export_clear_temp_file (EvPrintOperationExport *export)
688 if (!export->temp_file)
691 g_unlink (export->temp_file);
692 g_free (export->temp_file);
693 export->temp_file = NULL;
697 ev_print_operation_export_run_next (EvPrintOperationExport *export)
699 EvPrintOperation *op = EV_PRINT_OPERATION (export);
700 EvPrintOperation *next;
701 EvDocument *document;
703 /* First pop the current job */
704 document = op->document;
705 ev_print_queue_pop (document);
707 next = ev_print_queue_peek (document);
709 ev_print_operation_export_begin (EV_PRINT_OPERATION_EXPORT (next));
713 gtk_print_job_finished (GtkPrintJob *print_job,
714 EvPrintOperationExport *export,
717 EvPrintOperation *op = EV_PRINT_OPERATION (export);
720 g_set_error_literal (&export->error,
722 GTK_PRINT_ERROR_GENERAL,
724 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
726 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
729 ev_print_operation_export_clear_temp_file (export);
730 g_object_unref (print_job);
732 ev_print_operation_export_run_next (export);
736 export_print_done (EvPrintOperationExport *export)
738 EvPrintOperation *op = EV_PRINT_OPERATION (export);
739 GtkPrintSettings *settings;
740 EvFileExporterCapabilities capabilities;
741 GError *error = NULL;
743 g_assert (export->temp_file != NULL);
745 /* Some printers take into account some print settings,
746 * and others don't. However we have exported the document
747 * to a ps or pdf file according to such print settings. So,
748 * we want to send the exported file to printer with those
749 * settings set to default values.
751 settings = gtk_print_settings_copy (export->print_settings);
752 capabilities = ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
754 gtk_print_settings_set_page_ranges (settings, NULL, 0);
755 gtk_print_settings_set_print_pages (settings, GTK_PRINT_PAGES_ALL);
756 if (capabilities & EV_FILE_EXPORTER_CAN_COPIES)
757 gtk_print_settings_set_n_copies (settings, 1);
758 if (capabilities & EV_FILE_EXPORTER_CAN_PAGE_SET)
759 gtk_print_settings_set_page_set (settings, GTK_PAGE_SET_ALL);
760 if (capabilities & EV_FILE_EXPORTER_CAN_SCALE)
761 gtk_print_settings_set_scale (settings, 1.0);
762 if (capabilities & EV_FILE_EXPORTER_CAN_COLLATE)
763 gtk_print_settings_set_collate (settings, FALSE);
764 if (capabilities & EV_FILE_EXPORTER_CAN_REVERSE)
765 gtk_print_settings_set_reverse (settings, FALSE);
766 if (capabilities & EV_FILE_EXPORTER_CAN_NUMBER_UP) {
767 gtk_print_settings_set_number_up (settings, 1);
768 gtk_print_settings_set_int (settings, "cups-"GTK_PRINT_SETTINGS_NUMBER_UP, 1);
771 if (export->print_preview) {
775 gchar *print_settings_file = NULL;
777 key_file = g_key_file_new ();
779 gtk_print_settings_to_key_file (settings, key_file, NULL);
780 gtk_page_setup_to_key_file (export->page_setup, key_file, NULL);
781 g_key_file_set_string (key_file, "Print Job", "title", export->job_name);
783 data = g_key_file_to_data (key_file, &data_len, &error);
787 fd = g_file_open_tmp ("print-settingsXXXXXX", &print_settings_file, &error);
789 g_file_set_contents (print_settings_file, data, data_len, &error);
795 g_key_file_free (key_file);
801 gchar *quoted_filename;
802 gchar *quoted_settings_filename;
804 quoted_filename = g_shell_quote (export->temp_file);
805 quoted_settings_filename = g_shell_quote (print_settings_file);
806 cmd = g_strdup_printf ("evince-previewer --unlink-tempfile --print-settings %s %s",
807 quoted_settings_filename, quoted_filename);
809 g_shell_parse_argv (cmd, &argc, &argv, &error);
811 g_free (quoted_filename);
812 g_free (quoted_settings_filename);
816 gdk_spawn_on_screen (gtk_window_get_screen (export->parent_window),
827 if (print_settings_file)
828 g_unlink (print_settings_file);
829 g_free (print_settings_file);
831 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_APPLY);
832 /* temp_file will be deleted by the previewer */
834 ev_print_operation_export_run_next (export);
839 job = gtk_print_job_new (export->job_name,
843 gtk_print_job_set_source_file (job, export->temp_file, &error);
845 gtk_print_job_send (job,
846 (GtkPrintJobCompleteFunc)gtk_print_job_finished,
847 g_object_ref (export),
848 (GDestroyNotify)g_object_unref);
851 g_object_unref (settings);
854 g_set_error_literal (&export->error,
856 GTK_PRINT_ERROR_GENERAL,
858 g_error_free (error);
859 ev_print_operation_export_clear_temp_file (export);
860 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
862 ev_print_operation_export_run_next (export);
867 export_print_page_idle_finished (EvPrintOperationExport *export)
873 export_job_finished (EvJobExport *job,
874 EvPrintOperationExport *export)
876 EvPrintOperation *op = EV_PRINT_OPERATION (export);
878 if (export->pages_per_sheet == 1 || (export->total + export->blank) % export->pages_per_sheet == 0 ) {
879 ev_document_doc_mutex_lock ();
880 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
881 ev_document_doc_mutex_unlock ();
885 export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
886 (GSourceFunc)export_print_page,
888 (GDestroyNotify)export_print_page_idle_finished);
892 export_job_cancelled (EvJobExport *job,
893 EvPrintOperationExport *export)
895 export_cancel (export);
899 export_cancel (EvPrintOperationExport *export)
901 EvPrintOperation *op = EV_PRINT_OPERATION (export);
903 if (export->idle_id > 0)
904 g_source_remove (export->idle_id);
907 if (export->job_export) {
908 g_signal_handlers_disconnect_by_func (export->job_export,
911 g_signal_handlers_disconnect_by_func (export->job_export,
912 export_job_cancelled,
914 g_object_unref (export->job_export);
915 export->job_export = NULL;
918 if (export->fd != -1) {
923 ev_print_operation_export_clear_temp_file (export);
925 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
927 ev_print_operation_export_run_next (export);
931 update_progress (EvPrintOperationExport *export)
933 EvPrintOperation *op = EV_PRINT_OPERATION (export);
935 ev_print_operation_update_status (op, export->total,
936 export->n_pages_to_print,
937 export->total / (gdouble)export->n_pages_to_print);
941 export_print_page (EvPrintOperationExport *export)
943 EvPrintOperation *op = EV_PRINT_OPERATION (export);
945 if (!export->temp_file)
946 return FALSE; /* cancelled */
951 /* when printing multiple collated copies & multiple pages per sheet we want to
952 prevent the next copy bleeding into the last sheet of the previous one
953 we therefore check whether we've reached the last page in a document
954 if that is the case and the given sheet is not filled with pages,
955 we introduce a few blank pages to finish off the sheet
956 to make sure nothing goes wrong, the final condition ensures that
957 we're not at the end of a sheet, otherwise we'd introduce a blank sheet! */
959 if (export->collate == 1 && export->total > 1 && export->pages_per_sheet > 1 &&
960 (export->page + 1) % export->n_pages == 0 && (export->total - 1 + export->blank) % export->pages_per_sheet != 0) {
961 ev_document_doc_mutex_lock ();
962 ev_file_exporter_end_page (EV_FILE_EXPORTER (op->document));
963 /* keep track of how many blank pages have been added */
964 export->blank += export->pages_per_sheet - (export->total - 1 + export->blank) % export->pages_per_sheet;
965 ev_document_doc_mutex_unlock ();
969 if (export->collated == export->collated_copies) {
970 export->collated = 0;
971 if (!export_print_inc_page (export)) {
972 ev_document_doc_mutex_lock ();
973 ev_file_exporter_end (EV_FILE_EXPORTER (op->document));
974 ev_document_doc_mutex_unlock ();
978 update_progress (export);
979 export_print_done (export);
985 if (export->pages_per_sheet == 1 || (export->total + export->blank) % export->pages_per_sheet == 1) {
986 ev_document_doc_mutex_lock ();
987 ev_file_exporter_begin_page (EV_FILE_EXPORTER (op->document));
988 ev_document_doc_mutex_unlock ();
991 if (!export->job_export) {
992 export->job_export = ev_job_export_new (op->document);
993 g_signal_connect (export->job_export, "finished",
994 G_CALLBACK (export_job_finished),
996 g_signal_connect (export->job_export, "cancelled",
997 G_CALLBACK (export_job_cancelled),
1001 ev_job_export_set_page (EV_JOB_EXPORT (export->job_export), export->page);
1002 ev_job_scheduler_push_job (export->job_export, EV_JOB_PRIORITY_NONE);
1004 update_progress (export);
1010 ev_print_operation_export_begin (EvPrintOperationExport *export)
1012 EvPrintOperation *op = EV_PRINT_OPERATION (export);
1014 if (!export->temp_file)
1015 return; /* cancelled */
1017 ev_document_doc_mutex_lock ();
1018 ev_file_exporter_begin (EV_FILE_EXPORTER (op->document), &export->fc);
1019 ev_document_doc_mutex_unlock ();
1021 export->idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
1022 (GSourceFunc)export_print_page,
1024 (GDestroyNotify)export_print_page_idle_finished);
1028 ev_print_operation_export_print_dialog_response_cb (GtkDialog *dialog,
1030 EvPrintOperationExport *export)
1032 GtkPrintPages print_pages;
1033 GtkPrintSettings *print_settings;
1034 GtkPageSetup *page_setup;
1035 GtkPrinter *printer;
1041 const gchar *file_format;
1043 GError *error = NULL;
1044 EvPrintOperation *op = EV_PRINT_OPERATION (export);
1046 if (response != GTK_RESPONSE_OK &&
1047 response != GTK_RESPONSE_APPLY) {
1048 gtk_widget_destroy (GTK_WIDGET (dialog));
1049 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_CANCEL);
1054 export->print_preview = (response == GTK_RESPONSE_APPLY);
1056 printer = gtk_print_unix_dialog_get_selected_printer (GTK_PRINT_UNIX_DIALOG (dialog));
1057 ev_print_operation_export_set_printer (export, printer);
1059 print_settings = gtk_print_unix_dialog_get_settings (GTK_PRINT_UNIX_DIALOG (dialog));
1060 ev_print_operation_export_set_print_settings (op, print_settings);
1062 page_setup = gtk_print_unix_dialog_get_page_setup (GTK_PRINT_UNIX_DIALOG (dialog));
1063 ev_print_operation_export_set_default_page_setup (op, page_setup);
1065 if (!gtk_printer_accepts_ps (export->printer)) {
1066 gtk_widget_destroy (GTK_WIDGET (dialog));
1068 g_set_error_literal (&export->error,
1070 GTK_PRINT_ERROR_GENERAL,
1071 _("Printing is not supported on this printer."));
1072 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1077 file_format = gtk_print_settings_get (print_settings, GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT);
1079 filename = g_strdup_printf ("evince_print.%s.XXXXXX", file_format);
1080 export->fd = g_file_open_tmp (filename, &export->temp_file, &error);
1082 if (export->fd <= -1) {
1083 gtk_widget_destroy (GTK_WIDGET (dialog));
1085 g_set_error_literal (&export->error,
1087 GTK_PRINT_ERROR_GENERAL,
1089 g_error_free (error);
1090 g_signal_emit (op, signals[DONE], 0, GTK_PRINT_OPERATION_RESULT_ERROR);
1095 export->current_page = gtk_print_unix_dialog_get_current_page (GTK_PRINT_UNIX_DIALOG (dialog));
1096 export->page_set = gtk_print_settings_get_page_set (print_settings);
1097 print_pages = gtk_print_settings_get_print_pages (print_settings);
1099 switch (print_pages) {
1100 case GTK_PRINT_PAGES_CURRENT:
1101 export->ranges = &export->one_range;
1103 export->ranges[0].start = export->current_page;
1104 export->ranges[0].end = export->current_page;
1105 export->n_ranges = 1;
1108 case GTK_PRINT_PAGES_RANGES: {
1111 export->ranges = gtk_print_settings_get_page_ranges (print_settings, &export->n_ranges);
1112 for (i = 0; i < export->n_ranges; i++)
1113 if (export->ranges[i].end == -1 || export->ranges[i].end >= export->n_pages)
1114 export->ranges[i].end = export->n_pages - 1;
1117 case GTK_PRINT_PAGES_ALL:
1118 export->ranges = &export->one_range;
1120 export->ranges[0].start = 0;
1121 export->ranges[0].end = export->n_pages - 1;
1122 export->n_ranges = 1;
1126 if (export->n_ranges < 1 || !clamp_ranges (export)) {
1127 GtkWidget *message_dialog;
1129 message_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
1131 GTK_MESSAGE_WARNING,
1133 "%s", _("Invalid page selection"));
1134 gtk_window_set_title (GTK_WINDOW (message_dialog), _("Warning"));
1135 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message_dialog),
1136 "%s", _("Your print range selection does not include any page"));
1137 g_signal_connect (message_dialog, "response",
1138 G_CALLBACK (gtk_widget_destroy),
1140 gtk_widget_show (message_dialog);
1143 } else ev_print_operation_update_status (op, -1, -1, 0.0);
1145 width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_POINTS);
1146 height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_POINTS);
1147 scale = gtk_print_settings_get_scale (print_settings) * 0.01;
1153 export->pages_per_sheet = MAX (1, gtk_print_settings_get_number_up (print_settings));
1155 export->copies = gtk_print_settings_get_n_copies (print_settings);
1156 export->collate = gtk_print_settings_get_collate (print_settings);
1157 export->reverse = gtk_print_settings_get_reverse (print_settings);
1159 if (export->collate) {
1160 export->uncollated_copies = export->copies;
1161 export->collated_copies = 1;
1163 export->uncollated_copies = 1;
1164 export->collated_copies = export->copies;
1167 if (export->reverse) {
1168 export->range = export->n_ranges - 1;
1174 find_range (export);
1176 export->page = export->start - export->inc;
1177 export->collated = export->collated_copies - 1;
1179 get_first_and_last_page (export, &first_page, &last_page);
1181 export->fc.format = file_format && g_ascii_strcasecmp (file_format, "pdf") == 0 ?
1182 EV_FILE_FORMAT_PDF : EV_FILE_FORMAT_PS;
1183 export->fc.filename = export->temp_file;
1184 export->fc.first_page = MIN (first_page, last_page);
1185 export->fc.last_page = MAX (first_page, last_page);
1186 export->fc.paper_width = width;
1187 export->fc.paper_height = height;
1188 export->fc.duplex = FALSE;
1189 export->fc.pages_per_sheet = export->pages_per_sheet;
1191 if (ev_print_queue_is_empty (op->document))
1192 ev_print_operation_export_begin (export);
1194 ev_print_queue_push (op);
1196 g_signal_emit (op, signals[BEGIN_PRINT], 0);
1198 gtk_widget_destroy (GTK_WIDGET (dialog));
1202 ev_print_operation_export_run (EvPrintOperation *op,
1205 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1207 GtkPrintCapabilities capabilities;
1209 ev_print_queue_init ();
1211 export->parent_window = parent;
1212 export->error = NULL;
1214 dialog = gtk_print_unix_dialog_new (_("Print"), parent);
1215 gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
1217 capabilities = GTK_PRINT_CAPABILITY_PREVIEW |
1218 ev_file_exporter_get_capabilities (EV_FILE_EXPORTER (op->document));
1219 gtk_print_unix_dialog_set_manual_capabilities (GTK_PRINT_UNIX_DIALOG (dialog),
1222 gtk_print_unix_dialog_set_current_page (GTK_PRINT_UNIX_DIALOG (dialog),
1223 export->current_page);
1225 gtk_print_unix_dialog_set_settings (GTK_PRINT_UNIX_DIALOG (dialog),
1226 export->print_settings);
1228 if (export->page_setup)
1229 gtk_print_unix_dialog_set_page_setup (GTK_PRINT_UNIX_DIALOG (dialog),
1230 export->page_setup);
1232 g_signal_connect (dialog, "response",
1233 G_CALLBACK (ev_print_operation_export_print_dialog_response_cb),
1236 gtk_window_present (GTK_WINDOW (dialog));
1240 ev_print_operation_export_cancel (EvPrintOperation *op)
1242 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1244 if (export->job_export &&
1245 !ev_job_is_finished (export->job_export)) {
1246 ev_job_cancel (export->job_export);
1248 export_cancel (export);
1253 ev_print_operation_export_get_error (EvPrintOperation *op,
1256 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (op);
1258 g_propagate_error (error, export->error);
1259 export->error = NULL;
1263 ev_print_operation_export_finalize (GObject *object)
1265 EvPrintOperationExport *export = EV_PRINT_OPERATION_EXPORT (object);
1267 if (export->idle_id > 0) {
1268 g_source_remove (export->idle_id);
1269 export->idle_id = 0;
1272 if (export->fd != -1) {
1277 if (export->ranges) {
1278 if (export->ranges != &export->one_range)
1279 g_free (export->ranges);
1280 export->ranges = NULL;
1281 export->n_ranges = 0;
1284 if (export->temp_file) {
1285 g_free (export->temp_file);
1286 export->temp_file = NULL;
1289 if (export->job_name) {
1290 g_free (export->job_name);
1291 export->job_name = NULL;
1294 if (export->job_export) {
1295 if (!ev_job_is_finished (export->job_export))
1296 ev_job_cancel (export->job_export);
1297 g_signal_handlers_disconnect_by_func (export->job_export,
1298 export_job_finished,
1300 g_signal_handlers_disconnect_by_func (export->job_export,
1301 export_job_cancelled,
1303 g_object_unref (export->job_export);
1304 export->job_export = NULL;
1307 if (export->error) {
1308 g_error_free (export->error);
1309 export->error = NULL;
1312 if (export->print_settings) {
1313 g_object_unref (export->print_settings);
1314 export->print_settings = NULL;
1317 if (export->page_setup) {
1318 g_object_unref (export->page_setup);
1319 export->page_setup = NULL;
1322 if (export->printer) {
1323 g_object_unref (export->printer);
1324 export->printer = NULL;
1327 (* G_OBJECT_CLASS (ev_print_operation_export_parent_class)->finalize) (object);
1331 ev_print_operation_export_init (EvPrintOperationExport *export)
1336 ev_print_operation_export_constructor (GType type,
1337 guint n_construct_properties,
1338 GObjectConstructParam *construct_params)
1341 EvPrintOperationExport *export;
1342 EvPrintOperation *op;
1344 object = G_OBJECT_CLASS (ev_print_operation_export_parent_class)->constructor (type,
1345 n_construct_properties,
1347 export = EV_PRINT_OPERATION_EXPORT (object);
1348 op = EV_PRINT_OPERATION (object);
1349 export->n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1355 ev_print_operation_export_class_init (EvPrintOperationExportClass *klass)
1357 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
1358 EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1360 ev_print_op_class->set_current_page = ev_print_operation_export_set_current_page;
1361 ev_print_op_class->set_print_settings = ev_print_operation_export_set_print_settings;
1362 ev_print_op_class->get_print_settings = ev_print_operation_export_get_print_settings;
1363 ev_print_op_class->set_default_page_setup = ev_print_operation_export_set_default_page_setup;
1364 ev_print_op_class->get_default_page_setup = ev_print_operation_export_get_default_page_setup;
1365 ev_print_op_class->set_job_name = ev_print_operation_export_set_job_name;
1366 ev_print_op_class->get_job_name = ev_print_operation_export_get_job_name;
1367 ev_print_op_class->run = ev_print_operation_export_run;
1368 ev_print_op_class->cancel = ev_print_operation_export_cancel;
1369 ev_print_op_class->get_error = ev_print_operation_export_get_error;
1371 g_object_class->constructor = ev_print_operation_export_constructor;
1372 g_object_class->finalize = ev_print_operation_export_finalize;
1375 #if GTK_CHECK_VERSION (2, 17, 1)
1376 /* Print to cairo interface */
1377 #define EV_TYPE_PRINT_OPERATION_PRINT (ev_print_operation_print_get_type())
1378 #define EV_PRINT_OPERATION_PRINT(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PRINT_OPERATION_PRINT, EvPrintOperationPrint))
1379 #define EV_PRINT_OPERATION_PRINT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PRINT_OPERATION_PRINT, EvPrintOperationPrintClass))
1380 #define EV_IS_PRINT_OPERATION_PRINT(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PRINT_OPERATION_PRINT))
1382 typedef struct _EvPrintOperationPrint EvPrintOperationPrint;
1383 typedef struct _EvPrintOperationPrintClass EvPrintOperationPrintClass;
1385 static GType ev_print_operation_print_get_type (void) G_GNUC_CONST;
1387 struct _EvPrintOperationPrint {
1388 EvPrintOperation parent;
1390 GtkPrintOperation *op;
1395 struct _EvPrintOperationPrintClass {
1396 EvPrintOperationClass parent_class;
1399 G_DEFINE_TYPE (EvPrintOperationPrint, ev_print_operation_print, EV_TYPE_PRINT_OPERATION)
1402 ev_print_operation_print_set_current_page (EvPrintOperation *op,
1405 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1407 gtk_print_operation_set_current_page (print->op, current_page);
1411 ev_print_operation_print_set_print_settings (EvPrintOperation *op,
1412 GtkPrintSettings *print_settings)
1414 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1416 gtk_print_operation_set_print_settings (print->op, print_settings);
1419 static GtkPrintSettings *
1420 ev_print_operation_print_get_print_settings (EvPrintOperation *op)
1422 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1424 return gtk_print_operation_get_print_settings (print->op);
1428 ev_print_operation_print_set_default_page_setup (EvPrintOperation *op,
1429 GtkPageSetup *page_setup)
1431 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1433 gtk_print_operation_set_default_page_setup (print->op, page_setup);
1436 static GtkPageSetup *
1437 ev_print_operation_print_get_default_page_setup (EvPrintOperation *op)
1439 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1441 return gtk_print_operation_get_default_page_setup (print->op);
1445 ev_print_operation_print_set_job_name (EvPrintOperation *op,
1446 const gchar *job_name)
1448 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1450 g_free (print->job_name);
1451 print->job_name = g_strdup (job_name);
1453 gtk_print_operation_set_job_name (print->op, print->job_name);
1456 static const gchar *
1457 ev_print_operation_print_get_job_name (EvPrintOperation *op)
1459 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1461 if (!print->job_name) {
1464 g_object_get (print->op, "job_name", &name, NULL);
1465 print->job_name = name;
1468 return print->job_name;
1472 ev_print_operation_print_run (EvPrintOperation *op,
1475 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1477 gtk_print_operation_run (print->op,
1478 GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
1483 ev_print_operation_print_cancel (EvPrintOperation *op)
1485 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1487 gtk_print_operation_cancel (print->op);
1491 ev_print_operation_print_get_error (EvPrintOperation *op,
1494 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (op);
1496 gtk_print_operation_get_error (print->op, error);
1500 ev_print_operation_print_begin_print (EvPrintOperationPrint *print,
1501 GtkPrintContext *context)
1503 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1506 n_pages = ev_page_cache_get_n_pages (ev_page_cache_get (op->document));
1507 gtk_print_operation_set_n_pages (print->op, n_pages);
1509 /* FIXME: gtk_print should provide the progress */
1510 ev_print_operation_update_status (op, -1, n_pages, 0);
1512 g_signal_emit (op, signals[BEGIN_PRINT], 0);
1516 ev_print_operation_print_done (EvPrintOperationPrint *print,
1517 GtkPrintOperationResult result)
1519 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1521 /* FIXME: gtk_print should provide the progress */
1522 ev_print_operation_update_status (op, 0, 1, 1.0);
1524 g_signal_emit (op, signals[DONE], 0, result);
1528 print_job_finished (EvJobPrint *job,
1529 EvPrintOperationPrint *print)
1531 gtk_print_operation_draw_page_finish (print->op);
1532 ev_job_print_set_cairo (job, NULL);
1536 print_job_cancelled (EvJobPrint *job,
1537 EvPrintOperationPrint *print)
1539 gtk_print_operation_cancel (print->op);
1543 ev_print_operation_print_draw_page (EvPrintOperationPrint *print,
1544 GtkPrintContext *context,
1547 EvPrintOperation *op = EV_PRINT_OPERATION (print);
1550 gtk_print_operation_set_defer_drawing (print->op);
1552 if (!print->job_print) {
1553 print->job_print = ev_job_print_new (op->document);
1554 g_signal_connect (G_OBJECT (print->job_print), "finished",
1555 G_CALLBACK (print_job_finished),
1557 g_signal_connect (G_OBJECT (print->job_print), "cancelled",
1558 G_CALLBACK (print_job_cancelled),
1562 ev_job_print_set_page (EV_JOB_PRINT (print->job_print), page);
1564 cr = gtk_print_context_get_cairo_context (context);
1565 ev_job_print_set_cairo (EV_JOB_PRINT (print->job_print), cr);
1567 ev_job_scheduler_push_job (print->job_print, EV_JOB_PRIORITY_NONE);
1571 ev_print_operation_print_finalize (GObject *object)
1573 EvPrintOperationPrint *print = EV_PRINT_OPERATION_PRINT (object);
1576 g_object_unref (print->op);
1580 if (print->job_name) {
1581 g_free (print->job_name);
1582 print->job_name = NULL;
1585 if (print->job_print) {
1586 if (!ev_job_is_finished (print->job_print))
1587 ev_job_cancel (print->job_print);
1588 g_signal_handlers_disconnect_by_func (print->job_print,
1591 g_signal_handlers_disconnect_by_func (print->job_print,
1592 print_job_cancelled,
1594 g_object_unref (print->job_print);
1595 print->job_print = NULL;
1598 (* G_OBJECT_CLASS (ev_print_operation_print_parent_class)->finalize) (object);
1602 ev_print_operation_print_init (EvPrintOperationPrint *print)
1604 print->op = gtk_print_operation_new ();
1605 g_signal_connect_swapped (print->op, "begin_print",
1606 G_CALLBACK (ev_print_operation_print_begin_print),
1608 g_signal_connect_swapped (print->op, "done",
1609 G_CALLBACK (ev_print_operation_print_done),
1611 g_signal_connect_swapped (print->op, "draw_page",
1612 G_CALLBACK (ev_print_operation_print_draw_page),
1614 gtk_print_operation_set_allow_async (print->op, TRUE);
1618 ev_print_operation_print_class_init (EvPrintOperationPrintClass *klass)
1620 GObjectClass *g_object_class = G_OBJECT_CLASS (klass);
1621 EvPrintOperationClass *ev_print_op_class = EV_PRINT_OPERATION_CLASS (klass);
1623 ev_print_op_class->set_current_page = ev_print_operation_print_set_current_page;
1624 ev_print_op_class->set_print_settings = ev_print_operation_print_set_print_settings;
1625 ev_print_op_class->get_print_settings = ev_print_operation_print_get_print_settings;
1626 ev_print_op_class->set_default_page_setup = ev_print_operation_print_set_default_page_setup;
1627 ev_print_op_class->get_default_page_setup = ev_print_operation_print_get_default_page_setup;
1628 ev_print_op_class->set_job_name = ev_print_operation_print_set_job_name;
1629 ev_print_op_class->get_job_name = ev_print_operation_print_get_job_name;
1630 ev_print_op_class->run = ev_print_operation_print_run;
1631 ev_print_op_class->cancel = ev_print_operation_print_cancel;
1632 ev_print_op_class->get_error = ev_print_operation_print_get_error;
1634 g_object_class->finalize = ev_print_operation_print_finalize;
1636 #endif /* GTK_CHECK_VERSION (2, 17, 1) */
1638 /* Factory method */
1640 ev_print_operation_new (EvDocument *document)
1642 EvPrintOperation *op;
1644 #if GTK_CHECK_VERSION (2, 17, 1)
1645 if (EV_IS_DOCUMENT_PRINT (document))
1646 op = EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_PRINT,
1647 "document", document, NULL));
1650 op = EV_PRINT_OPERATION (g_object_new (EV_TYPE_PRINT_OPERATION_EXPORT,
1651 "document", document, NULL));