2 * Copyright (C) 2006 John (J5) Palmieri <johnp@redhat.com>
3 * Copyright (C) 2006 Alexander Larsson <alexl@redhat.com>
4 * Copyright © 2006, 2007 Christian Persch
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
30 #include "gtkprivate.h"
32 #include "gtkspinbutton.h"
33 #include "gtkcellrendererpixbuf.h"
34 #include "gtkcellrenderertext.h"
36 #include "gtkiconfactory.h"
38 #include "gtktreeselection.h"
39 #include "gtknotebook.h"
40 #include "gtkscrolledwindow.h"
41 #include "gtkcombobox.h"
42 #include "gtktogglebutton.h"
43 #include "gtkradiobutton.h"
44 #include "gtkdrawingarea.h"
48 #include "gtkalignment.h"
50 #include "gtkeventbox.h"
51 #include "gtkbuildable.h"
53 #include "gtkcustompaperunixdialog.h"
54 #include "gtkprintbackend.h"
55 #include "gtkprinter-private.h"
56 #include "gtkprintunixdialog.h"
57 #include "gtkprinteroptionwidget.h"
58 #include "gtkprintutils.h"
60 #include "gtkmessagedialog.h"
61 #include "gtkbutton.h"
63 #define EXAMPLE_PAGE_AREA_SIZE 140
64 #define RULER_DISTANCE 7.5
65 #define RULER_RADIUS 2
68 #define GTK_PRINT_UNIX_DIALOG_GET_PRIVATE(o) \
69 (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINT_UNIX_DIALOG, GtkPrintUnixDialogPrivate))
71 static void gtk_print_unix_dialog_destroy (GtkPrintUnixDialog *dialog);
72 static void gtk_print_unix_dialog_finalize (GObject *object);
73 static void gtk_print_unix_dialog_set_property (GObject *object,
77 static void gtk_print_unix_dialog_get_property (GObject *object,
81 static void gtk_print_unix_dialog_style_set (GtkWidget *widget,
82 GtkStyle *previous_style);
83 static void populate_dialog (GtkPrintUnixDialog *dialog);
84 static void unschedule_idle_mark_conflicts (GtkPrintUnixDialog *dialog);
85 static void selected_printer_changed (GtkTreeSelection *selection,
86 GtkPrintUnixDialog *dialog);
87 static void clear_per_printer_ui (GtkPrintUnixDialog *dialog);
88 static void printer_added_cb (GtkPrintBackend *backend,
90 GtkPrintUnixDialog *dialog);
91 static void printer_removed_cb (GtkPrintBackend *backend,
93 GtkPrintUnixDialog *dialog);
94 static void printer_status_cb (GtkPrintBackend *backend,
96 GtkPrintUnixDialog *dialog);
97 static void update_collate_icon (GtkToggleButton *toggle_button,
98 GtkPrintUnixDialog *dialog);
99 static gboolean dialog_get_collate (GtkPrintUnixDialog *dialog);
100 static gboolean dialog_get_reverse (GtkPrintUnixDialog *dialog);
101 static gint dialog_get_n_copies (GtkPrintUnixDialog *dialog);
103 static void set_cell_sensitivity_func (GtkTreeViewColumn *tree_column,
104 GtkCellRenderer *cell,
108 static gboolean set_active_printer (GtkPrintUnixDialog *dialog,
109 const gchar *printer_name);
110 static void redraw_page_layout_preview (GtkPrintUnixDialog *dialog);
113 static void gtk_print_unix_dialog_buildable_init (GtkBuildableIface *iface);
114 static GObject *gtk_print_unix_dialog_buildable_get_internal_child (GtkBuildable *buildable,
116 const gchar *childname);
118 static const gchar const common_paper_sizes[][16] = {
134 PAGE_SETUP_LIST_COL_PAGE_SETUP,
135 PAGE_SETUP_LIST_COL_IS_SEPARATOR,
136 PAGE_SETUP_LIST_N_COLS
144 PROP_SELECTED_PRINTER,
145 PROP_MANUAL_CAPABILITIES,
146 PROP_SUPPORT_SELECTION,
148 PROP_EMBED_PAGE_SETUP
152 PRINTER_LIST_COL_ICON,
153 PRINTER_LIST_COL_NAME,
154 PRINTER_LIST_COL_STATE,
155 PRINTER_LIST_COL_JOBS,
156 PRINTER_LIST_COL_LOCATION,
157 PRINTER_LIST_COL_PRINTER_OBJ,
161 struct GtkPrintUnixDialogPrivate
165 GtkWidget *printer_treeview;
167 GtkPrintCapabilities manual_capabilities;
168 GtkPrintCapabilities printer_capabilities;
170 GtkTreeModel *printer_list;
171 GtkTreeModelFilter *printer_list_filter;
173 GtkPageSetup *page_setup;
174 gboolean page_setup_set;
175 gboolean embed_page_setup;
176 GtkListStore *page_setup_list;
177 GtkListStore *custom_paper_list;
179 gboolean support_selection;
180 gboolean has_selection;
182 GtkWidget *all_pages_radio;
183 GtkWidget *current_page_radio;
184 GtkWidget *selection_radio;
185 GtkWidget *range_table;
186 GtkWidget *page_range_radio;
187 GtkWidget *page_range_entry;
189 GtkWidget *copies_spin;
190 GtkWidget *collate_check;
191 GtkWidget *reverse_check;
192 GtkWidget *collate_image;
193 GtkWidget *page_layout_preview;
194 GtkWidget *scale_spin;
195 GtkWidget *page_set_combo;
196 GtkWidget *print_now_radio;
197 GtkWidget *print_at_radio;
198 GtkWidget *print_at_entry;
199 GtkWidget *print_hold_radio;
200 GtkWidget *preview_button;
201 GtkWidget *paper_size_combo;
202 GtkWidget *paper_size_combo_label;
203 GtkWidget *orientation_combo;
204 GtkWidget *orientation_combo_label;
205 gboolean internal_page_setup_change;
206 gboolean updating_print_at;
207 GtkPrinterOptionWidget *pages_per_sheet;
208 GtkPrinterOptionWidget *duplex;
209 GtkPrinterOptionWidget *paper_type;
210 GtkPrinterOptionWidget *paper_source;
211 GtkPrinterOptionWidget *output_tray;
212 GtkPrinterOptionWidget *job_prio;
213 GtkPrinterOptionWidget *billing_info;
214 GtkPrinterOptionWidget *cover_before;
215 GtkPrinterOptionWidget *cover_after;
216 GtkPrinterOptionWidget *number_up_layout;
218 GtkWidget *conflicts_widget;
221 GtkWidget *finishing_table;
222 GtkWidget *finishing_page;
223 GtkWidget *image_quality_table;
224 GtkWidget *image_quality_page;
225 GtkWidget *color_table;
226 GtkWidget *color_page;
228 GtkWidget *advanced_vbox;
229 GtkWidget *advanced_page;
231 GtkWidget *extension_point;
233 /* These are set initially on selected printer (either default printer,
234 * printer taken from set settings, or user-selected), but when any
235 * setting is changed by the user it is cleared.
237 GtkPrintSettings *initial_settings;
239 GtkPrinterOption *number_up_layout_n_option;
240 GtkPrinterOption *number_up_layout_2_option;
242 /* This is the initial printer set by set_settings. We look for it in
243 * the added printers. We clear this whenever the user manually changes
244 * to another printer, when the user changes a setting or when we find
247 char *waiting_for_printer;
248 gboolean internal_printer_change;
250 GList *print_backends;
252 GtkPrinter *current_printer;
253 GtkPrinter *request_details_printer;
254 guint request_details_tag;
255 GtkPrinterOptionSet *options;
256 gulong options_changed_handler;
257 gulong mark_conflicts_id;
259 gchar *format_for_printer;
264 G_DEFINE_TYPE_WITH_CODE (GtkPrintUnixDialog, gtk_print_unix_dialog, GTK_TYPE_DIALOG,
265 G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
266 gtk_print_unix_dialog_buildable_init))
268 static GtkBuildableIface *parent_buildable_iface;
271 is_default_printer (GtkPrintUnixDialog *dialog,
274 GtkPrintUnixDialogPrivate *priv = dialog->priv;
276 if (priv->format_for_printer)
277 return strcmp (priv->format_for_printer,
278 gtk_printer_get_name (printer)) == 0;
280 return gtk_printer_is_default (printer);
284 gtk_print_unix_dialog_class_init (GtkPrintUnixDialogClass *class)
286 GObjectClass *object_class;
287 GtkWidgetClass *widget_class;
289 object_class = (GObjectClass *) class;
290 widget_class = (GtkWidgetClass *) class;
292 object_class->finalize = gtk_print_unix_dialog_finalize;
293 object_class->set_property = gtk_print_unix_dialog_set_property;
294 object_class->get_property = gtk_print_unix_dialog_get_property;
296 widget_class->style_set = gtk_print_unix_dialog_style_set;
298 g_object_class_install_property (object_class,
300 g_param_spec_object ("page-setup",
302 P_("The GtkPageSetup to use"),
304 GTK_PARAM_READWRITE));
306 g_object_class_install_property (object_class,
308 g_param_spec_int ("current-page",
310 P_("The current page in the document"),
314 GTK_PARAM_READWRITE));
316 g_object_class_install_property (object_class,
318 g_param_spec_object ("print-settings",
319 P_("Print Settings"),
320 P_("The GtkPrintSettings used for initializing the dialog"),
321 GTK_TYPE_PRINT_SETTINGS,
322 GTK_PARAM_READWRITE));
324 g_object_class_install_property (object_class,
325 PROP_SELECTED_PRINTER,
326 g_param_spec_object ("selected-printer",
327 P_("Selected Printer"),
328 P_("The GtkPrinter which is selected"),
330 GTK_PARAM_READABLE));
332 g_object_class_install_property (object_class,
333 PROP_MANUAL_CAPABILITIES,
334 g_param_spec_flags ("manual-capabilities",
335 P_("Manual Capabilites"),
336 P_("Capabilities the application can handle"),
337 GTK_TYPE_PRINT_CAPABILITIES,
339 GTK_PARAM_READWRITE));
341 g_object_class_install_property (object_class,
342 PROP_SUPPORT_SELECTION,
343 g_param_spec_boolean ("support-selection",
344 P_("Support Selection"),
345 P_("Whether the dialog supports selection"),
347 GTK_PARAM_READWRITE));
349 g_object_class_install_property (object_class,
351 g_param_spec_boolean ("has-selection",
353 P_("Whether the application has a selection"),
355 GTK_PARAM_READWRITE));
357 g_object_class_install_property (object_class,
358 PROP_EMBED_PAGE_SETUP,
359 g_param_spec_boolean ("embed-page-setup",
360 P_("Embed Page Setup"),
361 P_("TRUE if page setup combos are embedded in GtkPrintUnixDialog"),
363 GTK_PARAM_READWRITE));
365 g_type_class_add_private (class, sizeof (GtkPrintUnixDialogPrivate));
368 /* Returns a toplevel GtkWindow, or NULL if none */
370 get_toplevel (GtkWidget *widget)
372 GtkWidget *toplevel = NULL;
374 toplevel = gtk_widget_get_toplevel (widget);
375 if (!gtk_widget_is_toplevel (toplevel))
378 return GTK_WINDOW (toplevel);
382 set_busy_cursor (GtkPrintUnixDialog *dialog,
389 toplevel = get_toplevel (GTK_WIDGET (dialog));
390 if (!toplevel || !gtk_widget_get_realized (GTK_WIDGET (toplevel)))
393 display = gtk_widget_get_display (GTK_WIDGET (toplevel));
396 cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
400 gdk_window_set_cursor (GTK_WIDGET (toplevel)->window, cursor);
401 gdk_display_flush (display);
404 gdk_cursor_unref (cursor);
408 add_custom_button_to_dialog (GtkDialog *dialog,
409 const gchar *mnemonic_label,
410 const gchar *stock_id,
413 GtkWidget *button = NULL;
415 button = gtk_button_new_with_mnemonic (mnemonic_label);
416 gtk_widget_set_can_default (button, TRUE);
417 gtk_button_set_image (GTK_BUTTON (button),
418 gtk_image_new_from_stock (stock_id,
419 GTK_ICON_SIZE_BUTTON));
420 gtk_widget_show (button);
422 gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, response_id);
425 /* This function handles error messages before printing.
428 error_dialogs (GtkPrintUnixDialog *print_dialog,
429 gint print_dialog_response_id,
432 GtkPrintUnixDialogPrivate *priv = print_dialog->priv;
433 GtkPrinterOption *option = NULL;
434 GtkPrinter *printer = NULL;
435 GtkWindow *toplevel = NULL;
436 GtkWidget *dialog = NULL;
438 gchar *basename = NULL;
439 gchar *dirname = NULL;
442 if (print_dialog != NULL && print_dialog_response_id == GTK_RESPONSE_OK)
444 printer = gtk_print_unix_dialog_get_selected_printer (print_dialog);
448 if (priv->request_details_tag || !gtk_printer_is_accepting_jobs (printer))
450 g_signal_stop_emission_by_name (print_dialog, "response");
454 /* Shows overwrite confirmation dialog in the case of printing to file which
456 if (gtk_printer_is_virtual (printer))
458 option = gtk_printer_option_set_lookup (priv->options,
459 "gtk-main-page-custom-input");
461 if (option != NULL &&
462 option->type == GTK_PRINTER_OPTION_TYPE_FILESAVE)
464 file = g_file_new_for_uri (option->value);
467 g_file_query_exists (file, NULL))
469 toplevel = get_toplevel (GTK_WIDGET (print_dialog));
471 basename = g_file_get_basename (file);
472 dirname = g_file_get_parse_name (g_file_get_parent (file));
474 dialog = gtk_message_dialog_new (toplevel,
476 GTK_DIALOG_DESTROY_WITH_PARENT,
477 GTK_MESSAGE_QUESTION,
479 _("A file named \"%s\" already exists. Do you want to replace it?"),
482 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
483 _("The file already exists in \"%s\". Replacing it will "
484 "overwrite its contents."),
487 gtk_dialog_add_button (GTK_DIALOG (dialog),
488 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
489 add_custom_button_to_dialog (GTK_DIALOG (dialog),
492 GTK_RESPONSE_ACCEPT);
493 gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
497 gtk_dialog_set_default_response (GTK_DIALOG (dialog),
498 GTK_RESPONSE_ACCEPT);
501 gtk_window_group_add_window (toplevel->group,
502 GTK_WINDOW (dialog));
504 response = gtk_dialog_run (GTK_DIALOG (dialog));
506 gtk_widget_destroy (dialog);
511 if (response != GTK_RESPONSE_ACCEPT)
513 g_signal_stop_emission_by_name (print_dialog, "response");
514 g_object_unref (file);
519 g_object_unref (file);
528 gtk_print_unix_dialog_init (GtkPrintUnixDialog *dialog)
530 GtkPrintUnixDialogPrivate *priv = dialog->priv;
532 priv = dialog->priv = GTK_PRINT_UNIX_DIALOG_GET_PRIVATE (dialog);
533 priv->print_backends = NULL;
534 priv->current_page = -1;
535 priv->number_up_layout_n_option = NULL;
536 priv->number_up_layout_2_option = NULL;
538 priv->page_setup = gtk_page_setup_new ();
539 priv->page_setup_set = FALSE;
540 priv->embed_page_setup = FALSE;
541 priv->internal_page_setup_change = FALSE;
543 priv->support_selection = FALSE;
544 priv->has_selection = FALSE;
546 g_signal_connect (dialog,
548 (GCallback) gtk_print_unix_dialog_destroy,
551 g_signal_connect (dialog,
553 (GCallback) error_dialogs,
556 g_signal_connect (dialog,
557 "notify::page-setup",
558 (GCallback) redraw_page_layout_preview,
561 priv->preview_button = gtk_button_new_from_stock (GTK_STOCK_PRINT_PREVIEW);
562 gtk_widget_show (priv->preview_button);
564 gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
565 priv->preview_button,
567 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
568 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
569 GTK_STOCK_PRINT, GTK_RESPONSE_OK,
571 gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
577 gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
578 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
580 priv->page_setup_list = gtk_list_store_new (PAGE_SETUP_LIST_N_COLS,
584 priv->custom_paper_list = gtk_list_store_new (1, G_TYPE_OBJECT);
585 _gtk_print_load_custom_papers (priv->custom_paper_list);
587 populate_dialog (dialog);
591 gtk_print_unix_dialog_destroy (GtkPrintUnixDialog *dialog)
593 /* Make sure we don't destroy custom widgets owned by the backends */
594 clear_per_printer_ui (dialog);
598 disconnect_printer_details_request (GtkPrintUnixDialog *dialog, gboolean details_failed)
600 GtkPrintUnixDialogPrivate *priv = dialog->priv;
602 if (priv->request_details_tag)
604 g_signal_handler_disconnect (priv->request_details_printer,
605 priv->request_details_tag);
606 priv->request_details_tag = 0;
607 set_busy_cursor (dialog, FALSE);
609 gtk_list_store_set (GTK_LIST_STORE (priv->printer_list),
610 g_object_get_data (G_OBJECT (priv->request_details_printer),
611 "gtk-print-tree-iter"),
612 PRINTER_LIST_COL_STATE,
613 _("Getting printer information failed"),
616 gtk_list_store_set (GTK_LIST_STORE (priv->printer_list),
617 g_object_get_data (G_OBJECT (priv->request_details_printer),
618 "gtk-print-tree-iter"),
619 PRINTER_LIST_COL_STATE,
620 gtk_printer_get_state_message (priv->request_details_printer),
622 g_object_unref (priv->request_details_printer);
623 priv->request_details_printer = NULL;
628 gtk_print_unix_dialog_finalize (GObject *object)
630 GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
631 GtkPrintUnixDialogPrivate *priv = dialog->priv;
632 GtkPrintBackend *backend;
635 unschedule_idle_mark_conflicts (dialog);
636 disconnect_printer_details_request (dialog, FALSE);
638 if (priv->current_printer)
640 g_object_unref (priv->current_printer);
641 priv->current_printer = NULL;
644 if (priv->printer_list)
646 g_object_unref (priv->printer_list);
647 priv->printer_list = NULL;
650 if (priv->custom_paper_list)
652 g_object_unref (priv->custom_paper_list);
653 priv->custom_paper_list = NULL;
656 if (priv->printer_list_filter)
658 g_object_unref (priv->printer_list_filter);
659 priv->printer_list_filter = NULL;
664 g_object_unref (priv->options);
665 priv->options = NULL;
668 if (priv->number_up_layout_2_option)
670 priv->number_up_layout_2_option->choices[0] = NULL;
671 priv->number_up_layout_2_option->choices[1] = NULL;
672 g_free (priv->number_up_layout_2_option->choices_display[0]);
673 g_free (priv->number_up_layout_2_option->choices_display[1]);
674 priv->number_up_layout_2_option->choices_display[0] = NULL;
675 priv->number_up_layout_2_option->choices_display[1] = NULL;
676 g_object_unref (priv->number_up_layout_2_option);
677 priv->number_up_layout_2_option = NULL;
680 if (priv->number_up_layout_n_option)
682 g_object_unref (priv->number_up_layout_n_option);
683 priv->number_up_layout_n_option = NULL;
686 if (priv->page_setup)
688 g_object_unref (priv->page_setup);
689 priv->page_setup = NULL;
692 if (priv->initial_settings)
694 g_object_unref (priv->initial_settings);
695 priv->initial_settings = NULL;
698 g_free (priv->waiting_for_printer);
699 priv->waiting_for_printer = NULL;
701 g_free (priv->format_for_printer);
702 priv->format_for_printer = NULL;
704 for (node = priv->print_backends; node != NULL; node = node->next)
706 backend = GTK_PRINT_BACKEND (node->data);
708 g_signal_handlers_disconnect_by_func (backend, printer_added_cb, dialog);
709 g_signal_handlers_disconnect_by_func (backend, printer_removed_cb, dialog);
710 g_signal_handlers_disconnect_by_func (backend, printer_status_cb, dialog);
712 gtk_print_backend_destroy (backend);
713 g_object_unref (backend);
716 g_list_free (priv->print_backends);
717 priv->print_backends = NULL;
719 if (priv->page_setup_list)
721 g_object_unref (priv->page_setup_list);
722 priv->page_setup_list = NULL;
725 G_OBJECT_CLASS (gtk_print_unix_dialog_parent_class)->finalize (object);
729 printer_removed_cb (GtkPrintBackend *backend,
731 GtkPrintUnixDialog *dialog)
733 GtkPrintUnixDialogPrivate *priv = dialog->priv;
736 iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");
737 gtk_list_store_remove (GTK_LIST_STORE (priv->printer_list), iter);
741 gtk_print_unix_dialog_buildable_init (GtkBuildableIface *iface)
743 parent_buildable_iface = g_type_interface_peek_parent (iface);
745 iface->get_internal_child = gtk_print_unix_dialog_buildable_get_internal_child;
749 gtk_print_unix_dialog_buildable_get_internal_child (GtkBuildable *buildable,
751 const gchar *childname)
753 if (strcmp (childname, "notebook") == 0)
754 return G_OBJECT (GTK_PRINT_UNIX_DIALOG (buildable)->priv->notebook);
756 return parent_buildable_iface->get_internal_child (buildable, builder, childname);
759 /* This function controls "sensitive" property of GtkCellRenderer based on pause
760 * state of printers. */
761 void set_cell_sensitivity_func (GtkTreeViewColumn *tree_column,
762 GtkCellRenderer *cell,
763 GtkTreeModel *tree_model,
769 gtk_tree_model_get (tree_model, iter, PRINTER_LIST_COL_PRINTER_OBJ, &printer, -1);
771 if (printer != NULL && !gtk_printer_is_accepting_jobs (printer))
782 printer_status_cb (GtkPrintBackend *backend,
784 GtkPrintUnixDialog *dialog)
786 GtkPrintUnixDialogPrivate *priv = dialog->priv;
788 GtkTreeSelection *selection;
790 iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");
792 gtk_list_store_set (GTK_LIST_STORE (priv->printer_list), iter,
793 PRINTER_LIST_COL_ICON, gtk_printer_get_icon_name (printer),
794 PRINTER_LIST_COL_STATE, gtk_printer_get_state_message (printer),
795 PRINTER_LIST_COL_JOBS, gtk_printer_get_job_count (printer),
796 PRINTER_LIST_COL_LOCATION, gtk_printer_get_location (printer),
799 /* When the pause state change then we need to update sensitive property
800 * of GTK_RESPONSE_OK button inside of selected_printer_changed function. */
801 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
802 selected_printer_changed (selection, dialog);
804 if (gtk_print_backend_printer_list_is_done (backend) &&
805 gtk_printer_is_default (printer) &&
806 (gtk_tree_selection_count_selected_rows (selection) == 0))
807 set_active_printer (dialog, gtk_printer_get_name (printer));
811 printer_added_cb (GtkPrintBackend *backend,
813 GtkPrintUnixDialog *dialog)
815 GtkPrintUnixDialogPrivate *priv = dialog->priv;
816 GtkTreeIter iter, filter_iter;
817 GtkTreeSelection *selection;
820 gtk_list_store_append (GTK_LIST_STORE (priv->printer_list), &iter);
822 g_object_set_data_full (G_OBJECT (printer),
823 "gtk-print-tree-iter",
824 gtk_tree_iter_copy (&iter),
825 (GDestroyNotify) gtk_tree_iter_free);
827 gtk_list_store_set (GTK_LIST_STORE (priv->printer_list), &iter,
828 PRINTER_LIST_COL_ICON, gtk_printer_get_icon_name (printer),
829 PRINTER_LIST_COL_NAME, gtk_printer_get_name (printer),
830 PRINTER_LIST_COL_STATE, gtk_printer_get_state_message (printer),
831 PRINTER_LIST_COL_JOBS, gtk_printer_get_job_count (printer),
832 PRINTER_LIST_COL_LOCATION, gtk_printer_get_location (printer),
833 PRINTER_LIST_COL_PRINTER_OBJ, printer,
836 gtk_tree_model_filter_convert_child_iter_to_iter (priv->printer_list_filter,
837 &filter_iter, &iter);
838 path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->printer_list_filter), &filter_iter);
840 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
842 if (priv->waiting_for_printer != NULL &&
843 strcmp (gtk_printer_get_name (printer),
844 priv->waiting_for_printer) == 0)
846 priv->internal_printer_change = TRUE;
847 gtk_tree_selection_select_iter (selection, &filter_iter);
848 gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->printer_treeview),
849 path, NULL, TRUE, 0.5, 0.0);
850 priv->internal_printer_change = FALSE;
851 g_free (priv->waiting_for_printer);
852 priv->waiting_for_printer = NULL;
854 else if (is_default_printer (dialog, printer) &&
855 gtk_tree_selection_count_selected_rows (selection) == 0)
857 priv->internal_printer_change = TRUE;
858 gtk_tree_selection_select_iter (selection, &filter_iter);
859 gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->printer_treeview),
860 path, NULL, TRUE, 0.5, 0.0);
861 priv->internal_printer_change = FALSE;
864 gtk_tree_path_free (path);
868 printer_list_initialize (GtkPrintUnixDialog *dialog,
869 GtkPrintBackend *print_backend)
874 g_return_if_fail (print_backend != NULL);
876 g_signal_connect_object (print_backend,
878 (GCallback) printer_added_cb,
879 G_OBJECT (dialog), 0);
881 g_signal_connect_object (print_backend,
883 (GCallback) printer_removed_cb,
884 G_OBJECT (dialog), 0);
886 g_signal_connect_object (print_backend,
887 "printer-status-changed",
888 (GCallback) printer_status_cb,
889 G_OBJECT (dialog), 0);
891 list = gtk_print_backend_get_printer_list (print_backend);
896 printer_added_cb (print_backend, node->data, dialog);
904 load_print_backends (GtkPrintUnixDialog *dialog)
906 GtkPrintUnixDialogPrivate *priv = dialog->priv;
909 if (g_module_supported ())
910 priv->print_backends = gtk_print_backend_load_modules ();
912 for (node = priv->print_backends; node != NULL; node = node->next)
914 GtkPrintBackend *backend = node->data;
915 printer_list_initialize (dialog, backend);
920 gtk_print_unix_dialog_set_property (GObject *object,
926 GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
930 case PROP_PAGE_SETUP:
931 gtk_print_unix_dialog_set_page_setup (dialog, g_value_get_object (value));
933 case PROP_CURRENT_PAGE:
934 gtk_print_unix_dialog_set_current_page (dialog, g_value_get_int (value));
936 case PROP_PRINT_SETTINGS:
937 gtk_print_unix_dialog_set_settings (dialog, g_value_get_object (value));
939 case PROP_MANUAL_CAPABILITIES:
940 gtk_print_unix_dialog_set_manual_capabilities (dialog, g_value_get_flags (value));
942 case PROP_SUPPORT_SELECTION:
943 gtk_print_unix_dialog_set_support_selection (dialog, g_value_get_boolean (value));
945 case PROP_HAS_SELECTION:
946 gtk_print_unix_dialog_set_has_selection (dialog, g_value_get_boolean (value));
948 case PROP_EMBED_PAGE_SETUP:
949 gtk_print_unix_dialog_set_embed_page_setup (dialog, g_value_get_boolean (value));
952 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
958 gtk_print_unix_dialog_get_property (GObject *object,
963 GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
964 GtkPrintUnixDialogPrivate *priv = dialog->priv;
968 case PROP_PAGE_SETUP:
969 g_value_set_object (value, priv->page_setup);
971 case PROP_CURRENT_PAGE:
972 g_value_set_int (value, priv->current_page);
974 case PROP_PRINT_SETTINGS:
975 g_value_take_object (value, gtk_print_unix_dialog_get_settings (dialog));
977 case PROP_SELECTED_PRINTER:
978 g_value_set_object (value, priv->current_printer);
980 case PROP_MANUAL_CAPABILITIES:
981 g_value_set_flags (value, priv->manual_capabilities);
983 case PROP_SUPPORT_SELECTION:
984 g_value_set_boolean (value, priv->support_selection);
986 case PROP_HAS_SELECTION:
987 g_value_set_boolean (value, priv->has_selection);
989 case PROP_EMBED_PAGE_SETUP:
990 g_value_set_boolean (value, priv->embed_page_setup);
993 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
999 is_printer_active (GtkTreeModel *model,
1001 GtkPrintUnixDialog *dialog)
1004 GtkPrinter *printer;
1005 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1007 gtk_tree_model_get (model,
1009 PRINTER_LIST_COL_PRINTER_OBJ,
1013 if (printer == NULL)
1016 result = gtk_printer_is_active (printer);
1019 priv->manual_capabilities & (GTK_PRINT_CAPABILITY_GENERATE_PDF |
1020 GTK_PRINT_CAPABILITY_GENERATE_PS))
1022 /* Check that the printer can handle at least one of the data
1023 * formats that the application supports.
1025 result = ((priv->manual_capabilities & GTK_PRINT_CAPABILITY_GENERATE_PDF) &&
1026 gtk_printer_accepts_pdf (printer)) ||
1027 ((priv->manual_capabilities & GTK_PRINT_CAPABILITY_GENERATE_PS) &&
1028 gtk_printer_accepts_ps (printer));
1031 g_object_unref (printer);
1037 default_printer_list_sort_func (GtkTreeModel *model,
1044 GtkPrinter *a_printer;
1045 GtkPrinter *b_printer;
1048 gtk_tree_model_get (model, a,
1049 PRINTER_LIST_COL_NAME, &a_name,
1050 PRINTER_LIST_COL_PRINTER_OBJ, &a_printer,
1052 gtk_tree_model_get (model, b,
1053 PRINTER_LIST_COL_NAME, &b_name,
1054 PRINTER_LIST_COL_PRINTER_OBJ, &b_printer,
1057 if (a_printer == NULL && b_printer == NULL)
1059 else if (a_printer == NULL)
1061 else if (b_printer == NULL)
1063 else if (gtk_printer_is_virtual (a_printer) && gtk_printer_is_virtual (b_printer))
1065 else if (gtk_printer_is_virtual (a_printer) && !gtk_printer_is_virtual (b_printer))
1067 else if (!gtk_printer_is_virtual (a_printer) && gtk_printer_is_virtual (b_printer))
1069 else if (a_name == NULL && b_name == NULL)
1071 else if (a_name == NULL && b_name != NULL)
1073 else if (a_name != NULL && b_name == NULL)
1076 result = g_ascii_strcasecmp (a_name, b_name);
1080 g_object_unref (a_printer);
1081 g_object_unref (b_printer);
1087 create_printer_list_model (GtkPrintUnixDialog *dialog)
1089 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1090 GtkListStore *model;
1091 GtkTreeSortable *sort;
1093 model = gtk_list_store_new (PRINTER_LIST_N_COLS,
1101 priv->printer_list = (GtkTreeModel *)model;
1102 priv->printer_list_filter = (GtkTreeModelFilter *) gtk_tree_model_filter_new ((GtkTreeModel *)model,
1105 gtk_tree_model_filter_set_visible_func (priv->printer_list_filter,
1106 (GtkTreeModelFilterVisibleFunc) is_printer_active,
1110 sort = GTK_TREE_SORTABLE (model);
1111 gtk_tree_sortable_set_default_sort_func (sort,
1112 default_printer_list_sort_func,
1116 gtk_tree_sortable_set_sort_column_id (sort,
1117 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
1118 GTK_SORT_ASCENDING);
1124 wrap_in_frame (const gchar *label,
1127 GtkWidget *frame, *alignment, *label_widget;
1130 label_widget = gtk_label_new (NULL);
1131 gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
1132 gtk_widget_show (label_widget);
1134 bold_text = g_markup_printf_escaped ("<b>%s</b>", label);
1135 gtk_label_set_markup (GTK_LABEL (label_widget), bold_text);
1138 frame = gtk_vbox_new (FALSE, 6);
1139 gtk_box_pack_start (GTK_BOX (frame), label_widget, FALSE, FALSE, 0);
1141 alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
1142 gtk_alignment_set_padding (GTK_ALIGNMENT (alignment),
1144 gtk_box_pack_start (GTK_BOX (frame), alignment, FALSE, FALSE, 0);
1146 gtk_container_add (GTK_CONTAINER (alignment), child);
1148 gtk_widget_show (frame);
1149 gtk_widget_show (alignment);
1155 setup_option (GtkPrintUnixDialog *dialog,
1156 const gchar *option_name,
1157 GtkPrinterOptionWidget *widget)
1159 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1160 GtkPrinterOption *option;
1162 option = gtk_printer_option_set_lookup (priv->options, option_name);
1163 gtk_printer_option_widget_set_source (widget, option);
1165 return option != NULL;
1169 add_option_to_extension_point (GtkPrinterOption *option,
1172 GtkWidget *extension_point = data;
1175 widget = gtk_printer_option_widget_new (option);
1176 gtk_widget_show (widget);
1178 if (gtk_printer_option_widget_has_external_label (GTK_PRINTER_OPTION_WIDGET (widget)))
1180 GtkWidget *label, *hbox;
1182 label = gtk_printer_option_widget_get_external_label (GTK_PRINTER_OPTION_WIDGET (widget));
1183 gtk_widget_show (label);
1184 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1185 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
1187 hbox = gtk_hbox_new (FALSE, 12);
1188 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1189 gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1190 gtk_widget_show (hbox);
1192 gtk_box_pack_start (GTK_BOX (extension_point), hbox, FALSE, FALSE, 0);
1195 gtk_box_pack_start (GTK_BOX (extension_point), widget, FALSE, FALSE, 0);
1199 add_option_to_table (GtkPrinterOption *option,
1203 GtkWidget *label, *widget;
1206 table = GTK_TABLE (user_data);
1208 if (g_str_has_prefix (option->name, "gtk-"))
1211 widget = gtk_printer_option_widget_new (option);
1212 gtk_widget_show (widget);
1214 gtk_table_get_size (table, &row, NULL);
1215 gtk_table_resize (table, row + 1, 2);
1217 if (gtk_printer_option_widget_has_external_label (GTK_PRINTER_OPTION_WIDGET (widget)))
1219 label = gtk_printer_option_widget_get_external_label (GTK_PRINTER_OPTION_WIDGET (widget));
1220 gtk_widget_show (label);
1222 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1223 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
1225 gtk_table_attach (table, label,
1226 0, 1, row - 1 , row, GTK_FILL, 0, 0, 0);
1228 gtk_table_attach (table, widget,
1229 1, 2, row - 1, row, GTK_FILL, 0, 0, 0);
1232 gtk_table_attach (table, widget,
1233 0, 2, row - 1, row, GTK_FILL, 0, 0, 0);
1237 setup_page_table (GtkPrinterOptionSet *options,
1244 gtk_printer_option_set_foreach_in_group (options, group,
1245 add_option_to_table,
1248 gtk_table_get_size (GTK_TABLE (table), &nrows, NULL);
1250 gtk_widget_hide (page);
1252 gtk_widget_show (page);
1256 update_print_at_option (GtkPrintUnixDialog *dialog)
1258 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1259 GtkPrinterOption *option;
1261 option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time");
1266 if (priv->updating_print_at)
1269 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->print_at_radio)))
1270 gtk_printer_option_set (option, "at");
1271 else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->print_hold_radio)))
1272 gtk_printer_option_set (option, "on-hold");
1274 gtk_printer_option_set (option, "now");
1276 option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time-text");
1279 const char *text = gtk_entry_get_text (GTK_ENTRY (priv->print_at_entry));
1280 gtk_printer_option_set (option, text);
1286 setup_print_at (GtkPrintUnixDialog *dialog)
1288 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1289 GtkPrinterOption *option;
1291 option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time");
1295 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_now_radio),
1297 gtk_widget_set_sensitive (priv->print_at_radio, FALSE);
1298 gtk_widget_set_sensitive (priv->print_at_entry, FALSE);
1299 gtk_widget_set_sensitive (priv->print_hold_radio, FALSE);
1300 gtk_entry_set_text (GTK_ENTRY (priv->print_at_entry), "");
1304 priv->updating_print_at = TRUE;
1306 gtk_widget_set_sensitive (priv->print_at_entry, FALSE);
1307 gtk_widget_set_sensitive (priv->print_at_radio,
1308 gtk_printer_option_has_choice (option, "at"));
1310 gtk_widget_set_sensitive (priv->print_hold_radio,
1311 gtk_printer_option_has_choice (option, "on-hold"));
1313 update_print_at_option (dialog);
1315 if (strcmp (option->value, "at") == 0)
1316 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_at_radio),
1318 else if (strcmp (option->value, "on-hold") == 0)
1319 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_hold_radio),
1322 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_now_radio),
1325 option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time-text");
1327 gtk_entry_set_text (GTK_ENTRY (priv->print_at_entry), option->value);
1329 priv->updating_print_at = FALSE;
1335 update_dialog_from_settings (GtkPrintUnixDialog *dialog)
1337 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1340 GtkWidget *table, *frame;
1341 gboolean has_advanced, has_job;
1344 if (priv->current_printer == NULL)
1346 clear_per_printer_ui (dialog);
1347 gtk_widget_hide (priv->job_page);
1348 gtk_widget_hide (priv->advanced_page);
1349 gtk_widget_hide (priv->image_quality_page);
1350 gtk_widget_hide (priv->finishing_page);
1351 gtk_widget_hide (priv->color_page);
1352 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
1357 setup_option (dialog, "gtk-n-up", priv->pages_per_sheet);
1358 setup_option (dialog, "gtk-n-up-layout", priv->number_up_layout);
1359 setup_option (dialog, "gtk-duplex", priv->duplex);
1360 setup_option (dialog, "gtk-paper-type", priv->paper_type);
1361 setup_option (dialog, "gtk-paper-source", priv->paper_source);
1362 setup_option (dialog, "gtk-output-tray", priv->output_tray);
1365 has_job |= setup_option (dialog, "gtk-job-prio", priv->job_prio);
1366 has_job |= setup_option (dialog, "gtk-billing-info", priv->billing_info);
1367 has_job |= setup_option (dialog, "gtk-cover-before", priv->cover_before);
1368 has_job |= setup_option (dialog, "gtk-cover-after", priv->cover_after);
1369 has_job |= setup_print_at (dialog);
1372 gtk_widget_show (priv->job_page);
1374 gtk_widget_hide (priv->job_page);
1376 setup_page_table (priv->options,
1378 priv->image_quality_table,
1379 priv->image_quality_page);
1381 setup_page_table (priv->options,
1383 priv->finishing_table,
1384 priv->finishing_page);
1386 setup_page_table (priv->options,
1391 gtk_printer_option_set_foreach_in_group (priv->options,
1392 "GtkPrintDialogExtension",
1393 add_option_to_extension_point,
1394 priv->extension_point);
1396 /* Put the rest of the groups in the advanced page */
1397 groups = gtk_printer_option_set_get_groups (priv->options);
1399 has_advanced = FALSE;
1400 for (l = groups; l != NULL; l = l->next)
1407 if (strcmp (group, "ImageQualityPage") == 0 ||
1408 strcmp (group, "ColorPage") == 0 ||
1409 strcmp (group, "FinishingPage") == 0 ||
1410 strcmp (group, "GtkPrintDialogExtension") == 0)
1413 table = gtk_table_new (1, 2, FALSE);
1414 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1415 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1417 gtk_printer_option_set_foreach_in_group (priv->options,
1419 add_option_to_table,
1422 gtk_table_get_size (GTK_TABLE (table), &nrows, NULL);
1424 gtk_widget_destroy (table);
1427 has_advanced = TRUE;
1428 frame = wrap_in_frame (group, table);
1429 gtk_widget_show (table);
1430 gtk_widget_show (frame);
1432 gtk_box_pack_start (GTK_BOX (priv->advanced_vbox),
1433 frame, FALSE, FALSE, 0);
1438 gtk_widget_show (priv->advanced_page);
1440 gtk_widget_hide (priv->advanced_page);
1442 g_list_foreach (groups, (GFunc) g_free, NULL);
1443 g_list_free (groups);
1447 update_dialog_from_capabilities (GtkPrintUnixDialog *dialog)
1449 GtkPrintCapabilities caps;
1450 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1451 gboolean can_collate;
1452 const gchar *copies;
1454 copies = gtk_entry_get_text (GTK_ENTRY (priv->copies_spin));
1455 can_collate = (*copies != '\0' && atoi (copies) > 1);
1457 caps = priv->manual_capabilities | priv->printer_capabilities;
1459 gtk_widget_set_sensitive (priv->page_set_combo,
1460 caps & GTK_PRINT_CAPABILITY_PAGE_SET);
1461 gtk_widget_set_sensitive (priv->copies_spin,
1462 caps & GTK_PRINT_CAPABILITY_COPIES);
1463 gtk_widget_set_sensitive (priv->collate_check,
1465 (caps & GTK_PRINT_CAPABILITY_COLLATE));
1466 gtk_widget_set_sensitive (priv->reverse_check,
1467 caps & GTK_PRINT_CAPABILITY_REVERSE);
1468 gtk_widget_set_sensitive (priv->scale_spin,
1469 caps & GTK_PRINT_CAPABILITY_SCALE);
1470 gtk_widget_set_sensitive (GTK_WIDGET (priv->pages_per_sheet),
1471 caps & GTK_PRINT_CAPABILITY_NUMBER_UP);
1473 if (caps & GTK_PRINT_CAPABILITY_PREVIEW)
1474 gtk_widget_show (priv->preview_button);
1476 gtk_widget_hide (priv->preview_button);
1478 update_collate_icon (NULL, dialog);
1480 gtk_tree_model_filter_refilter (priv->printer_list_filter);
1484 page_setup_is_equal (GtkPageSetup *a,
1488 gtk_paper_size_is_equal (gtk_page_setup_get_paper_size (a),
1489 gtk_page_setup_get_paper_size (b)) &&
1490 gtk_page_setup_get_top_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_top_margin (b, GTK_UNIT_MM) &&
1491 gtk_page_setup_get_bottom_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_bottom_margin (b, GTK_UNIT_MM) &&
1492 gtk_page_setup_get_left_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_left_margin (b, GTK_UNIT_MM) &&
1493 gtk_page_setup_get_right_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_right_margin (b, GTK_UNIT_MM);
1497 page_setup_is_same_size (GtkPageSetup *a,
1500 return gtk_paper_size_is_equal (gtk_page_setup_get_paper_size (a),
1501 gtk_page_setup_get_paper_size (b));
1505 set_paper_size (GtkPrintUnixDialog *dialog,
1506 GtkPageSetup *page_setup,
1510 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1511 GtkTreeModel *model;
1513 GtkPageSetup *list_page_setup;
1515 if (!priv->internal_page_setup_change)
1518 if (page_setup == NULL)
1521 model = GTK_TREE_MODEL (priv->page_setup_list);
1523 if (gtk_tree_model_get_iter_first (model, &iter))
1527 gtk_tree_model_get (GTK_TREE_MODEL (priv->page_setup_list), &iter,
1528 PAGE_SETUP_LIST_COL_PAGE_SETUP, &list_page_setup, -1);
1529 if (list_page_setup == NULL)
1532 if ((size_only && page_setup_is_same_size (page_setup, list_page_setup)) ||
1533 (!size_only && page_setup_is_equal (page_setup, list_page_setup)))
1535 gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->paper_size_combo),
1537 gtk_combo_box_set_active (GTK_COMBO_BOX (priv->orientation_combo),
1538 gtk_page_setup_get_orientation (page_setup));
1539 g_object_unref (list_page_setup);
1543 g_object_unref (list_page_setup);
1545 } while (gtk_tree_model_iter_next (model, &iter));
1550 gtk_list_store_append (priv->page_setup_list, &iter);
1551 gtk_list_store_set (priv->page_setup_list, &iter,
1552 PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
1554 gtk_list_store_append (priv->page_setup_list, &iter);
1555 gtk_list_store_set (priv->page_setup_list, &iter,
1556 PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
1558 gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->paper_size_combo),
1560 gtk_combo_box_set_active (GTK_COMBO_BOX (priv->orientation_combo),
1561 gtk_page_setup_get_orientation (page_setup));
1569 fill_custom_paper_sizes (GtkPrintUnixDialog *dialog)
1571 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1572 GtkTreeIter iter, paper_iter;
1573 GtkTreeModel *model;
1575 model = GTK_TREE_MODEL (priv->custom_paper_list);
1576 if (gtk_tree_model_get_iter_first (model, &iter))
1578 gtk_list_store_append (priv->page_setup_list, &paper_iter);
1579 gtk_list_store_set (priv->page_setup_list, &paper_iter,
1580 PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
1584 GtkPageSetup *page_setup;
1585 gtk_tree_model_get (model, &iter, 0, &page_setup, -1);
1587 gtk_list_store_append (priv->page_setup_list, &paper_iter);
1588 gtk_list_store_set (priv->page_setup_list, &paper_iter,
1589 PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
1592 g_object_unref (page_setup);
1593 } while (gtk_tree_model_iter_next (model, &iter));
1596 gtk_list_store_append (priv->page_setup_list, &paper_iter);
1597 gtk_list_store_set (priv->page_setup_list, &paper_iter,
1598 PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
1600 gtk_list_store_append (priv->page_setup_list, &paper_iter);
1601 gtk_list_store_set (priv->page_setup_list, &paper_iter,
1602 PAGE_SETUP_LIST_COL_PAGE_SETUP, NULL,
1607 fill_paper_sizes (GtkPrintUnixDialog *dialog,
1608 GtkPrinter *printer)
1610 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1612 GtkPageSetup *page_setup;
1613 GtkPaperSize *paper_size;
1617 gtk_list_store_clear (priv->page_setup_list);
1619 if (printer == NULL || (list = gtk_printer_list_papers (printer)) == NULL)
1621 for (i = 0; i < G_N_ELEMENTS (common_paper_sizes); i++)
1623 page_setup = gtk_page_setup_new ();
1624 paper_size = gtk_paper_size_new (common_paper_sizes[i]);
1625 gtk_page_setup_set_paper_size_and_default_margins (page_setup, paper_size);
1626 gtk_paper_size_free (paper_size);
1628 gtk_list_store_append (priv->page_setup_list, &iter);
1629 gtk_list_store_set (priv->page_setup_list, &iter,
1630 PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
1632 g_object_unref (page_setup);
1637 for (l = list; l != NULL; l = l->next)
1639 page_setup = l->data;
1640 gtk_list_store_append (priv->page_setup_list, &iter);
1641 gtk_list_store_set (priv->page_setup_list, &iter,
1642 PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
1644 g_object_unref (page_setup);
1649 fill_custom_paper_sizes (dialog);
1653 update_paper_sizes (GtkPrintUnixDialog *dialog)
1655 GtkPageSetup *current_page_setup = NULL;
1656 GtkPrinter *printer;
1658 printer = gtk_print_unix_dialog_get_selected_printer (dialog);
1660 fill_paper_sizes (dialog, printer);
1662 current_page_setup = gtk_page_setup_copy (gtk_print_unix_dialog_get_page_setup (dialog));
1664 if (current_page_setup)
1666 if (!set_paper_size (dialog, current_page_setup, FALSE, FALSE))
1667 set_paper_size (dialog, current_page_setup, TRUE, TRUE);
1669 g_object_unref (current_page_setup);
1674 mark_conflicts (GtkPrintUnixDialog *dialog)
1676 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1677 GtkPrinter *printer;
1678 gboolean have_conflict;
1680 have_conflict = FALSE;
1682 printer = priv->current_printer;
1687 g_signal_handler_block (priv->options,
1688 priv->options_changed_handler);
1690 gtk_printer_option_set_clear_conflicts (priv->options);
1692 have_conflict = _gtk_printer_mark_conflicts (printer,
1695 g_signal_handler_unblock (priv->options,
1696 priv->options_changed_handler);
1700 gtk_widget_show (priv->conflicts_widget);
1702 gtk_widget_hide (priv->conflicts_widget);
1706 mark_conflicts_callback (gpointer data)
1708 GtkPrintUnixDialog *dialog = data;
1709 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1711 priv->mark_conflicts_id = 0;
1713 mark_conflicts (dialog);
1719 unschedule_idle_mark_conflicts (GtkPrintUnixDialog *dialog)
1721 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1723 if (priv->mark_conflicts_id != 0)
1725 g_source_remove (priv->mark_conflicts_id);
1726 priv->mark_conflicts_id = 0;
1731 schedule_idle_mark_conflicts (GtkPrintUnixDialog *dialog)
1733 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1735 if (priv->mark_conflicts_id != 0)
1738 priv->mark_conflicts_id = gdk_threads_add_idle (mark_conflicts_callback,
1743 options_changed_cb (GtkPrintUnixDialog *dialog)
1745 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1747 schedule_idle_mark_conflicts (dialog);
1749 g_free (priv->waiting_for_printer);
1750 priv->waiting_for_printer = NULL;
1754 remove_custom_widget (GtkWidget *widget,
1755 GtkContainer *container)
1757 gtk_container_remove (container, widget);
1761 extension_point_clear_children (GtkContainer *container)
1763 gtk_container_foreach (container,
1764 (GtkCallback)remove_custom_widget,
1769 clear_per_printer_ui (GtkPrintUnixDialog *dialog)
1771 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1773 gtk_container_foreach (GTK_CONTAINER (priv->finishing_table),
1774 (GtkCallback)gtk_widget_destroy,
1776 gtk_table_resize (GTK_TABLE (priv->finishing_table), 1, 2);
1777 gtk_container_foreach (GTK_CONTAINER (priv->image_quality_table),
1778 (GtkCallback)gtk_widget_destroy,
1780 gtk_table_resize (GTK_TABLE (priv->image_quality_table), 1, 2);
1781 gtk_container_foreach (GTK_CONTAINER (priv->color_table),
1782 (GtkCallback)gtk_widget_destroy,
1784 gtk_table_resize (GTK_TABLE (priv->color_table), 1, 2);
1785 gtk_container_foreach (GTK_CONTAINER (priv->advanced_vbox),
1786 (GtkCallback)gtk_widget_destroy,
1788 extension_point_clear_children (GTK_CONTAINER (priv->extension_point));
1792 printer_details_acquired (GtkPrinter *printer,
1794 GtkPrintUnixDialog *dialog)
1796 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1798 disconnect_printer_details_request (dialog, !success);
1802 GtkTreeSelection *selection;
1803 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
1805 selected_printer_changed (selection, dialog);
1810 selected_printer_changed (GtkTreeSelection *selection,
1811 GtkPrintUnixDialog *dialog)
1813 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1814 GtkPrinter *printer;
1815 GtkTreeIter iter, filter_iter;
1817 /* Whenever the user selects a printer we stop looking for
1818 the printer specified in the initial settings */
1819 if (priv->waiting_for_printer &&
1820 !priv->internal_printer_change)
1822 g_free (priv->waiting_for_printer);
1823 priv->waiting_for_printer = NULL;
1826 disconnect_printer_details_request (dialog, FALSE);
1829 if (gtk_tree_selection_get_selected (selection, NULL, &filter_iter))
1831 gtk_tree_model_filter_convert_iter_to_child_iter (priv->printer_list_filter,
1835 gtk_tree_model_get (priv->printer_list, &iter,
1836 PRINTER_LIST_COL_PRINTER_OBJ, &printer,
1840 /* sets GTK_RESPONSE_OK button sensitivity depending on whether the printer
1841 * accepts/rejects jobs
1843 if (printer != NULL)
1845 if (!gtk_printer_is_accepting_jobs (printer))
1847 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
1851 if (priv->current_printer == printer && gtk_printer_has_details (printer))
1852 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, TRUE);
1856 if (printer != NULL && !gtk_printer_has_details (printer))
1858 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
1859 priv->request_details_tag =
1860 g_signal_connect (printer, "details-acquired",
1861 G_CALLBACK (printer_details_acquired), dialog);
1862 /* take the reference */
1863 priv->request_details_printer = printer;
1864 gtk_printer_request_details (printer);
1865 set_busy_cursor (dialog, TRUE);
1866 gtk_list_store_set (GTK_LIST_STORE (priv->printer_list),
1867 g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter"),
1868 PRINTER_LIST_COL_STATE, _("Getting printer information..."),
1873 if (printer == priv->current_printer)
1876 g_object_unref (printer);
1882 g_object_unref (priv->options);
1883 priv->options = NULL;
1885 clear_per_printer_ui (dialog);
1888 if (priv->current_printer)
1890 g_object_unref (priv->current_printer);
1893 priv->printer_capabilities = 0;
1895 if (gtk_printer_is_accepting_jobs (printer))
1896 gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, TRUE);
1897 priv->current_printer = printer;
1899 if (printer != NULL)
1901 if (!priv->page_setup_set)
1903 /* if no explicit page setup has been set, use the printer default */
1904 GtkPageSetup *page_setup;
1906 page_setup = gtk_printer_get_default_page_size (printer);
1909 page_setup = gtk_page_setup_new ();
1911 if (page_setup && priv->page_setup)
1912 gtk_page_setup_set_orientation (page_setup, gtk_page_setup_get_orientation (priv->page_setup));
1914 g_object_unref (priv->page_setup);
1915 priv->page_setup = page_setup;
1918 priv->printer_capabilities = gtk_printer_get_capabilities (printer);
1919 priv->options = _gtk_printer_get_options (printer,
1920 priv->initial_settings,
1922 priv->manual_capabilities);
1924 priv->options_changed_handler =
1925 g_signal_connect_swapped (priv->options, "changed", G_CALLBACK (options_changed_cb), dialog);
1928 update_dialog_from_settings (dialog);
1929 update_dialog_from_capabilities (dialog);
1931 priv->internal_page_setup_change = TRUE;
1932 update_paper_sizes (dialog);
1933 priv->internal_page_setup_change = FALSE;
1935 g_object_notify ( G_OBJECT(dialog), "selected-printer");
1939 update_collate_icon (GtkToggleButton *toggle_button,
1940 GtkPrintUnixDialog *dialog)
1942 GtkPrintUnixDialogPrivate *priv = dialog->priv;
1944 gtk_widget_queue_draw (priv->collate_image);
1948 paint_page (GtkWidget *widget,
1956 gint x, y, width, height;
1957 gint text_y, linewidth;
1959 x = x_offset * scale;
1960 y = y_offset * scale;
1962 height = 26 * scale;
1967 gdk_cairo_set_source_color (cr, &widget->style->base[GTK_STATE_NORMAL]);
1968 cairo_rectangle (cr, x, y, width, height);
1971 gdk_cairo_set_source_color (cr, &widget->style->text[GTK_STATE_NORMAL]);
1972 cairo_set_line_width (cr, linewidth);
1973 cairo_rectangle (cr, x + linewidth/2.0, y + linewidth/2.0, width - linewidth, height - linewidth);
1976 cairo_select_font_face (cr, "Sans",
1977 CAIRO_FONT_SLANT_NORMAL,
1978 CAIRO_FONT_WEIGHT_NORMAL);
1979 cairo_set_font_size (cr, (gint)(9 * scale));
1980 cairo_move_to (cr, x + (gint)(text_x * scale), y + (gint)(text_y * scale));
1981 cairo_show_text (cr, text);
1985 draw_collate_cb (GtkWidget *widget,
1986 GdkEventExpose *event,
1987 GtkPrintUnixDialog *dialog)
1989 GtkSettings *settings;
1993 gboolean collate, reverse, rtl;
1997 collate = dialog_get_collate (dialog);
1998 reverse = dialog_get_reverse (dialog);
1999 copies = dialog_get_n_copies (dialog);
2001 rtl = (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL);
2003 settings = gtk_widget_get_settings (widget);
2004 gtk_icon_size_lookup_for_settings (settings,
2005 GTK_ICON_SIZE_DIALOG,
2008 scale = size / 48.0;
2009 text_x = rtl ? 4 : 11;
2011 cr = gdk_cairo_create (widget->window);
2013 cairo_translate (cr, widget->allocation.x, widget->allocation.y);
2017 paint_page (widget, cr, scale, rtl ? 40: 15, 5, reverse ? "1" : "2", text_x);
2018 paint_page (widget, cr, scale, rtl ? 50: 5, 15, reverse ? "2" : "1", text_x);
2022 paint_page (widget, cr, scale, rtl ? 40: 15, 5, collate == reverse ? "1" : "2", text_x);
2023 paint_page (widget, cr, scale, rtl ? 50: 5, 15, reverse ? "2" : "1", text_x);
2025 paint_page (widget, cr, scale, rtl ? 5 : 50, 5, reverse ? "1" : "2", text_x);
2026 paint_page (widget, cr, scale, rtl ? 15 : 40, 15, collate == reverse ? "2" : "1", text_x);
2035 gtk_print_unix_dialog_style_set (GtkWidget *widget,
2036 GtkStyle *previous_style)
2038 GTK_WIDGET_CLASS (gtk_print_unix_dialog_parent_class)->style_set (widget, previous_style);
2040 if (gtk_widget_has_screen (widget))
2042 GtkPrintUnixDialog *dialog = (GtkPrintUnixDialog *)widget;
2043 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2044 GtkSettings *settings;
2048 settings = gtk_widget_get_settings (widget);
2049 gtk_icon_size_lookup_for_settings (settings,
2050 GTK_ICON_SIZE_DIALOG,
2053 scale = size / 48.0;
2055 gtk_widget_set_size_request (priv->collate_image,
2062 update_entry_sensitivity (GtkWidget *button,
2067 active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
2069 gtk_widget_set_sensitive (range, active);
2072 gtk_widget_grab_focus (range);
2076 emit_ok_response (GtkTreeView *tree_view,
2078 GtkTreeViewColumn *column,
2079 gpointer *user_data)
2081 GtkPrintUnixDialog *print_dialog;
2083 print_dialog = (GtkPrintUnixDialog *) user_data;
2085 gtk_dialog_response (GTK_DIALOG (print_dialog), GTK_RESPONSE_OK);
2089 create_main_page (GtkPrintUnixDialog *dialog)
2091 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2092 GtkWidget *main_vbox, *label, *vbox, *hbox;
2093 GtkWidget *scrolled, *treeview, *frame, *table;
2094 GtkWidget *entry, *spinbutton;
2095 GtkWidget *radio, *check, *image;
2096 GtkCellRenderer *renderer;
2097 GtkTreeViewColumn *column;
2098 GtkTreeSelection *selection;
2099 GtkWidget *custom_input;
2100 const gchar *range_tooltip;
2102 main_vbox = gtk_vbox_new (FALSE, 18);
2103 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
2104 gtk_widget_show (main_vbox);
2106 vbox = gtk_vbox_new (FALSE, 6);
2107 gtk_box_pack_start (GTK_BOX (main_vbox), vbox, TRUE, TRUE, 0);
2108 gtk_widget_show (vbox);
2110 scrolled = gtk_scrolled_window_new (NULL, NULL);
2111 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
2112 GTK_POLICY_AUTOMATIC,
2113 GTK_POLICY_AUTOMATIC);
2114 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
2116 gtk_widget_show (scrolled);
2117 gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
2119 treeview = gtk_tree_view_new_with_model ((GtkTreeModel *) priv->printer_list_filter);
2120 priv->printer_treeview = treeview;
2121 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), TRUE);
2122 gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), PRINTER_LIST_COL_NAME);
2123 gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), TRUE);
2124 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
2125 gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
2126 g_signal_connect (selection, "changed", G_CALLBACK (selected_printer_changed), dialog);
2128 renderer = gtk_cell_renderer_pixbuf_new ();
2129 column = gtk_tree_view_column_new_with_attributes ("",
2132 PRINTER_LIST_COL_ICON,
2134 gtk_tree_view_column_set_cell_data_func (column, renderer, set_cell_sensitivity_func, NULL, NULL);
2135 gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2137 renderer = gtk_cell_renderer_text_new ();
2138 column = gtk_tree_view_column_new_with_attributes (_("Printer"),
2141 PRINTER_LIST_COL_NAME,
2143 gtk_tree_view_column_set_cell_data_func (column, renderer, set_cell_sensitivity_func, NULL, NULL);
2144 gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2146 renderer = gtk_cell_renderer_text_new ();
2147 /* Translators: this is the header for the location column in the print dialog */
2148 column = gtk_tree_view_column_new_with_attributes (_("Location"),
2151 PRINTER_LIST_COL_LOCATION,
2153 gtk_tree_view_column_set_cell_data_func (column, renderer, set_cell_sensitivity_func, NULL, NULL);
2154 gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2156 renderer = gtk_cell_renderer_text_new ();
2157 g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2158 /* Translators: this is the header for the printer status column in the print dialog */
2159 column = gtk_tree_view_column_new_with_attributes (_("Status"),
2162 PRINTER_LIST_COL_STATE,
2164 gtk_tree_view_column_set_cell_data_func (column, renderer, set_cell_sensitivity_func, NULL, NULL);
2165 gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2167 g_signal_connect (GTK_TREE_VIEW (treeview), "row-activated", G_CALLBACK (emit_ok_response), dialog);
2169 gtk_widget_show (treeview);
2170 gtk_container_add (GTK_CONTAINER (scrolled), treeview);
2172 custom_input = gtk_hbox_new (FALSE, 18);
2173 gtk_widget_show (custom_input);
2174 gtk_box_pack_start (GTK_BOX (vbox), custom_input, FALSE, FALSE, 0);
2175 priv->extension_point = custom_input;
2177 hbox = gtk_hbox_new (FALSE, 18);
2178 gtk_widget_show (hbox);
2179 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
2181 table = gtk_table_new (4, 2, FALSE);
2182 priv->range_table = table;
2183 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2184 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2185 frame = wrap_in_frame (_("Range"), table);
2186 gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
2187 gtk_widget_show (table);
2189 radio = gtk_radio_button_new_with_mnemonic (NULL, _("_All Pages"));
2190 priv->all_pages_radio = radio;
2191 gtk_widget_show (radio);
2192 gtk_table_attach (GTK_TABLE (table), radio,
2193 0, 2, 0, 1, GTK_FILL, 0,
2195 radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
2196 _("C_urrent Page"));
2197 if (priv->current_page == -1)
2198 gtk_widget_set_sensitive (radio, FALSE);
2199 priv->current_page_radio = radio;
2200 gtk_widget_show (radio);
2201 gtk_table_attach (GTK_TABLE (table), radio,
2202 0, 2, 1, 2, GTK_FILL, 0,
2205 radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
2208 gtk_widget_set_sensitive (radio, priv->has_selection);
2209 priv->selection_radio = radio;
2210 gtk_table_attach (GTK_TABLE (table), radio,
2211 0, 2, 2, 3, GTK_FILL, 0,
2213 gtk_table_set_row_spacing (GTK_TABLE (table), 2, 0);
2215 radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), _("Pag_es:"));
2216 range_tooltip = _("Specify one or more page ranges,\n e.g. 1-3,7,11");
2217 gtk_widget_set_tooltip_text (radio, range_tooltip);
2219 priv->page_range_radio = radio;
2220 gtk_widget_show (radio);
2221 gtk_table_attach (GTK_TABLE (table), radio,
2222 0, 1, 3, 4, GTK_FILL, 0,
2224 entry = gtk_entry_new ();
2225 gtk_widget_set_tooltip_text (entry, range_tooltip);
2226 atk_object_set_name (gtk_widget_get_accessible (entry), _("Pages"));
2227 atk_object_set_description (gtk_widget_get_accessible (entry), range_tooltip);
2228 priv->page_range_entry = entry;
2229 gtk_widget_show (entry);
2230 gtk_table_attach (GTK_TABLE (table), entry,
2231 1, 2, 3, 4, GTK_FILL, 0,
2233 g_signal_connect (radio, "toggled", G_CALLBACK (update_entry_sensitivity), entry);
2234 update_entry_sensitivity (radio, entry);
2236 table = gtk_table_new (3, 2, FALSE);
2237 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2238 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2239 frame = wrap_in_frame (_("Copies"), table);
2240 gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
2241 gtk_widget_show (table);
2243 /* FIXME chpe: too much space between Copies and spinbutton, put those 2 in a hbox and make it span 2 columns */
2244 label = gtk_label_new_with_mnemonic (_("Copie_s:"));
2245 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2246 gtk_widget_show (label);
2247 gtk_table_attach (GTK_TABLE (table), label,
2248 0, 1, 0, 1, GTK_FILL, 0,
2250 spinbutton = gtk_spin_button_new_with_range (1.0, 100.0, 1.0);
2251 priv->copies_spin = spinbutton;
2252 gtk_widget_show (spinbutton);
2253 gtk_table_attach (GTK_TABLE (table), spinbutton,
2254 1, 2, 0, 1, GTK_FILL, 0,
2256 gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
2257 g_signal_connect_swapped (spinbutton, "value-changed",
2258 G_CALLBACK (update_dialog_from_capabilities), dialog);
2259 g_signal_connect_swapped (spinbutton, "changed",
2260 G_CALLBACK (update_dialog_from_capabilities), dialog);
2262 check = gtk_check_button_new_with_mnemonic (_("C_ollate"));
2263 priv->collate_check = check;
2264 g_signal_connect (check, "toggled", G_CALLBACK (update_collate_icon), dialog);
2265 gtk_widget_show (check);
2266 gtk_table_attach (GTK_TABLE (table), check,
2267 0, 1, 1, 2, GTK_FILL, 0,
2270 check = gtk_check_button_new_with_mnemonic (_("_Reverse"));
2271 g_signal_connect (check, "toggled", G_CALLBACK (update_collate_icon), dialog);
2272 priv->reverse_check = check;
2273 gtk_widget_show (check);
2274 gtk_table_attach (GTK_TABLE (table), check,
2275 0, 1, 2, 3, GTK_FILL, 0,
2278 image = gtk_drawing_area_new ();
2279 gtk_widget_set_has_window (image, FALSE);
2281 priv->collate_image = image;
2282 gtk_widget_show (image);
2283 gtk_widget_set_size_request (image, 70, 90);
2284 gtk_table_attach (GTK_TABLE (table), image,
2285 1, 2, 1, 3, GTK_FILL, 0,
2287 g_signal_connect (image, "expose-event",
2288 G_CALLBACK (draw_collate_cb), dialog);
2290 label = gtk_label_new (_("General"));
2291 gtk_widget_show (label);
2293 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), main_vbox, label);
2297 is_range_separator (gchar c)
2299 return (c == ',' || c == ';' || c == ':');
2302 static GtkPageRange *
2303 dialog_get_page_ranges (GtkPrintUnixDialog *dialog,
2306 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2308 const gchar *text, *p;
2310 GtkPageRange *ranges;
2313 text = gtk_entry_get_text (GTK_ENTRY (priv->page_range_entry));
2325 if (is_range_separator (*p))
2330 ranges = g_new0 (GtkPageRange, n_ranges);
2336 while (isspace (*p)) p++;
2340 /* a half-open range like -2 */
2345 start = (int)strtol (p, &next, 10);
2353 while (isspace (*p)) p++;
2358 end = (int)strtol (p, &next, 10);
2359 if (next == p) /* a half-open range like 2- */
2361 else if (end < start)
2365 ranges[i].start = start - 1;
2366 ranges[i].end = end - 1;
2369 /* Skip until end or separator */
2370 while (*p && !is_range_separator (*p))
2373 /* if not at end, skip separator */
2384 dialog_set_page_ranges (GtkPrintUnixDialog *dialog,
2385 GtkPageRange *ranges,
2388 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2390 GString *s = g_string_new (NULL);
2392 for (i = 0; i < n_ranges; i++)
2394 g_string_append_printf (s, "%d", ranges[i].start + 1);
2395 if (ranges[i].end > ranges[i].start)
2396 g_string_append_printf (s, "-%d", ranges[i].end + 1);
2397 else if (ranges[i].end == -1)
2398 g_string_append (s, "-");
2400 if (i != n_ranges - 1)
2401 g_string_append (s, ",");
2404 gtk_entry_set_text (GTK_ENTRY (priv->page_range_entry), s->str);
2406 g_string_free (s, TRUE);
2409 static GtkPrintPages
2410 dialog_get_print_pages (GtkPrintUnixDialog *dialog)
2412 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2414 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->all_pages_radio)))
2415 return GTK_PRINT_PAGES_ALL;
2416 else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->current_page_radio)))
2417 return GTK_PRINT_PAGES_CURRENT;
2418 else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->selection_radio)))
2419 return GTK_PRINT_PAGES_SELECTION;
2421 return GTK_PRINT_PAGES_RANGES;
2425 dialog_set_print_pages (GtkPrintUnixDialog *dialog,
2426 GtkPrintPages pages)
2428 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2430 if (pages == GTK_PRINT_PAGES_RANGES)
2431 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->page_range_radio), TRUE);
2432 else if (pages == GTK_PRINT_PAGES_CURRENT)
2433 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->current_page_radio), TRUE);
2434 else if (pages == GTK_PRINT_PAGES_SELECTION)
2435 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selection_radio), TRUE);
2437 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_pages_radio), TRUE);
2441 dialog_get_scale (GtkPrintUnixDialog *dialog)
2443 if (gtk_widget_is_sensitive (dialog->priv->scale_spin))
2444 return gtk_spin_button_get_value (GTK_SPIN_BUTTON (dialog->priv->scale_spin));
2450 dialog_set_scale (GtkPrintUnixDialog *dialog,
2453 gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->priv->scale_spin), val);
2457 dialog_get_page_set (GtkPrintUnixDialog *dialog)
2459 if (gtk_widget_is_sensitive (dialog->priv->page_set_combo))
2460 return (GtkPageSet)gtk_combo_box_get_active (GTK_COMBO_BOX (dialog->priv->page_set_combo));
2462 return GTK_PAGE_SET_ALL;
2466 dialog_set_page_set (GtkPrintUnixDialog *dialog,
2469 gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->priv->page_set_combo),
2474 dialog_get_n_copies (GtkPrintUnixDialog *dialog)
2476 if (gtk_widget_is_sensitive (dialog->priv->copies_spin))
2477 return gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dialog->priv->copies_spin));
2482 dialog_set_n_copies (GtkPrintUnixDialog *dialog,
2485 gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->priv->copies_spin),
2490 dialog_get_collate (GtkPrintUnixDialog *dialog)
2492 if (gtk_widget_is_sensitive (dialog->priv->collate_check))
2493 return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->collate_check));
2498 dialog_set_collate (GtkPrintUnixDialog *dialog,
2501 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->collate_check),
2506 dialog_get_reverse (GtkPrintUnixDialog *dialog)
2508 if (gtk_widget_is_sensitive (dialog->priv->reverse_check))
2509 return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->reverse_check));
2514 dialog_set_reverse (GtkPrintUnixDialog *dialog,
2517 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->reverse_check),
2522 dialog_get_pages_per_sheet (GtkPrintUnixDialog *dialog)
2524 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2528 val = gtk_printer_option_widget_get_value (priv->pages_per_sheet);
2542 static GtkNumberUpLayout
2543 dialog_get_number_up_layout (GtkPrintUnixDialog *dialog)
2545 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2546 GtkPrintCapabilities caps;
2547 GtkNumberUpLayout layout;
2549 GEnumClass *enum_class;
2550 GEnumValue *enum_value;
2552 val = gtk_printer_option_widget_get_value (priv->number_up_layout);
2554 caps = priv->manual_capabilities | priv->printer_capabilities;
2556 if ((caps & GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT) == 0)
2557 return GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM;
2559 if (gtk_widget_get_direction (GTK_WIDGET (dialog)) == GTK_TEXT_DIR_LTR)
2560 layout = GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM;
2562 layout = GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM;
2567 enum_class = g_type_class_ref (GTK_TYPE_NUMBER_UP_LAYOUT);
2568 enum_value = g_enum_get_value_by_nick (enum_class, val);
2570 layout = enum_value->value;
2571 g_type_class_unref (enum_class);
2577 draw_page_cb (GtkWidget *widget,
2578 GdkEventExpose *event,
2579 GtkPrintUnixDialog *dialog)
2581 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2584 gint w, h, tmp, shadow_offset;
2585 gint pages_x, pages_y, i, x, y, layout_w, layout_h;
2586 gdouble page_width, page_height;
2587 GtkPageOrientation orientation;
2589 PangoLayout *layout;
2590 PangoFontDescription *font;
2593 GtkNumberUpLayout number_up_layout;
2594 gint start_x, end_x, start_y, end_y;
2596 gboolean horizontal;
2597 GtkPageSetup *page_setup;
2598 gdouble paper_width, paper_height;
2599 gdouble pos_x, pos_y;
2600 gint pages_per_sheet;
2601 gboolean ltr = TRUE;
2603 orientation = gtk_page_setup_get_orientation (priv->page_setup);
2605 (orientation == GTK_PAGE_ORIENTATION_LANDSCAPE) ||
2606 (orientation == GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE);
2608 number_up_layout = dialog_get_number_up_layout (dialog);
2610 cr = gdk_cairo_create (widget->window);
2614 page_setup = gtk_print_unix_dialog_get_page_setup (dialog);
2616 if (page_setup != NULL)
2620 paper_width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM);
2621 paper_height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM);
2625 paper_width = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM);
2626 paper_height = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM);
2629 if (paper_width < paper_height)
2631 h = EXAMPLE_PAGE_AREA_SIZE - 3;
2632 w = (paper_height != 0) ? h * paper_width / paper_height : 0;
2636 w = EXAMPLE_PAGE_AREA_SIZE - 3;
2637 h = (paper_width != 0) ? w * paper_height / paper_width : 0;
2640 if (paper_width == 0)
2643 if (paper_height == 0)
2649 w = (EXAMPLE_PAGE_AREA_SIZE - 3) / ratio;
2650 h = EXAMPLE_PAGE_AREA_SIZE - 3;
2653 pages_per_sheet = dialog_get_pages_per_sheet (dialog);
2654 switch (pages_per_sheet)
2658 pages_x = 1; pages_y = 1;
2661 landscape = !landscape;
2662 pages_x = 1; pages_y = 2;
2665 pages_x = 2; pages_y = 2;
2668 landscape = !landscape;
2669 pages_x = 2; pages_y = 3;
2672 pages_x = 3; pages_y = 3;
2675 pages_x = 4; pages_y = 4;
2690 pos_x = widget->allocation.x + (widget->allocation.width - w) / 2;
2691 pos_y = widget->allocation.y + (widget->allocation.height - h) / 2 - 10;
2692 color = &widget->style->text[GTK_STATE_NORMAL];
2693 cairo_translate (cr, pos_x, pos_y);
2697 color = &widget->style->text[GTK_STATE_NORMAL];
2698 cairo_set_source_rgba (cr, color->red / 65535., color->green / 65535., color->blue / 65535, 0.5);
2699 cairo_rectangle (cr, shadow_offset + 1, shadow_offset + 1, w, h);
2702 gdk_cairo_set_source_color (cr, &widget->style->base[GTK_STATE_NORMAL]);
2703 cairo_rectangle (cr, 1, 1, w, h);
2705 cairo_set_line_width (cr, 1.0);
2706 cairo_rectangle (cr, 0.5, 0.5, w + 1, h + 1);
2708 gdk_cairo_set_source_color (cr, &widget->style->text[GTK_STATE_NORMAL]);
2713 page_width = (double)w / pages_x;
2714 page_height = (double)h / pages_y;
2716 layout = pango_cairo_create_layout (cr);
2718 font = pango_font_description_new ();
2719 pango_font_description_set_family (font, "sans");
2721 if (page_height > 0)
2722 pango_font_description_set_absolute_size (font, page_height * 0.4 * PANGO_SCALE);
2724 pango_font_description_set_absolute_size (font, 1);
2726 pango_layout_set_font_description (layout, font);
2727 pango_font_description_free (font);
2729 pango_layout_set_width (layout, page_width * PANGO_SCALE);
2730 pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
2732 switch (number_up_layout)
2735 case GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM:
2737 end_x = pages_x - 1;
2739 end_y = pages_y - 1;
2744 case GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP:
2746 end_x = pages_x - 1;
2747 start_y = pages_y - 1;
2753 case GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM:
2754 start_x = pages_x - 1;
2757 end_y = pages_y - 1;
2762 case GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP:
2763 start_x = pages_x - 1;
2765 start_y = pages_y - 1;
2771 case GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT:
2773 end_x = pages_x - 1;
2775 end_y = pages_y - 1;
2780 case GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT:
2781 start_x = pages_x - 1;
2784 end_y = pages_y - 1;
2789 case GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT:
2791 end_x = pages_x - 1;
2792 start_y = pages_y - 1;
2798 case GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT:
2799 start_x = pages_x - 1;
2801 start_y = pages_y - 1;
2810 for (y = start_y; y != end_y + dy; y += dy)
2812 for (x = start_x; x != end_x + dx; x += dx)
2814 text = g_strdup_printf ("%d", i++);
2815 pango_layout_set_text (layout, text, -1);
2817 pango_layout_get_size (layout, &layout_w, &layout_h);
2819 cairo_translate (cr,
2821 y * page_height + (page_height - layout_h / 1024.0) / 2);
2823 pango_cairo_show_layout (cr, layout);
2828 for (x = start_x; x != end_x + dx; x += dx)
2830 for (y = start_y; y != end_y + dy; y += dy)
2832 text = g_strdup_printf ("%d", i++);
2833 pango_layout_set_text (layout, text, -1);
2835 pango_layout_get_size (layout, &layout_w, &layout_h);
2837 cairo_translate (cr,
2839 y * page_height + (page_height - layout_h / 1024.0) / 2);
2841 pango_cairo_show_layout (cr, layout);
2846 g_object_unref (layout);
2848 if (page_setup != NULL)
2853 if (pages_per_sheet == 2 || pages_per_sheet == 6)
2855 paper_width = gtk_page_setup_get_paper_height (page_setup, _gtk_print_get_default_user_units ());
2856 paper_height = gtk_page_setup_get_paper_width (page_setup, _gtk_print_get_default_user_units ());
2860 paper_width = gtk_page_setup_get_paper_width (page_setup, _gtk_print_get_default_user_units ());
2861 paper_height = gtk_page_setup_get_paper_height (page_setup, _gtk_print_get_default_user_units ());
2867 layout = pango_cairo_create_layout (cr);
2869 font = pango_font_description_new ();
2870 pango_font_description_set_family (font, "sans");
2872 PangoContext *pango_c = NULL;
2873 PangoFontDescription *pango_f = NULL;
2874 gint font_size = 12 * PANGO_SCALE;
2876 pango_c = gtk_widget_get_pango_context (widget);
2877 if (pango_c != NULL)
2879 pango_f = pango_context_get_font_description (pango_c);
2880 if (pango_f != NULL)
2881 font_size = pango_font_description_get_size (pango_f);
2884 pango_font_description_set_size (font, font_size);
2885 pango_layout_set_font_description (layout, font);
2886 pango_font_description_free (font);
2888 pango_layout_set_width (layout, -1);
2889 pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
2891 if (_gtk_print_get_default_user_units () == GTK_UNIT_MM)
2892 text = g_strdup_printf ("%.1f mm", paper_height);
2894 text = g_strdup_printf ("%.2f inch", paper_height);
2896 pango_layout_set_text (layout, text, -1);
2898 pango_layout_get_size (layout, &layout_w, &layout_h);
2900 ltr = gtk_widget_get_direction (GTK_WIDGET (dialog)) == GTK_TEXT_DIR_LTR;
2903 cairo_translate (cr, pos_x - layout_w / PANGO_SCALE - 2 * RULER_DISTANCE,
2904 widget->allocation.y + (widget->allocation.height - layout_h / PANGO_SCALE) / 2);
2906 cairo_translate (cr, pos_x + w + shadow_offset + 2 * RULER_DISTANCE,
2907 widget->allocation.y + (widget->allocation.height - layout_h / PANGO_SCALE) / 2);
2909 pango_cairo_show_layout (cr, layout);
2914 if (_gtk_print_get_default_user_units () == GTK_UNIT_MM)
2915 text = g_strdup_printf ("%.1f mm", paper_width);
2917 text = g_strdup_printf ("%.2f inch", paper_width);
2919 pango_layout_set_text (layout, text, -1);
2921 pango_layout_get_size (layout, &layout_w, &layout_h);
2923 cairo_translate (cr, widget->allocation.x + (widget->allocation.width - layout_w / PANGO_SCALE) / 2,
2924 pos_y + h + shadow_offset + 2 * RULER_DISTANCE);
2926 pango_cairo_show_layout (cr, layout);
2928 g_object_unref (layout);
2932 cairo_set_line_width (cr, 1);
2936 cairo_move_to (cr, pos_x - RULER_DISTANCE, pos_y);
2937 cairo_line_to (cr, pos_x - RULER_DISTANCE, pos_y + h);
2940 cairo_move_to (cr, pos_x - RULER_DISTANCE - RULER_RADIUS, pos_y - 0.5);
2941 cairo_line_to (cr, pos_x - RULER_DISTANCE + RULER_RADIUS, pos_y - 0.5);
2944 cairo_move_to (cr, pos_x - RULER_DISTANCE - RULER_RADIUS, pos_y + h + 0.5);
2945 cairo_line_to (cr, pos_x - RULER_DISTANCE + RULER_RADIUS, pos_y + h + 0.5);
2950 cairo_move_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE, pos_y);
2951 cairo_line_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE, pos_y + h);
2954 cairo_move_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE - RULER_RADIUS, pos_y - 0.5);
2955 cairo_line_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE + RULER_RADIUS, pos_y - 0.5);
2958 cairo_move_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE - RULER_RADIUS, pos_y + h + 0.5);
2959 cairo_line_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE + RULER_RADIUS, pos_y + h + 0.5);
2963 cairo_move_to (cr, pos_x, pos_y + h + shadow_offset + RULER_DISTANCE);
2964 cairo_line_to (cr, pos_x + w, pos_y + h + shadow_offset + RULER_DISTANCE);
2967 cairo_move_to (cr, pos_x - 0.5, pos_y + h + shadow_offset + RULER_DISTANCE - RULER_RADIUS);
2968 cairo_line_to (cr, pos_x - 0.5, pos_y + h + shadow_offset + RULER_DISTANCE + RULER_RADIUS);
2971 cairo_move_to (cr, pos_x + w + 0.5, pos_y + h + shadow_offset + RULER_DISTANCE - RULER_RADIUS);
2972 cairo_line_to (cr, pos_x + w + 0.5, pos_y + h + shadow_offset + RULER_DISTANCE + RULER_RADIUS);
2982 redraw_page_layout_preview (GtkPrintUnixDialog *dialog)
2984 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2986 if (priv->page_layout_preview)
2987 gtk_widget_queue_draw (priv->page_layout_preview);
2991 update_number_up_layout (GtkPrintUnixDialog *dialog)
2993 GtkPrintUnixDialogPrivate *priv = dialog->priv;
2994 GtkPrintCapabilities caps;
2995 GtkPrinterOptionSet *set;
2996 GtkNumberUpLayout layout;
2997 GtkPrinterOption *option;
2998 GtkPrinterOption *old_option;
2999 GtkPageOrientation page_orientation;
3001 set = priv->options;
3003 caps = priv->manual_capabilities | priv->printer_capabilities;
3005 if (caps & GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT)
3007 if (priv->number_up_layout_n_option == NULL)
3009 priv->number_up_layout_n_option = gtk_printer_option_set_lookup (set, "gtk-n-up-layout");
3010 if (priv->number_up_layout_n_option == NULL)
3012 char *n_up_layout[] = { "lrtb", "lrbt", "rltb", "rlbt", "tblr", "tbrl", "btlr", "btrl" };
3013 /* Translators: These strings name the possible arrangements of
3014 * multiple pages on a sheet when printing (same as in gtkprintbackendcups.c)
3016 char *n_up_layout_display[] = { N_("Left to right, top to bottom"), N_("Left to right, bottom to top"),
3017 N_("Right to left, top to bottom"), N_("Right to left, bottom to top"),
3018 N_("Top to bottom, left to right"), N_("Top to bottom, right to left"),
3019 N_("Bottom to top, left to right"), N_("Bottom to top, right to left") };
3022 priv->number_up_layout_n_option = gtk_printer_option_new ("gtk-n-up-layout",
3024 GTK_PRINTER_OPTION_TYPE_PICKONE);
3025 gtk_printer_option_allocate_choices (priv->number_up_layout_n_option, 8);
3027 for (i = 0; i < G_N_ELEMENTS (n_up_layout_display); i++)
3029 priv->number_up_layout_n_option->choices[i] = g_strdup (n_up_layout[i]);
3030 priv->number_up_layout_n_option->choices_display[i] = g_strdup (_(n_up_layout_display[i]));
3033 g_object_ref (priv->number_up_layout_n_option);
3035 priv->number_up_layout_2_option = gtk_printer_option_new ("gtk-n-up-layout",
3037 GTK_PRINTER_OPTION_TYPE_PICKONE);
3038 gtk_printer_option_allocate_choices (priv->number_up_layout_2_option, 2);
3041 page_orientation = gtk_page_setup_get_orientation (priv->page_setup);
3042 if (page_orientation == GTK_PAGE_ORIENTATION_PORTRAIT ||
3043 page_orientation == GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT)
3045 if (! (priv->number_up_layout_2_option->choices[0] == priv->number_up_layout_n_option->choices[0] &&
3046 priv->number_up_layout_2_option->choices[1] == priv->number_up_layout_n_option->choices[2]))
3048 g_free (priv->number_up_layout_2_option->choices_display[0]);
3049 g_free (priv->number_up_layout_2_option->choices_display[1]);
3050 priv->number_up_layout_2_option->choices[0] = priv->number_up_layout_n_option->choices[0];
3051 priv->number_up_layout_2_option->choices[1] = priv->number_up_layout_n_option->choices[2];
3052 priv->number_up_layout_2_option->choices_display[0] = g_strdup ( _("Left to right"));
3053 priv->number_up_layout_2_option->choices_display[1] = g_strdup ( _("Right to left"));
3058 if (! (priv->number_up_layout_2_option->choices[0] == priv->number_up_layout_n_option->choices[0] &&
3059 priv->number_up_layout_2_option->choices[1] == priv->number_up_layout_n_option->choices[1]))
3061 g_free (priv->number_up_layout_2_option->choices_display[0]);
3062 g_free (priv->number_up_layout_2_option->choices_display[1]);
3063 priv->number_up_layout_2_option->choices[0] = priv->number_up_layout_n_option->choices[0];
3064 priv->number_up_layout_2_option->choices[1] = priv->number_up_layout_n_option->choices[1];
3065 priv->number_up_layout_2_option->choices_display[0] = g_strdup ( _("Top to bottom"));
3066 priv->number_up_layout_2_option->choices_display[1] = g_strdup ( _("Bottom to top"));
3070 layout = dialog_get_number_up_layout (dialog);
3072 old_option = gtk_printer_option_set_lookup (set, "gtk-n-up-layout");
3073 if (old_option != NULL)
3074 gtk_printer_option_set_remove (set, old_option);
3076 if (dialog_get_pages_per_sheet (dialog) != 1)
3078 GEnumClass *enum_class;
3079 GEnumValue *enum_value;
3080 enum_class = g_type_class_ref (GTK_TYPE_NUMBER_UP_LAYOUT);
3082 if (dialog_get_pages_per_sheet (dialog) == 2)
3084 option = priv->number_up_layout_2_option;
3088 case GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM:
3089 case GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT:
3090 enum_value = g_enum_get_value (enum_class, GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM);
3093 case GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP:
3094 case GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT:
3095 enum_value = g_enum_get_value (enum_class, GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP);
3098 case GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM:
3099 case GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT:
3100 enum_value = g_enum_get_value (enum_class, GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM);
3103 case GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP:
3104 case GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT:
3105 enum_value = g_enum_get_value (enum_class, GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP);
3109 g_assert_not_reached();
3115 option = priv->number_up_layout_n_option;
3117 enum_value = g_enum_get_value (enum_class, layout);
3120 g_assert (enum_value != NULL);
3121 gtk_printer_option_set (option, enum_value->value_nick);
3122 g_type_class_unref (enum_class);
3124 gtk_printer_option_set_add (set, option);
3128 setup_option (dialog, "gtk-n-up-layout", priv->number_up_layout);
3130 if (priv->number_up_layout != NULL)
3131 gtk_widget_set_sensitive (GTK_WIDGET (priv->number_up_layout),
3132 (caps & GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT) &&
3133 (dialog_get_pages_per_sheet (dialog) > 1));
3137 custom_paper_dialog_response_cb (GtkDialog *custom_paper_dialog,
3141 GtkPrintUnixDialog *print_dialog = GTK_PRINT_UNIX_DIALOG (user_data);
3142 GtkPrintUnixDialogPrivate *priv = print_dialog->priv;
3143 GtkTreeModel *model;
3146 _gtk_print_load_custom_papers (priv->custom_paper_list);
3148 priv->internal_page_setup_change = TRUE;
3149 update_paper_sizes (print_dialog);
3150 priv->internal_page_setup_change = FALSE;
3152 if (priv->page_setup_set)
3154 model = GTK_TREE_MODEL (priv->custom_paper_list);
3155 if (gtk_tree_model_get_iter_first (model, &iter))
3159 GtkPageSetup *page_setup;
3160 gtk_tree_model_get (model, &iter, 0, &page_setup, -1);
3163 g_strcmp0 (gtk_paper_size_get_display_name (gtk_page_setup_get_paper_size (page_setup)),
3164 gtk_paper_size_get_display_name (gtk_page_setup_get_paper_size (priv->page_setup))) == 0)
3165 gtk_print_unix_dialog_set_page_setup (print_dialog, page_setup);
3167 g_object_unref (page_setup);
3168 } while (gtk_tree_model_iter_next (model, &iter));
3172 gtk_widget_destroy (GTK_WIDGET (custom_paper_dialog));
3176 orientation_changed (GtkComboBox *combo_box,
3177 GtkPrintUnixDialog *dialog)
3179 GtkPrintUnixDialogPrivate *priv = dialog->priv;
3180 GtkPageOrientation orientation;
3181 GtkPageSetup *page_setup;
3183 if (priv->internal_page_setup_change)
3186 orientation = (GtkPageOrientation) gtk_combo_box_get_active (GTK_COMBO_BOX (priv->orientation_combo));
3188 if (priv->page_setup)
3190 page_setup = gtk_page_setup_copy (priv->page_setup);
3192 gtk_page_setup_set_orientation (page_setup, orientation);
3194 gtk_print_unix_dialog_set_page_setup (dialog, page_setup);
3197 redraw_page_layout_preview (dialog);
3201 paper_size_changed (GtkComboBox *combo_box,
3202 GtkPrintUnixDialog *dialog)
3204 GtkPrintUnixDialogPrivate *priv = dialog->priv;
3206 GtkPageSetup *page_setup, *last_page_setup;
3207 GtkPageOrientation orientation;
3209 if (priv->internal_page_setup_change)
3212 if (gtk_combo_box_get_active_iter (combo_box, &iter))
3214 gtk_tree_model_get (gtk_combo_box_get_model (combo_box),
3215 &iter, PAGE_SETUP_LIST_COL_PAGE_SETUP, &page_setup, -1);
3217 if (page_setup == NULL)
3219 GtkWidget *custom_paper_dialog;
3221 /* Change from "manage" menu item to last value */
3222 if (priv->page_setup)
3223 last_page_setup = g_object_ref (priv->page_setup);
3225 last_page_setup = gtk_page_setup_new (); /* "good" default */
3227 if (!set_paper_size (dialog, last_page_setup, FALSE, FALSE))
3228 set_paper_size (dialog, last_page_setup, TRUE, TRUE);
3229 g_object_unref (last_page_setup);
3231 /* And show the custom paper dialog */
3232 custom_paper_dialog = _gtk_custom_paper_unix_dialog_new (GTK_WINDOW (dialog), _("Manage Custom Sizes"));
3233 g_signal_connect (custom_paper_dialog, "response", G_CALLBACK (custom_paper_dialog_response_cb), dialog);
3234 gtk_window_present (GTK_WINDOW (custom_paper_dialog));
3239 if (priv->page_setup)
3240 orientation = gtk_page_setup_get_orientation (priv->page_setup);
3242 orientation = GTK_PAGE_ORIENTATION_PORTRAIT;
3244 gtk_page_setup_set_orientation (page_setup, orientation);
3245 gtk_print_unix_dialog_set_page_setup (dialog, page_setup);
3247 g_object_unref (page_setup);
3250 redraw_page_layout_preview (dialog);
3254 paper_size_row_is_separator (GtkTreeModel *model,
3260 gtk_tree_model_get (model, iter, PAGE_SETUP_LIST_COL_IS_SEPARATOR, &separator, -1);
3265 page_name_func (GtkCellLayout *cell_layout,
3266 GtkCellRenderer *cell,
3267 GtkTreeModel *tree_model,
3271 GtkPageSetup *page_setup;
3272 GtkPaperSize *paper_size;
3274 gtk_tree_model_get (tree_model, iter,
3275 PAGE_SETUP_LIST_COL_PAGE_SETUP, &page_setup, -1);
3278 paper_size = gtk_page_setup_get_paper_size (page_setup);
3279 g_object_set (cell, "text", gtk_paper_size_get_display_name (paper_size), NULL);
3280 g_object_unref (page_setup);
3283 g_object_set (cell, "text", _("Manage Custom Sizes..."), NULL);
3287 create_page_setup_page (GtkPrintUnixDialog *dialog)
3289 GtkPrintUnixDialogPrivate *priv = dialog->priv;
3290 GtkWidget *main_vbox, *label, *hbox, *hbox2;
3291 GtkWidget *frame, *table, *widget;
3292 GtkWidget *combo, *spinbutton, *draw;
3293 GtkCellRenderer *cell;
3295 main_vbox = gtk_vbox_new (FALSE, 18);
3296 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
3297 gtk_widget_show (main_vbox);
3299 hbox = gtk_hbox_new (FALSE, 18);
3300 gtk_widget_show (hbox);
3301 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
3303 table = gtk_table_new (5, 2, FALSE);
3304 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3305 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3306 frame = wrap_in_frame (_("Layout"), table);
3307 gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
3308 gtk_widget_show (table);
3310 label = gtk_label_new_with_mnemonic (_("T_wo-sided:"));
3311 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3312 gtk_widget_show (label);
3313 gtk_table_attach (GTK_TABLE (table), label,
3314 0, 1, 0, 1, GTK_FILL, 0,
3317 widget = gtk_printer_option_widget_new (NULL);
3318 priv->duplex = GTK_PRINTER_OPTION_WIDGET (widget);
3319 gtk_widget_show (widget);
3320 gtk_table_attach (GTK_TABLE (table), widget,
3321 1, 2, 0, 1, GTK_FILL, 0,
3323 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3325 label = gtk_label_new_with_mnemonic (_("Pages per _side:"));
3326 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3327 gtk_widget_show (label);
3328 gtk_table_attach (GTK_TABLE (table), label,
3329 0, 1, 1, 2, GTK_FILL, 0,
3332 widget = gtk_printer_option_widget_new (NULL);
3333 g_signal_connect_swapped (widget, "changed", G_CALLBACK (redraw_page_layout_preview), dialog);
3334 g_signal_connect_swapped (widget, "changed", G_CALLBACK (update_number_up_layout), dialog);
3335 priv->pages_per_sheet = GTK_PRINTER_OPTION_WIDGET (widget);
3336 gtk_widget_show (widget);
3337 gtk_table_attach (GTK_TABLE (table), widget,
3338 1, 2, 1, 2, GTK_FILL, 0,
3340 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3342 label = gtk_label_new_with_mnemonic (_("Page or_dering:"));
3343 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3344 gtk_widget_show (label);
3345 gtk_table_attach (GTK_TABLE (table), label,
3346 0, 1, 2, 3, GTK_FILL, 0,
3349 widget = gtk_printer_option_widget_new (NULL);
3350 g_signal_connect_swapped (widget, "changed", G_CALLBACK (redraw_page_layout_preview), dialog);
3351 priv->number_up_layout = GTK_PRINTER_OPTION_WIDGET (widget);
3352 gtk_widget_show (widget);
3353 gtk_table_attach (GTK_TABLE (table), widget,
3354 1, 2, 2, 3, GTK_FILL, 0,
3356 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3358 label = gtk_label_new_with_mnemonic (_("_Only print:"));
3359 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3360 gtk_widget_show (label);
3361 gtk_table_attach (GTK_TABLE (table), label,
3362 0, 1, 3, 4, GTK_FILL, 0,
3365 combo = gtk_combo_box_new_text ();
3366 priv->page_set_combo = combo;
3367 gtk_widget_show (combo);
3368 gtk_table_attach (GTK_TABLE (table), combo,
3369 1, 2, 3, 4, GTK_FILL, 0,
3371 gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
3373 gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("All sheets"));
3374 gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Even sheets"));
3375 gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Odd sheets"));
3376 gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
3378 label = gtk_label_new_with_mnemonic (_("Sc_ale:"));
3379 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3380 gtk_widget_show (label);
3381 gtk_table_attach (GTK_TABLE (table), label,
3382 0, 1, 4, 5, GTK_FILL, 0,
3385 hbox2 = gtk_hbox_new (FALSE, 6);
3386 gtk_widget_show (hbox2);
3387 gtk_table_attach (GTK_TABLE (table), hbox2,
3388 1, 2, 4, 5, GTK_FILL, 0,
3391 spinbutton = gtk_spin_button_new_with_range (1.0, 1000.0, 1.0);
3392 priv->scale_spin = spinbutton;
3393 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinbutton), 1);
3394 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinbutton), 100.0);
3395 gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0);
3396 gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
3397 gtk_widget_show (spinbutton);
3398 label = gtk_label_new ("%"); /* FIXMEchpe does there exist any language where % needs to be translated? */
3399 gtk_widget_show (label);
3400 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
3402 table = gtk_table_new (4, 2, FALSE);
3403 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3404 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3405 frame = wrap_in_frame (_("Paper"), table);
3406 gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 6);
3407 gtk_widget_show (table);
3409 label = gtk_label_new_with_mnemonic (_("Paper _type:"));
3410 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3411 gtk_widget_show (label);
3412 gtk_table_attach (GTK_TABLE (table), label,
3413 0, 1, 0, 1, GTK_FILL, 0,
3416 widget = gtk_printer_option_widget_new (NULL);
3417 priv->paper_type = GTK_PRINTER_OPTION_WIDGET (widget);
3418 gtk_widget_show (widget);
3419 gtk_table_attach (GTK_TABLE (table), widget,
3420 1, 2, 0, 1, GTK_FILL, 0,
3422 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3424 label = gtk_label_new_with_mnemonic (_("Paper _source:"));
3425 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3426 gtk_widget_show (label);
3427 gtk_table_attach (GTK_TABLE (table), label,
3428 0, 1, 1, 2, GTK_FILL, 0,
3431 widget = gtk_printer_option_widget_new (NULL);
3432 priv->paper_source = GTK_PRINTER_OPTION_WIDGET (widget);
3433 gtk_widget_show (widget);
3434 gtk_table_attach (GTK_TABLE (table), widget,
3435 1, 2, 1, 2, GTK_FILL, 0,
3437 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3439 label = gtk_label_new_with_mnemonic (_("Output t_ray:"));
3440 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3441 gtk_widget_show (label);
3442 gtk_table_attach (GTK_TABLE (table), label,
3443 0, 1, 2, 3, GTK_FILL, 0,
3446 widget = gtk_printer_option_widget_new (NULL);
3447 priv->output_tray = GTK_PRINTER_OPTION_WIDGET (widget);
3448 gtk_widget_show (widget);
3449 gtk_table_attach (GTK_TABLE (table), widget,
3450 1, 2, 2, 3, GTK_FILL, 0,
3452 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3455 label = gtk_label_new_with_mnemonic (_("_Paper size:"));
3456 priv->paper_size_combo_label = GTK_WIDGET (label);
3457 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3458 gtk_widget_show (label);
3459 gtk_table_attach (GTK_TABLE (table), label,
3460 0, 1, 3, 4, GTK_FILL, 0,
3463 combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->page_setup_list));
3464 priv->paper_size_combo = GTK_WIDGET (combo);
3465 gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo),
3466 paper_size_row_is_separator, NULL, NULL);
3467 cell = gtk_cell_renderer_text_new ();
3468 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
3469 gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell,
3470 page_name_func, NULL, NULL);
3471 gtk_table_attach (GTK_TABLE (table), combo,
3472 1, 2, 3, 4, GTK_FILL, 0,
3474 gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
3475 gtk_widget_set_sensitive (combo, FALSE);
3476 gtk_widget_show (combo);
3479 label = gtk_label_new_with_mnemonic (_("Or_ientation:"));
3480 priv->orientation_combo_label = GTK_WIDGET (label);
3481 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3482 gtk_widget_show (label);
3483 gtk_table_attach (GTK_TABLE (table), label,
3487 combo = gtk_combo_box_new_text ();
3488 priv->orientation_combo = GTK_WIDGET (combo);
3489 gtk_table_attach (GTK_TABLE (table), combo,
3490 1, 2, 4, 5, GTK_FILL, 0,
3492 gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
3494 gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Portrait"));
3495 gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Landscape"));
3496 gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Reverse portrait"));
3497 gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Reverse landscape"));
3498 gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
3499 gtk_widget_set_sensitive (combo, FALSE);
3500 gtk_widget_show (combo);
3503 /* Add the page layout preview */
3504 hbox2 = gtk_hbox_new (FALSE, 0);
3505 gtk_widget_show (hbox2);
3506 gtk_box_pack_start (GTK_BOX (main_vbox), hbox2, TRUE, TRUE, 0);
3508 draw = gtk_drawing_area_new ();
3509 gtk_widget_set_has_window (draw, FALSE);
3510 priv->page_layout_preview = draw;
3511 gtk_widget_set_size_request (draw, 350, 200);
3512 g_signal_connect (draw, "expose-event", G_CALLBACK (draw_page_cb), dialog);
3513 gtk_widget_show (draw);
3515 gtk_box_pack_start (GTK_BOX (hbox2), draw, TRUE, FALSE, 0);
3517 label = gtk_label_new (_("Page Setup"));
3518 gtk_widget_show (label);
3520 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
3525 create_job_page (GtkPrintUnixDialog *dialog)
3527 GtkPrintUnixDialogPrivate *priv = dialog->priv;
3528 GtkWidget *main_table, *label;
3529 GtkWidget *frame, *table, *radio;
3530 GtkWidget *entry, *widget;
3531 const gchar *at_tooltip;
3532 const gchar *on_hold_tooltip;
3534 main_table = gtk_table_new (2, 2, FALSE);
3535 gtk_container_set_border_width (GTK_CONTAINER (main_table), 12);
3536 gtk_table_set_row_spacings (GTK_TABLE (main_table), 18);
3537 gtk_table_set_col_spacings (GTK_TABLE (main_table), 18);
3539 table = gtk_table_new (2, 2, FALSE);
3540 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3541 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3542 frame = wrap_in_frame (_("Job Details"), table);
3543 gtk_table_attach (GTK_TABLE (main_table), frame,
3544 0, 1, 0, 1, GTK_FILL, 0,
3546 gtk_widget_show (table);
3548 label = gtk_label_new_with_mnemonic (_("Pri_ority:"));
3549 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3550 gtk_widget_show (label);
3551 gtk_table_attach (GTK_TABLE (table), label,
3552 0, 1, 0, 1, GTK_FILL, 0,
3555 widget = gtk_printer_option_widget_new (NULL);
3556 priv->job_prio = GTK_PRINTER_OPTION_WIDGET (widget);
3557 gtk_widget_show (widget);
3558 gtk_table_attach (GTK_TABLE (table), widget,
3559 1, 2, 0, 1, GTK_FILL, 0,
3561 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3563 label = gtk_label_new_with_mnemonic (_("_Billing info:"));
3564 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3565 gtk_widget_show (label);
3566 gtk_table_attach (GTK_TABLE (table), label,
3567 0, 1, 1, 2, GTK_FILL, 0,
3570 widget = gtk_printer_option_widget_new (NULL);
3571 priv->billing_info = GTK_PRINTER_OPTION_WIDGET (widget);
3572 gtk_widget_show (widget);
3573 gtk_table_attach (GTK_TABLE (table), widget,
3574 1, 2, 1, 2, GTK_FILL, 0,
3576 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3578 table = gtk_table_new (2, 2, FALSE);
3579 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3580 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3581 frame = wrap_in_frame (_("Print Document"), table);
3582 gtk_table_attach (GTK_TABLE (main_table), frame,
3583 0, 1, 1, 2, GTK_FILL, 0,
3585 gtk_widget_show (table);
3587 /* Translators: this is one of the choices for the print at option
3588 * in the print dialog
3590 radio = gtk_radio_button_new_with_mnemonic (NULL, _("_Now"));
3591 priv->print_now_radio = radio;
3592 gtk_widget_show (radio);
3593 gtk_table_attach (GTK_TABLE (table), radio,
3594 0, 2, 0, 1, GTK_FILL, 0,
3596 /* Translators: this is one of the choices for the print at option
3597 * in the print dialog. It also serves as the label for an entry that
3598 * allows the user to enter a time.
3600 radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
3603 /* Translators: Ability to parse the am/pm format depends on actual locale.
3604 * You can remove the am/pm values below for your locale if they are not
3607 at_tooltip = _("Specify the time of print,\n e.g. 15:30, 2:35 pm, 14:15:20, 11:46:30 am, 4 pm");
3608 gtk_widget_set_tooltip_text (radio, at_tooltip);
3609 priv->print_at_radio = radio;
3610 gtk_widget_show (radio);
3611 gtk_table_attach (GTK_TABLE (table), radio,
3612 0, 1, 1, 2, GTK_FILL, 0,
3615 entry = gtk_entry_new ();
3616 gtk_widget_set_tooltip_text (entry, at_tooltip);
3617 atk_object_set_name (gtk_widget_get_accessible (entry), _("Time of print"));
3618 atk_object_set_description (gtk_widget_get_accessible (entry), at_tooltip);
3619 priv->print_at_entry = entry;
3620 gtk_widget_show (entry);
3621 gtk_table_attach (GTK_TABLE (table), entry,
3622 1, 2, 1, 2, GTK_FILL, 0,
3625 g_signal_connect (radio, "toggled", G_CALLBACK (update_entry_sensitivity), entry);
3626 update_entry_sensitivity (radio, entry);
3628 /* Translators: this is one of the choices for the print at option
3629 * in the print dialog. It means that the print job will not be
3630 * printed until it explicitly gets 'released'.
3632 radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
3634 on_hold_tooltip = _("Hold the job until it is explicitly released");
3635 gtk_widget_set_tooltip_text (radio, on_hold_tooltip);
3636 priv->print_hold_radio = radio;
3637 gtk_widget_show (radio);
3638 gtk_table_attach (GTK_TABLE (table), radio,
3639 0, 2, 2, 3, GTK_FILL, 0,
3642 g_signal_connect_swapped (priv->print_now_radio, "toggled",
3643 G_CALLBACK (update_print_at_option), dialog);
3644 g_signal_connect_swapped (priv->print_at_radio, "toggled",
3645 G_CALLBACK (update_print_at_option), dialog);
3646 g_signal_connect_swapped (priv->print_at_entry, "changed",
3647 G_CALLBACK (update_print_at_option), dialog);
3648 g_signal_connect_swapped (priv->print_hold_radio, "toggled",
3649 G_CALLBACK (update_print_at_option), dialog);
3651 table = gtk_table_new (2, 2, FALSE);
3652 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3653 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3654 frame = wrap_in_frame (_("Add Cover Page"), table);
3655 gtk_table_attach (GTK_TABLE (main_table), frame,
3656 1, 2, 0, 1, GTK_FILL, 0,
3658 gtk_widget_show (table);
3660 /* Translators, this is the label used for the option in the print
3661 * dialog that controls the front cover page.
3663 label = gtk_label_new_with_mnemonic (_("Be_fore:"));
3664 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3665 gtk_widget_show (label);
3666 gtk_table_attach (GTK_TABLE (table), label,
3667 0, 1, 0, 1, GTK_FILL, 0,
3670 widget = gtk_printer_option_widget_new (NULL);
3671 priv->cover_before = GTK_PRINTER_OPTION_WIDGET (widget);
3672 gtk_widget_show (widget);
3673 gtk_table_attach (GTK_TABLE (table), widget,
3674 1, 2, 0, 1, GTK_FILL, 0,
3676 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3678 /* Translators, this is the label used for the option in the print
3679 * dialog that controls the back cover page.
3681 label = gtk_label_new_with_mnemonic (_("_After:"));
3682 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3683 gtk_widget_show (label);
3684 gtk_table_attach (GTK_TABLE (table), label,
3685 0, 1, 1, 2, GTK_FILL, 0,
3688 widget = gtk_printer_option_widget_new (NULL);
3689 priv->cover_after = GTK_PRINTER_OPTION_WIDGET (widget);
3690 gtk_widget_show (widget);
3691 gtk_table_attach (GTK_TABLE (table), widget,
3692 1, 2, 1, 2, GTK_FILL, 0,
3694 gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3696 /* Translators: this is the tab label for the notebook tab containing
3697 * job-specific options in the print dialog
3699 label = gtk_label_new (_("Job"));
3700 gtk_widget_show (label);
3702 priv->job_page = main_table;
3703 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
3708 create_optional_page (GtkPrintUnixDialog *dialog,
3710 GtkWidget **table_out,
3711 GtkWidget **page_out)
3713 GtkPrintUnixDialogPrivate *priv = dialog->priv;
3714 GtkWidget *table, *label, *scrolled;
3716 scrolled = gtk_scrolled_window_new (NULL, NULL);
3717 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
3719 GTK_POLICY_AUTOMATIC);
3721 table = gtk_table_new (1, 2, FALSE);
3722 gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3723 gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3724 gtk_container_set_border_width (GTK_CONTAINER (table), 12);
3725 gtk_widget_show (table);
3727 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
3729 gtk_viewport_set_shadow_type (GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (scrolled))),
3732 label = gtk_label_new (text);
3733 gtk_widget_show (label);
3735 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
3739 *page_out = scrolled;
3743 create_advanced_page (GtkPrintUnixDialog *dialog)
3745 GtkPrintUnixDialogPrivate *priv = dialog->priv;
3746 GtkWidget *main_vbox, *label, *scrolled;
3748 scrolled = gtk_scrolled_window_new (NULL, NULL);
3749 priv->advanced_page = scrolled;
3750 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
3752 GTK_POLICY_AUTOMATIC);
3754 main_vbox = gtk_vbox_new (FALSE, 18);
3755 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
3756 gtk_widget_show (main_vbox);
3758 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
3760 gtk_viewport_set_shadow_type (GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (scrolled))),
3763 priv->advanced_vbox = main_vbox;
3765 label = gtk_label_new (_("Advanced"));
3766 gtk_widget_show (label);
3768 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
3773 populate_dialog (GtkPrintUnixDialog *print_dialog)
3775 GtkPrintUnixDialogPrivate *priv = print_dialog->priv;
3776 GtkDialog *dialog = GTK_DIALOG (print_dialog);
3777 GtkWidget *vbox, *conflict_hbox, *image, *label;
3778 GtkWidget *action_area, *content_area;
3780 content_area = gtk_dialog_get_content_area (dialog);
3781 action_area = gtk_dialog_get_action_area (dialog);
3783 gtk_dialog_set_has_separator (dialog, FALSE);
3784 gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
3785 gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */
3786 gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
3787 gtk_box_set_spacing (GTK_BOX (action_area), 6);
3789 vbox = gtk_vbox_new (FALSE, 6);
3790 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
3791 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
3792 gtk_widget_show (vbox);
3794 priv->notebook = gtk_notebook_new ();
3795 gtk_box_pack_start (GTK_BOX (vbox), priv->notebook, TRUE, TRUE, 0);
3796 gtk_widget_show (priv->notebook);
3798 create_printer_list_model (print_dialog);
3800 create_main_page (print_dialog);
3801 create_page_setup_page (print_dialog);
3802 create_job_page (print_dialog);
3803 /* Translators: this will appear as tab label in print dialog. */
3804 create_optional_page (print_dialog, _("Image Quality"),
3805 &priv->image_quality_table,
3806 &priv->image_quality_page);
3807 /* Translators: this will appear as tab label in print dialog. */
3808 create_optional_page (print_dialog, _("Color"),
3811 /* Translators: this will appear as tab label in print dialog. */
3812 /* It's a typographical term, as in "Binding and finishing" */
3813 create_optional_page (print_dialog, _("Finishing"),
3814 &priv->finishing_table,
3815 &priv->finishing_page);
3816 create_advanced_page (print_dialog);
3818 priv->conflicts_widget = conflict_hbox = gtk_hbox_new (FALSE, 12);
3819 gtk_box_pack_end (GTK_BOX (vbox), conflict_hbox, FALSE, FALSE, 0);
3820 image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU);
3821 gtk_widget_show (image);
3822 gtk_box_pack_start (GTK_BOX (conflict_hbox), image, FALSE, TRUE, 0);
3823 label = gtk_label_new (_("Some of the settings in the dialog conflict"));
3824 gtk_widget_show (label);
3825 gtk_box_pack_start (GTK_BOX (conflict_hbox), label, FALSE, TRUE, 0);
3827 load_print_backends (print_dialog);
3831 * gtk_print_unix_dialog_new:
3832 * @title: (allow-none): Title of the dialog, or %NULL
3833 * @parent: (allow-none): Transient parent of the dialog, or %NULL
3835 * Creates a new #GtkPrintUnixDialog.
3837 * Return value: a new #GtkPrintUnixDialog
3842 gtk_print_unix_dialog_new (const gchar *title,
3846 const gchar *_title = _("Print");
3851 result = g_object_new (GTK_TYPE_PRINT_UNIX_DIALOG,
3852 "transient-for", parent,
3854 "has-separator", FALSE,
3861 * gtk_print_unix_dialog_get_selected_printer:
3862 * @dialog: a #GtkPrintUnixDialog
3864 * Gets the currently selected printer.
3866 * Returns: the currently selected printer
3871 gtk_print_unix_dialog_get_selected_printer (GtkPrintUnixDialog *dialog)
3873 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
3875 return dialog->priv->current_printer;
3879 * gtk_print_unix_dialog_set_page_setup:
3880 * @dialog: a #GtkPrintUnixDialog
3881 * @page_setup: a #GtkPageSetup
3883 * Sets the page setup of the #GtkPrintUnixDialog.
3888 gtk_print_unix_dialog_set_page_setup (GtkPrintUnixDialog *dialog,
3889 GtkPageSetup *page_setup)
3891 GtkPrintUnixDialogPrivate *priv;
3893 g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
3894 g_return_if_fail (GTK_IS_PAGE_SETUP (page_setup));
3896 priv = dialog->priv;
3898 if (priv->page_setup != page_setup)
3900 g_object_unref (priv->page_setup);
3901 priv->page_setup = g_object_ref (page_setup);
3903 priv->page_setup_set = TRUE;
3905 g_object_notify (G_OBJECT (dialog), "page-setup");
3910 * gtk_print_unix_dialog_get_page_setup:
3911 * @dialog: a #GtkPrintUnixDialog
3913 * Gets the page setup that is used by the #GtkPrintUnixDialog.
3915 * Returns: the page setup of @dialog.
3920 gtk_print_unix_dialog_get_page_setup (GtkPrintUnixDialog *dialog)
3922 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
3924 return dialog->priv->page_setup;
3928 * gtk_print_unix_dialog_get_page_setup_set:
3929 * @dialog: a #GtkPrintUnixDialog
3931 * Gets the page setup that is used by the #GtkPrintUnixDialog.
3933 * Returns: whether a page setup was set by user.
3938 gtk_print_unix_dialog_get_page_setup_set (GtkPrintUnixDialog *dialog)
3940 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
3942 return dialog->priv->page_setup_set;
3946 * gtk_print_unix_dialog_set_current_page:
3947 * @dialog: a #GtkPrintUnixDialog
3948 * @current_page: the current page number.
3950 * Sets the current page number. If @current_page is not -1, this enables
3951 * the current page choice for the range of pages to print.
3956 gtk_print_unix_dialog_set_current_page (GtkPrintUnixDialog *dialog,
3959 GtkPrintUnixDialogPrivate *priv;
3961 g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
3963 priv = dialog->priv;
3965 if (priv->current_page != current_page)
3967 priv->current_page = current_page;
3969 if (priv->current_page_radio)
3970 gtk_widget_set_sensitive (priv->current_page_radio, current_page != -1);
3972 g_object_notify (G_OBJECT (dialog), "current-page");
3977 * gtk_print_unix_dialog_get_current_page:
3978 * @dialog: a #GtkPrintUnixDialog
3980 * Gets the current page of the #GtkPrintDialog.
3982 * Returns: the current page of @dialog
3987 gtk_print_unix_dialog_get_current_page (GtkPrintUnixDialog *dialog)
3989 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), -1);
3991 return dialog->priv->current_page;
3995 set_active_printer (GtkPrintUnixDialog *dialog,
3996 const gchar *printer_name)
3998 GtkPrintUnixDialogPrivate *priv = dialog->priv;
3999 GtkTreeModel *model;
4000 GtkTreeIter iter, filter_iter;
4001 GtkTreeSelection *selection;
4002 GtkPrinter *printer;
4004 model = GTK_TREE_MODEL (priv->printer_list);
4006 if (gtk_tree_model_get_iter_first (model, &iter))
4010 gtk_tree_model_get (GTK_TREE_MODEL (priv->printer_list), &iter,
4011 PRINTER_LIST_COL_PRINTER_OBJ, &printer, -1);
4012 if (printer == NULL)
4015 if (strcmp (gtk_printer_get_name (printer), printer_name) == 0)
4017 gtk_tree_model_filter_convert_child_iter_to_iter (priv->printer_list_filter,
4018 &filter_iter, &iter);
4020 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
4021 priv->internal_printer_change = TRUE;
4022 gtk_tree_selection_select_iter (selection, &filter_iter);
4023 priv->internal_printer_change = FALSE;
4024 g_free (priv->waiting_for_printer);
4025 priv->waiting_for_printer = NULL;
4027 g_object_unref (printer);
4031 g_object_unref (printer);
4033 } while (gtk_tree_model_iter_next (model, &iter));
4040 * gtk_print_unix_dialog_set_settings:
4041 * @dialog: a #GtkPrintUnixDialog
4042 * @settings: (allow-none): a #GtkPrintSettings, or %NULL
4044 * Sets the #GtkPrintSettings for the #GtkPrintUnixDialog. Typically,
4045 * this is used to restore saved print settings from a previous print
4046 * operation before the print dialog is shown.
4051 gtk_print_unix_dialog_set_settings (GtkPrintUnixDialog *dialog,
4052 GtkPrintSettings *settings)
4054 GtkPrintUnixDialogPrivate *priv;
4055 const gchar *printer;
4056 GtkPageRange *ranges;
4059 g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
4060 g_return_if_fail (settings == NULL || GTK_IS_PRINT_SETTINGS (settings));
4062 priv = dialog->priv;
4064 if (settings != NULL)
4066 dialog_set_collate (dialog, gtk_print_settings_get_collate (settings));
4067 dialog_set_reverse (dialog, gtk_print_settings_get_reverse (settings));
4068 dialog_set_n_copies (dialog, gtk_print_settings_get_n_copies (settings));
4069 dialog_set_scale (dialog, gtk_print_settings_get_scale (settings));
4070 dialog_set_page_set (dialog, gtk_print_settings_get_page_set (settings));
4071 dialog_set_print_pages (dialog, gtk_print_settings_get_print_pages (settings));
4072 ranges = gtk_print_settings_get_page_ranges (settings, &num_ranges);
4075 dialog_set_page_ranges (dialog, ranges, num_ranges);
4079 priv->format_for_printer =
4080 g_strdup (gtk_print_settings_get (settings, "format-for-printer"));
4083 if (priv->initial_settings)
4084 g_object_unref (priv->initial_settings);
4086 priv->initial_settings = settings;
4088 g_free (priv->waiting_for_printer);
4089 priv->waiting_for_printer = NULL;
4093 g_object_ref (settings);
4095 printer = gtk_print_settings_get_printer (settings);
4097 if (printer && !set_active_printer (dialog, printer))
4098 priv->waiting_for_printer = g_strdup (printer);
4101 g_object_notify (G_OBJECT (dialog), "print-settings");
4105 * gtk_print_unix_dialog_get_settings:
4106 * @dialog: a #GtkPrintUnixDialog
4108 * Gets a new #GtkPrintSettings object that represents the
4109 * current values in the print dialog. Note that this creates a
4110 * <emphasis>new object</emphasis>, and you need to unref it
4111 * if don't want to keep it.
4113 * Returns: a new #GtkPrintSettings object with the values from @dialog
4118 gtk_print_unix_dialog_get_settings (GtkPrintUnixDialog *dialog)
4120 GtkPrintUnixDialogPrivate *priv;
4121 GtkPrintSettings *settings;
4122 GtkPrintPages print_pages;
4123 GtkPageRange *ranges;
4126 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
4128 priv = dialog->priv;
4129 settings = gtk_print_settings_new ();
4131 if (priv->current_printer)
4132 gtk_print_settings_set_printer (settings,
4133 gtk_printer_get_name (priv->current_printer));
4135 gtk_print_settings_set_printer (settings, "default");
4137 gtk_print_settings_set (settings, "format-for-printer",
4138 priv->format_for_printer);
4140 gtk_print_settings_set_collate (settings,
4141 dialog_get_collate (dialog));
4143 gtk_print_settings_set_reverse (settings,
4144 dialog_get_reverse (dialog));
4146 gtk_print_settings_set_n_copies (settings,
4147 dialog_get_n_copies (dialog));
4149 gtk_print_settings_set_scale (settings,
4150 dialog_get_scale (dialog));
4152 gtk_print_settings_set_page_set (settings,
4153 dialog_get_page_set (dialog));
4155 print_pages = dialog_get_print_pages (dialog);
4156 gtk_print_settings_set_print_pages (settings, print_pages);
4158 ranges = dialog_get_page_ranges (dialog, &n_ranges);
4161 gtk_print_settings_set_page_ranges (settings, ranges, n_ranges);
4165 /* TODO: print when. How to handle? */
4167 if (priv->current_printer)
4168 _gtk_printer_get_settings_from_options (priv->current_printer,
4176 * gtk_print_unix_dialog_add_custom_tab:
4177 * @dialog: a #GtkPrintUnixDialog
4178 * @child: the widget to put in the custom tab
4179 * @tab_label: the widget to use as tab label
4181 * Adds a custom tab to the print dialog.
4186 gtk_print_unix_dialog_add_custom_tab (GtkPrintUnixDialog *dialog,
4188 GtkWidget *tab_label)
4190 gtk_notebook_insert_page (GTK_NOTEBOOK (dialog->priv->notebook),
4191 child, tab_label, 2);
4192 gtk_widget_show (child);
4193 gtk_widget_show (tab_label);
4197 * gtk_print_unix_dialog_set_manual_capabilities:
4198 * @dialog: a #GtkPrintUnixDialog
4199 * @capabilities: the printing capabilities of your application
4201 * This lets you specify the printing capabilities your application
4202 * supports. For instance, if you can handle scaling the output then
4203 * you pass #GTK_PRINT_CAPABILITY_SCALE. If you don't pass that, then
4204 * the dialog will only let you select the scale if the printing
4205 * system automatically handles scaling.
4210 gtk_print_unix_dialog_set_manual_capabilities (GtkPrintUnixDialog *dialog,
4211 GtkPrintCapabilities capabilities)
4213 GtkPrintUnixDialogPrivate *priv = dialog->priv;
4215 if (priv->manual_capabilities != capabilities)
4217 priv->manual_capabilities = capabilities;
4218 update_dialog_from_capabilities (dialog);
4220 if (priv->current_printer)
4222 GtkTreeSelection *selection;
4224 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
4226 g_object_unref (priv->current_printer);
4227 priv->current_printer = NULL;
4228 priv->internal_printer_change = TRUE;
4229 selected_printer_changed (selection, dialog);
4230 priv->internal_printer_change = FALSE;
4233 g_object_notify (G_OBJECT (dialog), "manual-capabilities");
4238 * gtk_print_unix_dialog_get_manual_capabilities:
4239 * @dialog: a #GtkPrintUnixDialog
4241 * Gets the value of #GtkPrintUnixDialog::manual-capabilities property.
4243 * Returns: the printing capabilities
4247 GtkPrintCapabilities
4248 gtk_print_unix_dialog_get_manual_capabilities (GtkPrintUnixDialog *dialog)
4250 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
4252 return dialog->priv->manual_capabilities;
4256 * gtk_print_unix_dialog_set_support_selection:
4257 * @dialog: a #GtkPrintUnixDialog
4258 * @support_selection: %TRUE to allow print selection
4260 * Sets whether the print dialog allows user to print a selection.
4265 gtk_print_unix_dialog_set_support_selection (GtkPrintUnixDialog *dialog,
4266 gboolean support_selection)
4268 GtkPrintUnixDialogPrivate *priv;
4270 g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
4272 priv = dialog->priv;
4274 support_selection = support_selection != FALSE;
4275 if (priv->support_selection != support_selection)
4277 priv->support_selection = support_selection;
4279 if (priv->selection_radio)
4281 if (support_selection)
4283 gtk_widget_set_sensitive (priv->selection_radio, priv->has_selection);
4284 gtk_table_set_row_spacing (GTK_TABLE (priv->range_table),
4286 gtk_table_get_default_row_spacing (GTK_TABLE (priv->range_table)));
4287 gtk_widget_show (priv->selection_radio);
4291 gtk_widget_set_sensitive (priv->selection_radio, FALSE);
4292 gtk_table_set_row_spacing (GTK_TABLE (priv->range_table), 2, 0);
4293 gtk_widget_hide (priv->selection_radio);
4297 g_object_notify (G_OBJECT (dialog), "support-selection");
4302 * gtk_print_unix_dialog_get_support_selection:
4303 * @dialog: a #GtkPrintUnixDialog
4305 * Gets the value of #GtkPrintUnixDialog::support-selection property.
4307 * Returns: whether the application supports print of selection
4312 gtk_print_unix_dialog_get_support_selection (GtkPrintUnixDialog *dialog)
4314 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
4316 return dialog->priv->support_selection;
4320 * gtk_print_unix_dialog_set_has_selection:
4321 * @dialog: a #GtkPrintUnixDialog
4322 * @has_selection: %TRUE indicates that a selection exists
4324 * Sets whether a selection exists.
4329 gtk_print_unix_dialog_set_has_selection (GtkPrintUnixDialog *dialog,
4330 gboolean has_selection)
4332 GtkPrintUnixDialogPrivate *priv;
4334 g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
4336 priv = dialog->priv;
4338 has_selection = has_selection != FALSE;
4339 if (priv->has_selection != has_selection)
4341 priv->has_selection = has_selection;
4343 if (priv->selection_radio)
4345 if (priv->support_selection)
4346 gtk_widget_set_sensitive (priv->selection_radio, has_selection);
4348 gtk_widget_set_sensitive (priv->selection_radio, FALSE);
4351 g_object_notify (G_OBJECT (dialog), "has-selection");
4356 * gtk_print_unix_dialog_get_has_selection:
4357 * @dialog: a #GtkPrintUnixDialog
4359 * Gets the value of #GtkPrintUnixDialog::has-selection property.
4361 * Returns: whether there is a selection
4366 gtk_print_unix_dialog_get_has_selection (GtkPrintUnixDialog *dialog)
4368 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
4370 return dialog->priv->has_selection;
4374 * gtk_print_unix_dialog_set_embed_page_setup
4375 * @dialog: a #GtkPrintUnixDialog
4376 * @embed: embed page setup selection
4378 * Embed page size combo box and orientation combo box into page setup page.
4383 gtk_print_unix_dialog_set_embed_page_setup (GtkPrintUnixDialog *dialog,
4386 GtkPrintUnixDialogPrivate *priv;
4388 g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
4390 priv = dialog->priv;
4392 embed = embed != FALSE;
4393 if (priv->embed_page_setup != embed)
4395 priv->embed_page_setup = embed;
4397 gtk_widget_set_sensitive (priv->paper_size_combo, priv->embed_page_setup);
4398 gtk_widget_set_sensitive (priv->orientation_combo, priv->embed_page_setup);
4400 if (priv->embed_page_setup)
4402 if (priv->paper_size_combo != NULL)
4403 g_signal_connect (priv->paper_size_combo, "changed", G_CALLBACK (paper_size_changed), dialog);
4405 if (priv->orientation_combo)
4406 g_signal_connect (priv->orientation_combo, "changed", G_CALLBACK (orientation_changed), dialog);
4410 if (priv->paper_size_combo != NULL)
4411 g_signal_handlers_disconnect_by_func (priv->paper_size_combo, G_CALLBACK (paper_size_changed), dialog);
4413 if (priv->orientation_combo)
4414 g_signal_handlers_disconnect_by_func (priv->orientation_combo, G_CALLBACK (orientation_changed), dialog);
4417 priv->internal_page_setup_change = TRUE;
4418 update_paper_sizes (dialog);
4419 priv->internal_page_setup_change = FALSE;
4424 * gtk_print_unix_dialog_get_embed_page_setup:
4425 * @dialog: a #GtkPrintUnixDialog
4427 * Gets the value of #GtkPrintUnixDialog::embed-page-setup property.
4429 * Returns: whether there is a selection
4434 gtk_print_unix_dialog_get_embed_page_setup (GtkPrintUnixDialog *dialog)
4436 g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
4438 return dialog->priv->embed_page_setup;