Pileus Git - ~andy/gtk/blob - gtk/gtkprintunixdialog.c

   1 /* GtkPrintUnixDialog
   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
   5  *
   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.
  10  *
  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.
  15  *
  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.
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <stdio.h>
  28 #include <math.h>
  29
  30 #include "gtkprintunixdialog.h"
  31
  32 #include "gtkcustompaperunixdialog.h"
  33 #include "gtkprintbackend.h"
  34 #include "gtkprinter-private.h"
  35 #include "gtkprinteroptionwidget.h"
  36 #include "gtkprintutils.h"
  37
  38 #include "gtkspinbutton.h"
  39 #include "gtkcellrendererpixbuf.h"
  40 #include "gtkcellrenderertext.h"
  41 #include "gtkstock.h"
  42 #include "gtkiconfactory.h"
  43 #include "gtkimage.h"
  44 #include "gtktreeselection.h"
  45 #include "gtknotebook.h"
  46 #include "gtkscrolledwindow.h"
  47 #include "gtkcombobox.h"
  48 #include "gtktogglebutton.h"
  49 #include "gtkradiobutton.h"
  50 #include "gtkdrawingarea.h"
  51 #include "gtkvbox.h"
  52 #include "gtktable.h"
  53 #include "gtkframe.h"
  54 #include "gtkalignment.h"
  55 #include "gtklabel.h"
  56 #include "gtkeventbox.h"
  57 #include "gtkbuildable.h"
  58 #include "gtkmessagedialog.h"
  59 #include "gtkbutton.h"
  60 #include "gtkintl.h"
  61 #include "gtkprivate.h"
  62 #include "gtktypebuiltins.h"
  63
  64 #define EXAMPLE_PAGE_AREA_SIZE 110
  65 #define RULER_DISTANCE 7.5
  66 #define RULER_RADIUS 2
  67
  68
  69 static void     gtk_print_unix_dialog_destroy      (GtkPrintUnixDialog *dialog);
  70 static void     gtk_print_unix_dialog_finalize     (GObject            *object);
  71 static void     gtk_print_unix_dialog_set_property (GObject            *object,
  72                                                     guint               prop_id,
  73                                                     const GValue       *value,
  74                                                     GParamSpec         *pspec);
  75 static void     gtk_print_unix_dialog_get_property (GObject            *object,
  76                                                     guint               prop_id,
  77                                                     GValue             *value,
  78                                                     GParamSpec         *pspec);
  79 static void     gtk_print_unix_dialog_style_updated (GtkWidget          *widget);
  80 static void     populate_dialog                    (GtkPrintUnixDialog *dialog);
  81 static void     unschedule_idle_mark_conflicts     (GtkPrintUnixDialog *dialog);
  82 static void     selected_printer_changed           (GtkTreeSelection   *selection,
  83                                                     GtkPrintUnixDialog *dialog);
  84 static void     clear_per_printer_ui               (GtkPrintUnixDialog *dialog);
  85 static void     printer_added_cb                   (GtkPrintBackend    *backend,
  86                                                     GtkPrinter         *printer,
  87                                                     GtkPrintUnixDialog *dialog);
  88 static void     printer_removed_cb                 (GtkPrintBackend    *backend,
  89                                                     GtkPrinter         *printer,
  90                                                     GtkPrintUnixDialog *dialog);
  91 static void     printer_status_cb                  (GtkPrintBackend    *backend,
  92                                                     GtkPrinter         *printer,
  93                                                     GtkPrintUnixDialog *dialog);
  94 static void     update_collate_icon                (GtkToggleButton    *toggle_button,
  95                                                     GtkPrintUnixDialog *dialog);
  96 static gboolean dialog_get_collate                 (GtkPrintUnixDialog *dialog);
  97 static gboolean dialog_get_reverse                 (GtkPrintUnixDialog *dialog);
  98 static gint     dialog_get_n_copies                (GtkPrintUnixDialog *dialog);
  99
 100 static void     set_cell_sensitivity_func          (GtkTreeViewColumn *tree_column,
 101                                                     GtkCellRenderer   *cell,
 102                                                     GtkTreeModel      *model,
 103                                                     GtkTreeIter       *iter,
 104                                                     gpointer           data);
 105 static gboolean set_active_printer                 (GtkPrintUnixDialog *dialog,
 106                                                     const gchar        *printer_name);
 107 static void redraw_page_layout_preview             (GtkPrintUnixDialog *dialog);
 108
 109 /* GtkBuildable */
 110 static void gtk_print_unix_dialog_buildable_init                    (GtkBuildableIface *iface);
 111 static GObject *gtk_print_unix_dialog_buildable_get_internal_child  (GtkBuildable *buildable,
 112                                                                      GtkBuilder   *builder,
 113                                                                      const gchar  *childname);
 114
 115 static const gchar const common_paper_sizes[][16] = {
 116   "na_letter",
 117   "na_legal",
 118   "iso_a4",
 119   "iso_a5",
 120   "roc_16k",
 121   "iso_b5",
 122   "jis_b5",
 123   "na_number-10",
 124   "iso_dl",
 125   "jpn_chou3",
 126   "na_ledger",
 127   "iso_a3",
 128 };
 129
 130 enum {
 131   PAGE_SETUP_LIST_COL_PAGE_SETUP,
 132   PAGE_SETUP_LIST_COL_IS_SEPARATOR,
 133   PAGE_SETUP_LIST_N_COLS
 134 };
 135
 136 enum {
 137   PROP_0,
 138   PROP_PAGE_SETUP,
 139   PROP_CURRENT_PAGE,
 140   PROP_PRINT_SETTINGS,
 141   PROP_SELECTED_PRINTER,
 142   PROP_MANUAL_CAPABILITIES,
 143   PROP_SUPPORT_SELECTION,
 144   PROP_HAS_SELECTION,
 145   PROP_EMBED_PAGE_SETUP
 146 };
 147
 148 enum {
 149   PRINTER_LIST_COL_ICON,
 150   PRINTER_LIST_COL_NAME,
 151   PRINTER_LIST_COL_STATE,
 152   PRINTER_LIST_COL_JOBS,
 153   PRINTER_LIST_COL_LOCATION,
 154   PRINTER_LIST_COL_PRINTER_OBJ,
 155   PRINTER_LIST_N_COLS
 156 };
 157
 158 struct GtkPrintUnixDialogPrivate
 159 {
 160   GtkWidget *notebook;
 161
 162   GtkWidget *printer_treeview;
 163
 164   GtkPrintCapabilities manual_capabilities;
 165   GtkPrintCapabilities printer_capabilities;
 166
 167   GtkTreeModel *printer_list;
 168   GtkTreeModelFilter *printer_list_filter;
 169
 170   GtkPageSetup *page_setup;
 171   gboolean page_setup_set;
 172   gboolean embed_page_setup;
 173   GtkListStore *page_setup_list;
 174   GtkListStore *custom_paper_list;
 175
 176   gboolean support_selection;
 177   gboolean has_selection;
 178
 179   GtkWidget *all_pages_radio;
 180   GtkWidget *current_page_radio;
 181   GtkWidget *selection_radio;
 182   GtkWidget *range_table;
 183   GtkWidget *page_range_radio;
 184   GtkWidget *page_range_entry;
 185
 186   GtkWidget *copies_spin;
 187   GtkWidget *collate_check;
 188   GtkWidget *reverse_check;
 189   GtkWidget *collate_image;
 190   GtkWidget *page_layout_preview;
 191   GtkWidget *scale_spin;
 192   GtkWidget *page_set_combo;
 193   GtkWidget *print_now_radio;
 194   GtkWidget *print_at_radio;
 195   GtkWidget *print_at_entry;
 196   GtkWidget *print_hold_radio;
 197   GtkWidget *preview_button;
 198   GtkWidget *paper_size_combo;
 199   GtkWidget *paper_size_combo_label;
 200   GtkWidget *orientation_combo;
 201   GtkWidget *orientation_combo_label;
 202   gboolean internal_page_setup_change;
 203   gboolean updating_print_at;
 204   GtkPrinterOptionWidget *pages_per_sheet;
 205   GtkPrinterOptionWidget *duplex;
 206   GtkPrinterOptionWidget *paper_type;
 207   GtkPrinterOptionWidget *paper_source;
 208   GtkPrinterOptionWidget *output_tray;
 209   GtkPrinterOptionWidget *job_prio;
 210   GtkPrinterOptionWidget *billing_info;
 211   GtkPrinterOptionWidget *cover_before;
 212   GtkPrinterOptionWidget *cover_after;
 213   GtkPrinterOptionWidget *number_up_layout;
 214
 215   GtkWidget *conflicts_widget;
 216
 217   GtkWidget *job_page;
 218   GtkWidget *finishing_table;
 219   GtkWidget *finishing_page;
 220   GtkWidget *image_quality_table;
 221   GtkWidget *image_quality_page;
 222   GtkWidget *color_table;
 223   GtkWidget *color_page;
 224
 225   GtkWidget *advanced_vbox;
 226   GtkWidget *advanced_page;
 227
 228   GtkWidget *extension_point;
 229
 230   /* These are set initially on selected printer (either default printer,
 231    * printer taken from set settings, or user-selected), but when any
 232    * setting is changed by the user it is cleared.
 233    */
 234   GtkPrintSettings *initial_settings;
 235
 236   GtkPrinterOption *number_up_layout_n_option;
 237   GtkPrinterOption *number_up_layout_2_option;
 238
 239   /* This is the initial printer set by set_settings. We look for it in
 240    * the added printers. We clear this whenever the user manually changes
 241    * to another printer, when the user changes a setting or when we find
 242    * this printer.
 243    */
 244   char *waiting_for_printer;
 245   gboolean internal_printer_change;
 246
 247   GList *print_backends;
 248
 249   GtkPrinter *current_printer;
 250   GtkPrinter *request_details_printer;
 251   gulong request_details_tag;
 252   GtkPrinterOptionSet *options;
 253   gulong options_changed_handler;
 254   gulong mark_conflicts_id;
 255
 256   gchar *format_for_printer;
 257
 258   gint current_page;
 259 };
 260
 261 G_DEFINE_TYPE_WITH_CODE (GtkPrintUnixDialog, gtk_print_unix_dialog, GTK_TYPE_DIALOG,
 262                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 263                                                 gtk_print_unix_dialog_buildable_init))
 264
 265 static GtkBuildableIface *parent_buildable_iface;
 266
 267 static gboolean
 268 is_default_printer (GtkPrintUnixDialog *dialog,
 269                     GtkPrinter         *printer)
 270 {
 271   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 272
 273   if (priv->format_for_printer)
 274     return strcmp (priv->format_for_printer,
 275                    gtk_printer_get_name (printer)) == 0;
 276  else
 277    return gtk_printer_is_default (printer);
 278 }
 279
 280 static void
 281 gtk_print_unix_dialog_class_init (GtkPrintUnixDialogClass *class)
 282 {
 283   GObjectClass *object_class;
 284   GtkWidgetClass *widget_class;
 285
 286   object_class = (GObjectClass *) class;
 287   widget_class = (GtkWidgetClass *) class;
 288
 289   object_class->finalize = gtk_print_unix_dialog_finalize;
 290   object_class->set_property = gtk_print_unix_dialog_set_property;
 291   object_class->get_property = gtk_print_unix_dialog_get_property;
 292
 293   widget_class->style_updated = gtk_print_unix_dialog_style_updated;
 294
 295   g_object_class_install_property (object_class,
 296                                    PROP_PAGE_SETUP,
 297                                    g_param_spec_object ("page-setup",
 298                                                         P_("Page Setup"),
 299                                                         P_("The GtkPageSetup to use"),
 300                                                         GTK_TYPE_PAGE_SETUP,
 301                                                         GTK_PARAM_READWRITE));
 302
 303   g_object_class_install_property (object_class,
 304                                    PROP_CURRENT_PAGE,
 305                                    g_param_spec_int ("current-page",
 306                                                      P_("Current Page"),
 307                                                      P_("The current page in the document"),
 308                                                      -1,
 309                                                      G_MAXINT,
 310                                                      -1,
 311                                                      GTK_PARAM_READWRITE));
 312
 313   g_object_class_install_property (object_class,
 314                                    PROP_PRINT_SETTINGS,
 315                                    g_param_spec_object ("print-settings",
 316                                                         P_("Print Settings"),
 317                                                         P_("The GtkPrintSettings used for initializing the dialog"),
 318                                                         GTK_TYPE_PRINT_SETTINGS,
 319                                                         GTK_PARAM_READWRITE));
 320
 321   g_object_class_install_property (object_class,
 322                                    PROP_SELECTED_PRINTER,
 323                                    g_param_spec_object ("selected-printer",
 324                                                         P_("Selected Printer"),
 325                                                         P_("The GtkPrinter which is selected"),
 326                                                         GTK_TYPE_PRINTER,
 327                                                         GTK_PARAM_READABLE));
 328
 329   g_object_class_install_property (object_class,
 330                                    PROP_MANUAL_CAPABILITIES,
 331                                    g_param_spec_flags ("manual-capabilities",
 332                                                        P_("Manual Capabilities"),
 333                                                        P_("Capabilities the application can handle"),
 334                                                        GTK_TYPE_PRINT_CAPABILITIES,
 335                                                        0,
 336                                                        GTK_PARAM_READWRITE));
 337
 338   g_object_class_install_property (object_class,
 339                                    PROP_SUPPORT_SELECTION,
 340                                    g_param_spec_boolean ("support-selection",
 341                                                          P_("Support Selection"),
 342                                                          P_("Whether the dialog supports selection"),
 343                                                          FALSE,
 344                                                          GTK_PARAM_READWRITE));
 345
 346   g_object_class_install_property (object_class,
 347                                    PROP_HAS_SELECTION,
 348                                    g_param_spec_boolean ("has-selection",
 349                                                          P_("Has Selection"),
 350                                                          P_("Whether the application has a selection"),
 351                                                          FALSE,
 352                                                          GTK_PARAM_READWRITE));
 353
 354    g_object_class_install_property (object_class,
 355                                    PROP_EMBED_PAGE_SETUP,
 356                                    g_param_spec_boolean ("embed-page-setup",
 357                                                          P_("Embed Page Setup"),
 358                                                          P_("TRUE if page setup combos are embedded in GtkPrintUnixDialog"),
 359                                                          FALSE,
 360                                                          GTK_PARAM_READWRITE));
 361
 362   g_type_class_add_private (class, sizeof (GtkPrintUnixDialogPrivate));
 363 }
 364
 365 /* Returns a toplevel GtkWindow, or NULL if none */
 366 static GtkWindow *
 367 get_toplevel (GtkWidget *widget)
 368 {
 369   GtkWidget *toplevel = NULL;
 370
 371   toplevel = gtk_widget_get_toplevel (widget);
 372   if (!gtk_widget_is_toplevel (toplevel))
 373     return NULL;
 374   else
 375     return GTK_WINDOW (toplevel);
 376 }
 377
 378 static void
 379 set_busy_cursor (GtkPrintUnixDialog *dialog,
 380                  gboolean            busy)
 381 {
 382   GtkWidget *widget;
 383   GtkWindow *toplevel;
 384   GdkDisplay *display;
 385   GdkCursor *cursor;
 386
 387   toplevel = get_toplevel (GTK_WIDGET (dialog));
 388   widget = GTK_WIDGET (toplevel);
 389
 390   if (!toplevel || !gtk_widget_get_realized (widget))
 391     return;
 392
 393   display = gtk_widget_get_display (widget);
 394
 395   if (busy)
 396     cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
 397   else
 398     cursor = NULL;
 399
 400   gdk_window_set_cursor (gtk_widget_get_window (widget),
 401                          cursor);
 402   gdk_display_flush (display);
 403
 404   if (cursor)
 405     g_object_unref (cursor);
 406 }
 407
 408 static void
 409 add_custom_button_to_dialog (GtkDialog   *dialog,
 410                              const gchar *mnemonic_label,
 411                              const gchar *stock_id,
 412                              gint         response_id)
 413 {
 414   GtkWidget *button = NULL;
 415
 416   button = gtk_button_new_with_mnemonic (mnemonic_label);
 417   gtk_widget_set_can_default (button, TRUE);
 418   gtk_button_set_image (GTK_BUTTON (button),
 419                         gtk_image_new_from_stock (stock_id,
 420                                                   GTK_ICON_SIZE_BUTTON));
 421   gtk_widget_show (button);
 422
 423   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, response_id);
 424 }
 425
 426 /* This function handles error messages before printing.
 427  */
 428 static gboolean
 429 error_dialogs (GtkPrintUnixDialog *print_dialog,
 430                gint                print_dialog_response_id,
 431                gpointer            data)
 432 {
 433   GtkPrintUnixDialogPrivate *priv = print_dialog->priv;
 434   GtkPrinterOption          *option = NULL;
 435   GtkPrinter                *printer = NULL;
 436   GtkWindow                 *toplevel = NULL;
 437   GtkWidget                 *dialog = NULL;
 438   GFile                     *file = NULL;
 439   gchar                     *basename = NULL;
 440   gchar                     *dirname = NULL;
 441   int                        response;
 442
 443   if (print_dialog != NULL && print_dialog_response_id == GTK_RESPONSE_OK)
 444     {
 445       printer = gtk_print_unix_dialog_get_selected_printer (print_dialog);
 446
 447       if (printer != NULL)
 448         {
 449           if (priv->request_details_tag || !gtk_printer_is_accepting_jobs (printer))
 450             {
 451               g_signal_stop_emission_by_name (print_dialog, "response");
 452               return TRUE;
 453             }
 454
 455           /* Shows overwrite confirmation dialog in the case of printing to file which
 456            * already exists. */
 457           if (gtk_printer_is_virtual (printer))
 458             {
 459               option = gtk_printer_option_set_lookup (priv->options,
 460                                                       "gtk-main-page-custom-input");
 461
 462               if (option != NULL &&
 463                   option->type == GTK_PRINTER_OPTION_TYPE_FILESAVE)
 464                 {
 465                   file = g_file_new_for_uri (option->value);
 466
 467                   if (file != NULL &&
 468                       g_file_query_exists (file, NULL))
 469                     {
 470                       toplevel = get_toplevel (GTK_WIDGET (print_dialog));
 471
 472                       basename = g_file_get_basename (file);
 473                       dirname = g_file_get_parse_name (g_file_get_parent (file));
 474
 475                       dialog = gtk_message_dialog_new (toplevel,
 476                                                        GTK_DIALOG_MODAL |
 477                                                        GTK_DIALOG_DESTROY_WITH_PARENT,
 478                                                        GTK_MESSAGE_QUESTION,
 479                                                        GTK_BUTTONS_NONE,
 480                                                        _("A file named \"%s\" already exists.  Do you want to replace it?"),
 481                                                        basename);
 482
 483                       gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
 484                                                                 _("The file already exists in \"%s\".  Replacing it will "
 485                                                                 "overwrite its contents."),
 486                                                                 dirname);
 487
 488                       gtk_dialog_add_button (GTK_DIALOG (dialog),
 489                                              GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
 490                       add_custom_button_to_dialog (GTK_DIALOG (dialog),
 491                                                    _("_Replace"),
 492                                                    GTK_STOCK_PRINT,
 493                                                    GTK_RESPONSE_ACCEPT);
 494                       gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 495                                                                GTK_RESPONSE_ACCEPT,
 496                                                                GTK_RESPONSE_CANCEL,
 497                                                                -1);
 498                       gtk_dialog_set_default_response (GTK_DIALOG (dialog),
 499                                                        GTK_RESPONSE_ACCEPT);
 500
 501                       if (gtk_window_has_group (toplevel))
 502                         gtk_window_group_add_window (gtk_window_get_group (toplevel),
 503                                                      GTK_WINDOW (dialog));
 504
 505                       response = gtk_dialog_run (GTK_DIALOG (dialog));
 506
 507                       gtk_widget_destroy (dialog);
 508
 509                       g_free (dirname);
 510                       g_free (basename);
 511
 512                       if (response != GTK_RESPONSE_ACCEPT)
 513                         {
 514                           g_signal_stop_emission_by_name (print_dialog, "response");
 515                           g_object_unref (file);
 516                           return TRUE;
 517                         }
 518                     }
 519
 520                   g_object_unref (file);
 521                 }
 522             }
 523         }
 524     }
 525   return FALSE;
 526 }
 527
 528 static void
 529 gtk_print_unix_dialog_init (GtkPrintUnixDialog *dialog)
 530 {
 531   GtkPrintUnixDialogPrivate *priv;
 532
 533   dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
 534                                               GTK_TYPE_PRINT_UNIX_DIALOG,
 535                                               GtkPrintUnixDialogPrivate);
 536   priv = dialog->priv;
 537
 538   priv->print_backends = NULL;
 539   priv->current_page = -1;
 540   priv->number_up_layout_n_option = NULL;
 541   priv->number_up_layout_2_option = NULL;
 542
 543   priv->page_setup = gtk_page_setup_new ();
 544   priv->page_setup_set = FALSE;
 545   priv->embed_page_setup = FALSE;
 546   priv->internal_page_setup_change = FALSE;
 547
 548   priv->support_selection = FALSE;
 549   priv->has_selection = FALSE;
 550
 551   g_signal_connect (dialog,
 552                     "destroy",
 553                     (GCallback) gtk_print_unix_dialog_destroy,
 554                     NULL);
 555
 556   g_signal_connect (dialog,
 557                     "response",
 558                     (GCallback) error_dialogs,
 559                     NULL);
 560
 561   g_signal_connect (dialog,
 562                     "notify::page-setup",
 563                     (GCallback) redraw_page_layout_preview,
 564                     NULL);
 565
 566   priv->preview_button = gtk_button_new_from_stock (GTK_STOCK_PRINT_PREVIEW);
 567   gtk_widget_show (priv->preview_button);
 568
 569   gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
 570                                 priv->preview_button,
 571                                 GTK_RESPONSE_APPLY);
 572   gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 573                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 574                           GTK_STOCK_PRINT, GTK_RESPONSE_OK,
 575                           NULL);
 576   gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 577                                            GTK_RESPONSE_APPLY,
 578                                            GTK_RESPONSE_OK,
 579                                            GTK_RESPONSE_CANCEL,
 580                                            -1);
 581
 582   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 583   gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
 584
 585   priv->page_setup_list = gtk_list_store_new (PAGE_SETUP_LIST_N_COLS,
 586                                               G_TYPE_OBJECT,
 587                                               G_TYPE_BOOLEAN);
 588
 589   priv->custom_paper_list = gtk_list_store_new (1, G_TYPE_OBJECT);
 590   _gtk_print_load_custom_papers (priv->custom_paper_list);
 591
 592   populate_dialog (dialog);
 593 }
 594
 595 static void
 596 gtk_print_unix_dialog_destroy (GtkPrintUnixDialog *dialog)
 597 {
 598   /* Make sure we don't destroy custom widgets owned by the backends */
 599   clear_per_printer_ui (dialog);
 600 }
 601
 602 static void
 603 disconnect_printer_details_request (GtkPrintUnixDialog *dialog, gboolean details_failed)
 604 {
 605   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 606
 607   if (priv->request_details_tag)
 608     {
 609       g_signal_handler_disconnect (priv->request_details_printer,
 610                                    priv->request_details_tag);
 611       priv->request_details_tag = 0;
 612       set_busy_cursor (dialog, FALSE);
 613       if (details_failed)
 614         gtk_list_store_set (GTK_LIST_STORE (priv->printer_list),
 615                             g_object_get_data (G_OBJECT (priv->request_details_printer),
 616                                                "gtk-print-tree-iter"),
 617                             PRINTER_LIST_COL_STATE,
 618                              _("Getting printer information failed"),
 619                             -1);
 620       else
 621         gtk_list_store_set (GTK_LIST_STORE (priv->printer_list),
 622                             g_object_get_data (G_OBJECT (priv->request_details_printer),
 623                                                "gtk-print-tree-iter"),
 624                             PRINTER_LIST_COL_STATE,
 625                             gtk_printer_get_state_message (priv->request_details_printer),
 626                             -1);
 627       g_object_unref (priv->request_details_printer);
 628       priv->request_details_printer = NULL;
 629     }
 630 }
 631
 632 static void
 633 gtk_print_unix_dialog_finalize (GObject *object)
 634 {
 635   GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
 636   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 637   GtkPrintBackend *backend;
 638   GList *node;
 639
 640   unschedule_idle_mark_conflicts (dialog);
 641   disconnect_printer_details_request (dialog, FALSE);
 642
 643   if (priv->current_printer)
 644     {
 645       g_object_unref (priv->current_printer);
 646       priv->current_printer = NULL;
 647     }
 648
 649   if (priv->printer_list)
 650     {
 651       g_object_unref (priv->printer_list);
 652       priv->printer_list = NULL;
 653     }
 654
 655   if (priv->custom_paper_list)
 656     {
 657       g_object_unref (priv->custom_paper_list);
 658       priv->custom_paper_list = NULL;
 659     }
 660
 661   if (priv->printer_list_filter)
 662     {
 663       g_object_unref (priv->printer_list_filter);
 664       priv->printer_list_filter = NULL;
 665     }
 666
 667   if (priv->options)
 668     {
 669       g_object_unref (priv->options);
 670       priv->options = NULL;
 671     }
 672
 673   if (priv->number_up_layout_2_option)
 674     {
 675       priv->number_up_layout_2_option->choices[0] = NULL;
 676       priv->number_up_layout_2_option->choices[1] = NULL;
 677       g_free (priv->number_up_layout_2_option->choices_display[0]);
 678       g_free (priv->number_up_layout_2_option->choices_display[1]);
 679       priv->number_up_layout_2_option->choices_display[0] = NULL;
 680       priv->number_up_layout_2_option->choices_display[1] = NULL;
 681       g_object_unref (priv->number_up_layout_2_option);
 682       priv->number_up_layout_2_option = NULL;
 683     }
 684
 685   if (priv->number_up_layout_n_option)
 686     {
 687       g_object_unref (priv->number_up_layout_n_option);
 688       priv->number_up_layout_n_option = NULL;
 689     }
 690
 691  if (priv->page_setup)
 692     {
 693       g_object_unref (priv->page_setup);
 694       priv->page_setup = NULL;
 695     }
 696
 697   if (priv->initial_settings)
 698     {
 699       g_object_unref (priv->initial_settings);
 700       priv->initial_settings = NULL;
 701     }
 702
 703   g_free (priv->waiting_for_printer);
 704   priv->waiting_for_printer = NULL;
 705
 706   g_free (priv->format_for_printer);
 707   priv->format_for_printer = NULL;
 708
 709   for (node = priv->print_backends; node != NULL; node = node->next)
 710     {
 711       backend = GTK_PRINT_BACKEND (node->data);
 712
 713       g_signal_handlers_disconnect_by_func (backend, printer_added_cb, dialog);
 714       g_signal_handlers_disconnect_by_func (backend, printer_removed_cb, dialog);
 715       g_signal_handlers_disconnect_by_func (backend, printer_status_cb, dialog);
 716
 717       gtk_print_backend_destroy (backend);
 718       g_object_unref (backend);
 719     }
 720
 721   g_list_free (priv->print_backends);
 722   priv->print_backends = NULL;
 723
 724   if (priv->page_setup_list)
 725     {
 726       g_object_unref (priv->page_setup_list);
 727       priv->page_setup_list = NULL;
 728     }
 729
 730   G_OBJECT_CLASS (gtk_print_unix_dialog_parent_class)->finalize (object);
 731 }
 732
 733 static void
 734 printer_removed_cb (GtkPrintBackend    *backend,
 735                     GtkPrinter         *printer,
 736                     GtkPrintUnixDialog *dialog)
 737 {
 738   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 739   GtkTreeIter *iter;
 740
 741   iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");
 742   gtk_list_store_remove (GTK_LIST_STORE (priv->printer_list), iter);
 743 }
 744
 745 static void
 746 gtk_print_unix_dialog_buildable_init (GtkBuildableIface *iface)
 747 {
 748   parent_buildable_iface = g_type_interface_peek_parent (iface);
 749
 750   iface->get_internal_child = gtk_print_unix_dialog_buildable_get_internal_child;
 751 }
 752
 753 static GObject *
 754 gtk_print_unix_dialog_buildable_get_internal_child (GtkBuildable *buildable,
 755                                                     GtkBuilder   *builder,
 756                                                     const gchar  *childname)
 757 {
 758   if (strcmp (childname, "notebook") == 0)
 759     return G_OBJECT (GTK_PRINT_UNIX_DIALOG (buildable)->priv->notebook);
 760
 761   return parent_buildable_iface->get_internal_child (buildable, builder, childname);
 762 }
 763
 764 /* This function controls "sensitive" property of GtkCellRenderer based on pause
 765  * state of printers. */
 766 void set_cell_sensitivity_func (GtkTreeViewColumn *tree_column,
 767                                 GtkCellRenderer   *cell,
 768                                 GtkTreeModel      *tree_model,
 769                                 GtkTreeIter       *iter,
 770                                 gpointer           data)
 771 {
 772   GtkPrinter *printer;
 773
 774   gtk_tree_model_get (tree_model, iter, PRINTER_LIST_COL_PRINTER_OBJ, &printer, -1);
 775
 776   if (printer != NULL && !gtk_printer_is_accepting_jobs (printer))
 777     g_object_set (cell, "sensitive", FALSE, NULL);
 778   else
 779     g_object_set (cell, "sensitive", TRUE, NULL);
 780
 781   g_object_unref (printer);
 782 }
 783
 784 static void
 785 printer_status_cb (GtkPrintBackend    *backend,
 786                    GtkPrinter         *printer,
 787                    GtkPrintUnixDialog *dialog)
 788 {
 789   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 790   GtkTreeIter *iter;
 791   GtkTreeSelection *selection;
 792
 793   iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");
 794
 795   gtk_list_store_set (GTK_LIST_STORE (priv->printer_list), iter,
 796                       PRINTER_LIST_COL_ICON, gtk_printer_get_icon_name (printer),
 797                       PRINTER_LIST_COL_STATE, gtk_printer_get_state_message (printer),
 798                       PRINTER_LIST_COL_JOBS, gtk_printer_get_job_count (printer),
 799                       PRINTER_LIST_COL_LOCATION, gtk_printer_get_location (printer),
 800                       -1);
 801
 802   /* When the pause state change then we need to update sensitive property
 803    * of GTK_RESPONSE_OK button inside of selected_printer_changed function. */
 804   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
 805   selected_printer_changed (selection, dialog);
 806
 807   if (gtk_print_backend_printer_list_is_done (backend) &&
 808       gtk_printer_is_default (printer) &&
 809       (gtk_tree_selection_count_selected_rows (selection) == 0))
 810     set_active_printer (dialog, gtk_printer_get_name (printer));
 811 }
 812
 813 static void
 814 printer_added_cb (GtkPrintBackend    *backend,
 815                   GtkPrinter         *printer,
 816                   GtkPrintUnixDialog *dialog)
 817 {
 818   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 819   GtkTreeIter iter, filter_iter;
 820   GtkTreeSelection *selection;
 821   GtkTreePath *path;
 822
 823   gtk_list_store_append (GTK_LIST_STORE (priv->printer_list), &iter);
 824
 825   g_object_set_data_full (G_OBJECT (printer),
 826                          "gtk-print-tree-iter",
 827                           gtk_tree_iter_copy (&iter),
 828                           (GDestroyNotify) gtk_tree_iter_free);
 829
 830   gtk_list_store_set (GTK_LIST_STORE (priv->printer_list), &iter,
 831                       PRINTER_LIST_COL_ICON, gtk_printer_get_icon_name (printer),
 832                       PRINTER_LIST_COL_NAME, gtk_printer_get_name (printer),
 833                       PRINTER_LIST_COL_STATE, gtk_printer_get_state_message (printer),
 834                       PRINTER_LIST_COL_JOBS, gtk_printer_get_job_count (printer),
 835                       PRINTER_LIST_COL_LOCATION, gtk_printer_get_location (printer),
 836                       PRINTER_LIST_COL_PRINTER_OBJ, printer,
 837                       -1);
 838
 839   gtk_tree_model_filter_convert_child_iter_to_iter (priv->printer_list_filter,
 840                                                     &filter_iter, &iter);
 841   path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->printer_list_filter), &filter_iter);
 842
 843   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
 844
 845   if (priv->waiting_for_printer != NULL &&
 846       strcmp (gtk_printer_get_name (printer),
 847               priv->waiting_for_printer) == 0)
 848     {
 849       priv->internal_printer_change = TRUE;
 850       gtk_tree_selection_select_iter (selection, &filter_iter);
 851       gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->printer_treeview),
 852                                     path, NULL, TRUE, 0.5, 0.0);
 853       priv->internal_printer_change = FALSE;
 854       g_free (priv->waiting_for_printer);
 855       priv->waiting_for_printer = NULL;
 856     }
 857   else if (is_default_printer (dialog, printer) &&
 858            gtk_tree_selection_count_selected_rows (selection) == 0)
 859     {
 860       priv->internal_printer_change = TRUE;
 861       gtk_tree_selection_select_iter (selection, &filter_iter);
 862       gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->printer_treeview),
 863                                     path, NULL, TRUE, 0.5, 0.0);
 864       priv->internal_printer_change = FALSE;
 865     }
 866
 867   gtk_tree_path_free (path);
 868 }
 869
 870 static void
 871 printer_list_initialize (GtkPrintUnixDialog *dialog,
 872                          GtkPrintBackend    *print_backend)
 873 {
 874   GList *list;
 875   GList *node;
 876
 877   g_return_if_fail (print_backend != NULL);
 878
 879   g_signal_connect_object (print_backend,
 880                            "printer-added",
 881                            (GCallback) printer_added_cb,
 882                            G_OBJECT (dialog), 0);
 883
 884   g_signal_connect_object (print_backend,
 885                            "printer-removed",
 886                            (GCallback) printer_removed_cb,
 887                            G_OBJECT (dialog), 0);
 888
 889   g_signal_connect_object (print_backend,
 890                            "printer-status-changed",
 891                            (GCallback) printer_status_cb,
 892                            G_OBJECT (dialog), 0);
 893
 894   list = gtk_print_backend_get_printer_list (print_backend);
 895
 896   node = list;
 897   while (node != NULL)
 898     {
 899       printer_added_cb (print_backend, node->data, dialog);
 900       node = node->next;
 901     }
 902
 903   g_list_free (list);
 904 }
 905
 906 static void
 907 load_print_backends (GtkPrintUnixDialog *dialog)
 908 {
 909   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 910   GList *node;
 911
 912   if (g_module_supported ())
 913     priv->print_backends = gtk_print_backend_load_modules ();
 914
 915   for (node = priv->print_backends; node != NULL; node = node->next)
 916     {
 917       GtkPrintBackend *backend = node->data;
 918       printer_list_initialize (dialog, backend);
 919     }
 920 }
 921
 922 static void
 923 gtk_print_unix_dialog_set_property (GObject      *object,
 924                                     guint         prop_id,
 925                                     const GValue *value,
 926                                     GParamSpec   *pspec)
 927
 928 {
 929   GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
 930
 931   switch (prop_id)
 932     {
 933     case PROP_PAGE_SETUP:
 934       gtk_print_unix_dialog_set_page_setup (dialog, g_value_get_object (value));
 935       break;
 936     case PROP_CURRENT_PAGE:
 937       gtk_print_unix_dialog_set_current_page (dialog, g_value_get_int (value));
 938       break;
 939     case PROP_PRINT_SETTINGS:
 940       gtk_print_unix_dialog_set_settings (dialog, g_value_get_object (value));
 941       break;
 942     case PROP_MANUAL_CAPABILITIES:
 943       gtk_print_unix_dialog_set_manual_capabilities (dialog, g_value_get_flags (value));
 944       break;
 945     case PROP_SUPPORT_SELECTION:
 946       gtk_print_unix_dialog_set_support_selection (dialog, g_value_get_boolean (value));
 947       break;
 948     case PROP_HAS_SELECTION:
 949       gtk_print_unix_dialog_set_has_selection (dialog, g_value_get_boolean (value));
 950       break;
 951     case PROP_EMBED_PAGE_SETUP:
 952       gtk_print_unix_dialog_set_embed_page_setup (dialog, g_value_get_boolean (value));
 953       break;
 954     default:
 955       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 956       break;
 957     }
 958 }
 959
 960 static void
 961 gtk_print_unix_dialog_get_property (GObject    *object,
 962                                     guint       prop_id,
 963                                     GValue     *value,
 964                                     GParamSpec *pspec)
 965 {
 966   GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
 967   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 968
 969   switch (prop_id)
 970     {
 971     case PROP_PAGE_SETUP:
 972       g_value_set_object (value, priv->page_setup);
 973       break;
 974     case PROP_CURRENT_PAGE:
 975       g_value_set_int (value, priv->current_page);
 976       break;
 977     case PROP_PRINT_SETTINGS:
 978       g_value_take_object (value, gtk_print_unix_dialog_get_settings (dialog));
 979       break;
 980     case PROP_SELECTED_PRINTER:
 981       g_value_set_object (value, priv->current_printer);
 982       break;
 983     case PROP_MANUAL_CAPABILITIES:
 984       g_value_set_flags (value, priv->manual_capabilities);
 985       break;
 986     case PROP_SUPPORT_SELECTION:
 987       g_value_set_boolean (value, priv->support_selection);
 988       break;
 989     case PROP_HAS_SELECTION:
 990       g_value_set_boolean (value, priv->has_selection);
 991       break;
 992     case PROP_EMBED_PAGE_SETUP:
 993       g_value_set_boolean (value, priv->embed_page_setup);
 994       break;
 995     default:
 996       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 997       break;
 998     }
 999 }
1000
1001 static gboolean
1002 is_printer_active (GtkTreeModel       *model,
1003                    GtkTreeIter        *iter,
1004                    GtkPrintUnixDialog *dialog)
1005 {
1006   gboolean result;
1007   GtkPrinter *printer;
1008   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1009
1010   gtk_tree_model_get (model, iter,
1011                       PRINTER_LIST_COL_PRINTER_OBJ, &printer,
1012                       -1);
1013
1014   if (printer == NULL)
1015     return FALSE;
1016
1017   result = gtk_printer_is_active (printer);
1018
1019   if (result &&
1020       priv->manual_capabilities & (GTK_PRINT_CAPABILITY_GENERATE_PDF |
1021                                    GTK_PRINT_CAPABILITY_GENERATE_PS))
1022     {
1023        /* Check that the printer can handle at least one of the data
1024         * formats that the application supports.
1025         */
1026        result = ((priv->manual_capabilities & GTK_PRINT_CAPABILITY_GENERATE_PDF) &&
1027                  gtk_printer_accepts_pdf (printer)) ||
1028                 ((priv->manual_capabilities & GTK_PRINT_CAPABILITY_GENERATE_PS) &&
1029                  gtk_printer_accepts_ps (printer));
1030     }
1031
1032   g_object_unref (printer);
1033
1034   return result;
1035 }
1036
1037 static gint
1038 default_printer_list_sort_func (GtkTreeModel *model,
1039                                 GtkTreeIter  *a,
1040                                 GtkTreeIter  *b,
1041                                 gpointer      user_data)
1042 {
1043   gchar *a_name;
1044   gchar *b_name;
1045   GtkPrinter *a_printer;
1046   GtkPrinter *b_printer;
1047   gint result;
1048
1049   gtk_tree_model_get (model, a,
1050                       PRINTER_LIST_COL_NAME, &a_name,
1051                       PRINTER_LIST_COL_PRINTER_OBJ, &a_printer,
1052                       -1);
1053   gtk_tree_model_get (model, b,
1054                       PRINTER_LIST_COL_NAME, &b_name,
1055                       PRINTER_LIST_COL_PRINTER_OBJ, &b_printer,
1056                       -1);
1057
1058   if (a_printer == NULL && b_printer == NULL)
1059     result = 0;
1060   else if (a_printer == NULL)
1061    result = G_MAXINT;
1062   else if (b_printer == NULL)
1063    result = G_MININT;
1064   else if (gtk_printer_is_virtual (a_printer) && gtk_printer_is_virtual (b_printer))
1065     result = 0;
1066   else if (gtk_printer_is_virtual (a_printer) && !gtk_printer_is_virtual (b_printer))
1067     result = G_MININT;
1068   else if (!gtk_printer_is_virtual (a_printer) && gtk_printer_is_virtual (b_printer))
1069     result = G_MAXINT;
1070   else if (a_name == NULL && b_name == NULL)
1071     result = 0;
1072   else if (a_name == NULL && b_name != NULL)
1073     result = 1;
1074   else if (a_name != NULL && b_name == NULL)
1075     result = -1;
1076   else
1077     result = g_ascii_strcasecmp (a_name, b_name);
1078
1079   g_free (a_name);
1080   g_free (b_name);
1081   if (a_printer)
1082     g_object_unref (a_printer);
1083   if (b_printer)
1084     g_object_unref (b_printer);
1085
1086   return result;
1087 }
1088
1089 static void
1090 create_printer_list_model (GtkPrintUnixDialog *dialog)
1091 {
1092   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1093   GtkListStore *model;
1094   GtkTreeSortable *sort;
1095
1096   model = gtk_list_store_new (PRINTER_LIST_N_COLS,
1097                               G_TYPE_STRING,
1098                               G_TYPE_STRING,
1099                               G_TYPE_STRING,
1100                               G_TYPE_INT,
1101                               G_TYPE_STRING,
1102                               G_TYPE_OBJECT);
1103
1104   priv->printer_list = (GtkTreeModel *)model;
1105   priv->printer_list_filter = (GtkTreeModelFilter *) gtk_tree_model_filter_new ((GtkTreeModel *)model,
1106                                                                                         NULL);
1107
1108   gtk_tree_model_filter_set_visible_func (priv->printer_list_filter,
1109                                           (GtkTreeModelFilterVisibleFunc) is_printer_active,
1110                                           dialog,
1111                                           NULL);
1112
1113   sort = GTK_TREE_SORTABLE (model);
1114   gtk_tree_sortable_set_default_sort_func (sort,
1115                                            default_printer_list_sort_func,
1116                                            NULL,
1117                                            NULL);
1118
1119   gtk_tree_sortable_set_sort_column_id (sort,
1120                                         GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
1121                                         GTK_SORT_ASCENDING);
1122
1123 }
1124
1125
1126 static GtkWidget *
1127 wrap_in_frame (const gchar *label,
1128                GtkWidget   *child)
1129 {
1130   GtkWidget *frame, *alignment, *label_widget;
1131   gchar *bold_text;
1132
1133   label_widget = gtk_label_new (NULL);
1134   gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
1135   gtk_widget_show (label_widget);
1136
1137   bold_text = g_markup_printf_escaped ("<b>%s</b>", label);
1138   gtk_label_set_markup (GTK_LABEL (label_widget), bold_text);
1139   g_free (bold_text);
1140
1141   frame = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
1142   gtk_box_pack_start (GTK_BOX (frame), label_widget, FALSE, FALSE, 0);
1143
1144   alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
1145   gtk_alignment_set_padding (GTK_ALIGNMENT (alignment),
1146                              0, 0, 12, 0);
1147   gtk_box_pack_start (GTK_BOX (frame), alignment, FALSE, FALSE, 0);
1148
1149   gtk_container_add (GTK_CONTAINER (alignment), child);
1150
1151   gtk_widget_show (frame);
1152   gtk_widget_show (alignment);
1153
1154   return frame;
1155 }
1156
1157 static gboolean
1158 setup_option (GtkPrintUnixDialog     *dialog,
1159               const gchar            *option_name,
1160               GtkPrinterOptionWidget *widget)
1161 {
1162   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1163   GtkPrinterOption *option;
1164
1165   option = gtk_printer_option_set_lookup (priv->options, option_name);
1166   gtk_printer_option_widget_set_source (widget, option);
1167
1168   return option != NULL;
1169 }
1170
1171 static void
1172 add_option_to_extension_point (GtkPrinterOption *option,
1173                                gpointer          data)
1174 {
1175   GtkWidget *extension_point = data;
1176   GtkWidget *widget;
1177
1178   widget = gtk_printer_option_widget_new (option);
1179   gtk_widget_show (widget);
1180
1181   if (gtk_printer_option_widget_has_external_label (GTK_PRINTER_OPTION_WIDGET (widget)))
1182     {
1183       GtkWidget *label, *hbox;
1184
1185       label = gtk_printer_option_widget_get_external_label (GTK_PRINTER_OPTION_WIDGET (widget));
1186       gtk_widget_show (label);
1187       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1188       gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
1189
1190       hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
1191       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1192       gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1193       gtk_widget_show (hbox);
1194
1195       gtk_box_pack_start (GTK_BOX (extension_point), hbox, FALSE, FALSE, 0);
1196     }
1197   else
1198     gtk_box_pack_start (GTK_BOX (extension_point), widget, FALSE, FALSE, 0);
1199 }
1200
1201 static void
1202 add_option_to_table (GtkPrinterOption *option,
1203                      gpointer          user_data)
1204 {
1205   GtkTable *table;
1206   GtkWidget *label, *widget;
1207   guint row;
1208
1209   table = GTK_TABLE (user_data);
1210
1211   if (g_str_has_prefix (option->name, "gtk-"))
1212     return;
1213
1214   widget = gtk_printer_option_widget_new (option);
1215   gtk_widget_show (widget);
1216
1217   gtk_table_get_size (table, &row, NULL);
1218   gtk_table_resize (table, row + 1, 2);
1219
1220   if (gtk_printer_option_widget_has_external_label (GTK_PRINTER_OPTION_WIDGET (widget)))
1221     {
1222       label = gtk_printer_option_widget_get_external_label (GTK_PRINTER_OPTION_WIDGET (widget));
1223       gtk_widget_show (label);
1224
1225       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1226       gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
1227
1228       gtk_table_attach (table, label,
1229                         0, 1, row - 1 , row,  GTK_FILL, 0, 0, 0);
1230
1231       gtk_table_attach (table, widget,
1232                         1, 2, row - 1, row,  GTK_FILL, 0, 0, 0);
1233     }
1234   else
1235     gtk_table_attach (table, widget,
1236                       0, 2, row - 1, row,  GTK_FILL, 0, 0, 0);
1237 }
1238
1239 static void
1240 setup_page_table (GtkPrinterOptionSet *options,
1241                   const gchar         *group,
1242                   GtkWidget           *table,
1243                   GtkWidget           *page)
1244 {
1245   guint nrows;
1246
1247   gtk_printer_option_set_foreach_in_group (options, group,
1248                                            add_option_to_table,
1249                                            table);
1250
1251   gtk_table_get_size (GTK_TABLE (table), &nrows, NULL);
1252   if (nrows == 1)
1253     gtk_widget_hide (page);
1254   else
1255     gtk_widget_show (page);
1256 }
1257
1258 static void
1259 update_print_at_option (GtkPrintUnixDialog *dialog)
1260 {
1261   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1262   GtkPrinterOption *option;
1263
1264   option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time");
1265
1266   if (option == NULL)
1267     return;
1268
1269   if (priv->updating_print_at)
1270     return;
1271
1272   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->print_at_radio)))
1273     gtk_printer_option_set (option, "at");
1274   else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->print_hold_radio)))
1275     gtk_printer_option_set (option, "on-hold");
1276   else
1277     gtk_printer_option_set (option, "now");
1278
1279   option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time-text");
1280   if (option != NULL)
1281     {
1282       const char *text = gtk_entry_get_text (GTK_ENTRY (priv->print_at_entry));
1283       gtk_printer_option_set (option, text);
1284     }
1285 }
1286
1287
1288 static gboolean
1289 setup_print_at (GtkPrintUnixDialog *dialog)
1290 {
1291   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1292   GtkPrinterOption *option;
1293
1294   option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time");
1295
1296   if (option == NULL)
1297     {
1298       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_now_radio),
1299                                     TRUE);
1300       gtk_widget_set_sensitive (priv->print_at_radio, FALSE);
1301       gtk_widget_set_sensitive (priv->print_at_entry, FALSE);
1302       gtk_widget_set_sensitive (priv->print_hold_radio, FALSE);
1303       gtk_entry_set_text (GTK_ENTRY (priv->print_at_entry), "");
1304       return FALSE;
1305     }
1306
1307   priv->updating_print_at = TRUE;
1308
1309   gtk_widget_set_sensitive (priv->print_at_entry, FALSE);
1310   gtk_widget_set_sensitive (priv->print_at_radio,
1311                             gtk_printer_option_has_choice (option, "at"));
1312
1313   gtk_widget_set_sensitive (priv->print_hold_radio,
1314                             gtk_printer_option_has_choice (option, "on-hold"));
1315
1316   update_print_at_option (dialog);
1317
1318   if (strcmp (option->value, "at") == 0)
1319     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_at_radio),
1320                                   TRUE);
1321   else if (strcmp (option->value, "on-hold") == 0)
1322     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_hold_radio),
1323                                   TRUE);
1324   else
1325     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_now_radio),
1326                                   TRUE);
1327
1328   option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time-text");
1329   if (option != NULL)
1330     gtk_entry_set_text (GTK_ENTRY (priv->print_at_entry), option->value);
1331
1332   priv->updating_print_at = FALSE;
1333
1334   return TRUE;
1335 }
1336
1337 static void
1338 update_dialog_from_settings (GtkPrintUnixDialog *dialog)
1339 {
1340   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1341   GList *groups, *l;
1342   gchar *group;
1343   GtkWidget *table, *frame;
1344   gboolean has_advanced, has_job;
1345   guint nrows;
1346
1347   if (priv->current_printer == NULL)
1348     {
1349        clear_per_printer_ui (dialog);
1350        gtk_widget_hide (priv->job_page);
1351        gtk_widget_hide (priv->advanced_page);
1352        gtk_widget_hide (priv->image_quality_page);
1353        gtk_widget_hide (priv->finishing_page);
1354        gtk_widget_hide (priv->color_page);
1355        gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
1356
1357        return;
1358     }
1359
1360   setup_option (dialog, "gtk-n-up", priv->pages_per_sheet);
1361   setup_option (dialog, "gtk-n-up-layout", priv->number_up_layout);
1362   setup_option (dialog, "gtk-duplex", priv->duplex);
1363   setup_option (dialog, "gtk-paper-type", priv->paper_type);
1364   setup_option (dialog, "gtk-paper-source", priv->paper_source);
1365   setup_option (dialog, "gtk-output-tray", priv->output_tray);
1366
1367   has_job = FALSE;
1368   has_job |= setup_option (dialog, "gtk-job-prio", priv->job_prio);
1369   has_job |= setup_option (dialog, "gtk-billing-info", priv->billing_info);
1370   has_job |= setup_option (dialog, "gtk-cover-before", priv->cover_before);
1371   has_job |= setup_option (dialog, "gtk-cover-after", priv->cover_after);
1372   has_job |= setup_print_at (dialog);
1373
1374   if (has_job)
1375     gtk_widget_show (priv->job_page);
1376   else
1377     gtk_widget_hide (priv->job_page);
1378
1379   setup_page_table (priv->options,
1380                     "ImageQualityPage",
1381                     priv->image_quality_table,
1382                     priv->image_quality_page);
1383
1384   setup_page_table (priv->options,
1385                     "FinishingPage",
1386                     priv->finishing_table,
1387                     priv->finishing_page);
1388
1389   setup_page_table (priv->options,
1390                     "ColorPage",
1391                     priv->color_table,
1392                     priv->color_page);
1393
1394   gtk_printer_option_set_foreach_in_group (priv->options,
1395                                            "GtkPrintDialogExtension",
1396                                            add_option_to_extension_point,
1397                                            priv->extension_point);
1398
1399   /* Put the rest of the groups in the advanced page */
1400   groups = gtk_printer_option_set_get_groups (priv->options);
1401
1402   has_advanced = FALSE;
1403   for (l = groups; l != NULL; l = l->next)
1404     {
1405       group = l->data;
1406
1407       if (group == NULL)
1408         continue;
1409
1410       if (strcmp (group, "ImageQualityPage") == 0 ||
1411           strcmp (group, "ColorPage") == 0 ||
1412           strcmp (group, "FinishingPage") == 0 ||
1413           strcmp (group, "GtkPrintDialogExtension") == 0)
1414         continue;
1415
1416       table = gtk_table_new (1, 2, FALSE);
1417       gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1418       gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1419
1420       gtk_printer_option_set_foreach_in_group (priv->options,
1421                                                group,
1422                                                add_option_to_table,
1423                                                table);
1424
1425       gtk_table_get_size (GTK_TABLE (table), &nrows, NULL);
1426       if (nrows == 1)
1427         gtk_widget_destroy (table);
1428       else
1429         {
1430           has_advanced = TRUE;
1431           frame = wrap_in_frame (group, table);
1432           gtk_widget_show (table);
1433           gtk_widget_show (frame);
1434
1435           gtk_box_pack_start (GTK_BOX (priv->advanced_vbox),
1436                               frame, FALSE, FALSE, 0);
1437         }
1438     }
1439
1440   if (has_advanced)
1441     gtk_widget_show (priv->advanced_page);
1442   else
1443     gtk_widget_hide (priv->advanced_page);
1444
1445   g_list_foreach (groups, (GFunc) g_free, NULL);
1446   g_list_free (groups);
1447 }
1448
1449 static void
1450 update_dialog_from_capabilities (GtkPrintUnixDialog *dialog)
1451 {
1452   GtkPrintCapabilities caps;
1453   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1454   gboolean can_collate;
1455   const gchar *copies;
1456
1457   copies = gtk_entry_get_text (GTK_ENTRY (priv->copies_spin));
1458   can_collate = (*copies != '\0' && atoi (copies) > 1);
1459
1460   caps = priv->manual_capabilities | priv->printer_capabilities;
1461
1462   gtk_widget_set_sensitive (priv->page_set_combo,
1463                             caps & GTK_PRINT_CAPABILITY_PAGE_SET);
1464   gtk_widget_set_sensitive (priv->copies_spin,
1465                             caps & GTK_PRINT_CAPABILITY_COPIES);
1466   gtk_widget_set_sensitive (priv->collate_check,
1467                             can_collate &&
1468                             (caps & GTK_PRINT_CAPABILITY_COLLATE));
1469   gtk_widget_set_sensitive (priv->reverse_check,
1470                             caps & GTK_PRINT_CAPABILITY_REVERSE);
1471   gtk_widget_set_sensitive (priv->scale_spin,
1472                             caps & GTK_PRINT_CAPABILITY_SCALE);
1473   gtk_widget_set_sensitive (GTK_WIDGET (priv->pages_per_sheet),
1474                             caps & GTK_PRINT_CAPABILITY_NUMBER_UP);
1475
1476   if (caps & GTK_PRINT_CAPABILITY_PREVIEW)
1477     gtk_widget_show (priv->preview_button);
1478   else
1479     gtk_widget_hide (priv->preview_button);
1480
1481   update_collate_icon (NULL, dialog);
1482
1483   gtk_tree_model_filter_refilter (priv->printer_list_filter);
1484 }
1485
1486 static gboolean
1487 page_setup_is_equal (GtkPageSetup *a,
1488                      GtkPageSetup *b)
1489 {
1490   return
1491     gtk_paper_size_is_equal (gtk_page_setup_get_paper_size (a),
1492                              gtk_page_setup_get_paper_size (b)) &&
1493     gtk_page_setup_get_top_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_top_margin (b, GTK_UNIT_MM) &&
1494     gtk_page_setup_get_bottom_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_bottom_margin (b, GTK_UNIT_MM) &&
1495     gtk_page_setup_get_left_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_left_margin (b, GTK_UNIT_MM) &&
1496     gtk_page_setup_get_right_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_right_margin (b, GTK_UNIT_MM);
1497 }
1498
1499 static gboolean
1500 page_setup_is_same_size (GtkPageSetup *a,
1501                          GtkPageSetup *b)
1502 {
1503   return gtk_paper_size_is_equal (gtk_page_setup_get_paper_size (a),
1504                                   gtk_page_setup_get_paper_size (b));
1505 }
1506
1507 static gboolean
1508 set_paper_size (GtkPrintUnixDialog *dialog,
1509                 GtkPageSetup       *page_setup,
1510                 gboolean            size_only,
1511                 gboolean            add_item)
1512 {
1513   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1514   GtkTreeModel *model;
1515   GtkTreeIter iter;
1516   GtkPageSetup *list_page_setup;
1517
1518   if (!priv->internal_page_setup_change)
1519     return TRUE;
1520
1521   if (page_setup == NULL)
1522     return FALSE;
1523
1524   model = GTK_TREE_MODEL (priv->page_setup_list);
1525
1526   if (gtk_tree_model_get_iter_first (model, &iter))
1527     {
1528       do
1529         {
1530           gtk_tree_model_get (GTK_TREE_MODEL (priv->page_setup_list), &iter,
1531                               PAGE_SETUP_LIST_COL_PAGE_SETUP, &list_page_setup, -1);
1532           if (list_page_setup == NULL)
1533             continue;
1534
1535           if ((size_only && page_setup_is_same_size (page_setup, list_page_setup)) ||
1536               (!size_only && page_setup_is_equal (page_setup, list_page_setup)))
1537             {
1538               gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->paper_size_combo),
1539                                              &iter);
1540               gtk_combo_box_set_active (GTK_COMBO_BOX (priv->orientation_combo),
1541                                         gtk_page_setup_get_orientation (page_setup));
1542               g_object_unref (list_page_setup);
1543               return TRUE;
1544             }
1545
1546           g_object_unref (list_page_setup);
1547
1548         } while (gtk_tree_model_iter_next (model, &iter));
1549     }
1550
1551   if (add_item)
1552     {
1553       gtk_list_store_append (priv->page_setup_list, &iter);
1554       gtk_list_store_set (priv->page_setup_list, &iter,
1555                           PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
1556                           -1);
1557       gtk_list_store_append (priv->page_setup_list, &iter);
1558       gtk_list_store_set (priv->page_setup_list, &iter,
1559                           PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
1560                           -1);
1561       gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->paper_size_combo),
1562                                      &iter);
1563       gtk_combo_box_set_active (GTK_COMBO_BOX (priv->orientation_combo),
1564                                 gtk_page_setup_get_orientation (page_setup));
1565       return TRUE;
1566     }
1567
1568   return FALSE;
1569 }
1570
1571 static void
1572 fill_custom_paper_sizes (GtkPrintUnixDialog *dialog)
1573 {
1574   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1575   GtkTreeIter iter, paper_iter;
1576   GtkTreeModel *model;
1577
1578   model = GTK_TREE_MODEL (priv->custom_paper_list);
1579   if (gtk_tree_model_get_iter_first (model, &iter))
1580     {
1581       gtk_list_store_append (priv->page_setup_list, &paper_iter);
1582       gtk_list_store_set (priv->page_setup_list, &paper_iter,
1583                           PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
1584                           -1);
1585       do
1586         {
1587           GtkPageSetup *page_setup;
1588           gtk_tree_model_get (model, &iter, 0, &page_setup, -1);
1589
1590           gtk_list_store_append (priv->page_setup_list, &paper_iter);
1591           gtk_list_store_set (priv->page_setup_list, &paper_iter,
1592                               PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
1593                               -1);
1594
1595           g_object_unref (page_setup);
1596         } while (gtk_tree_model_iter_next (model, &iter));
1597     }
1598
1599   gtk_list_store_append (priv->page_setup_list, &paper_iter);
1600   gtk_list_store_set (priv->page_setup_list, &paper_iter,
1601                       PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
1602                       -1);
1603   gtk_list_store_append (priv->page_setup_list, &paper_iter);
1604   gtk_list_store_set (priv->page_setup_list, &paper_iter,
1605                       PAGE_SETUP_LIST_COL_PAGE_SETUP, NULL,
1606                       -1);
1607 }
1608
1609 static void
1610 fill_paper_sizes (GtkPrintUnixDialog *dialog,
1611                   GtkPrinter         *printer)
1612 {
1613   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1614   GList *list, *l;
1615   GtkPageSetup *page_setup;
1616   GtkPaperSize *paper_size;
1617   GtkTreeIter iter;
1618   gint i;
1619
1620   gtk_list_store_clear (priv->page_setup_list);
1621
1622   if (printer == NULL || (list = gtk_printer_list_papers (printer)) == NULL)
1623     {
1624       for (i = 0; i < G_N_ELEMENTS (common_paper_sizes); i++)
1625         {
1626           page_setup = gtk_page_setup_new ();
1627           paper_size = gtk_paper_size_new (common_paper_sizes[i]);
1628           gtk_page_setup_set_paper_size_and_default_margins (page_setup, paper_size);
1629           gtk_paper_size_free (paper_size);
1630
1631           gtk_list_store_append (priv->page_setup_list, &iter);
1632           gtk_list_store_set (priv->page_setup_list, &iter,
1633                               PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
1634                               -1);
1635           g_object_unref (page_setup);
1636         }
1637     }
1638   else
1639     {
1640       for (l = list; l != NULL; l = l->next)
1641         {
1642           page_setup = l->data;
1643           gtk_list_store_append (priv->page_setup_list, &iter);
1644           gtk_list_store_set (priv->page_setup_list, &iter,
1645                               PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
1646                               -1);
1647           g_object_unref (page_setup);
1648         }
1649       g_list_free (list);
1650     }
1651
1652   fill_custom_paper_sizes (dialog);
1653 }
1654
1655 static void
1656 update_paper_sizes (GtkPrintUnixDialog *dialog)
1657 {
1658   GtkPageSetup *current_page_setup = NULL;
1659   GtkPrinter   *printer;
1660
1661   printer = gtk_print_unix_dialog_get_selected_printer (dialog);
1662
1663   fill_paper_sizes (dialog, printer);
1664
1665   current_page_setup = gtk_page_setup_copy (gtk_print_unix_dialog_get_page_setup (dialog));
1666
1667   if (current_page_setup)
1668     {
1669       if (!set_paper_size (dialog, current_page_setup, FALSE, FALSE))
1670         set_paper_size (dialog, current_page_setup, TRUE, TRUE);
1671
1672       g_object_unref (current_page_setup);
1673     }
1674 }
1675
1676 static void
1677 mark_conflicts (GtkPrintUnixDialog *dialog)
1678 {
1679   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1680   GtkPrinter *printer;
1681   gboolean have_conflict;
1682
1683   have_conflict = FALSE;
1684
1685   printer = priv->current_printer;
1686
1687   if (printer)
1688     {
1689
1690       g_signal_handler_block (priv->options,
1691                               priv->options_changed_handler);
1692
1693       gtk_printer_option_set_clear_conflicts (priv->options);
1694
1695       have_conflict = _gtk_printer_mark_conflicts (printer,
1696                                                    priv->options);
1697
1698       g_signal_handler_unblock (priv->options,
1699                                 priv->options_changed_handler);
1700     }
1701
1702   if (have_conflict)
1703     gtk_widget_show (priv->conflicts_widget);
1704   else
1705     gtk_widget_hide (priv->conflicts_widget);
1706 }
1707
1708 static gboolean
1709 mark_conflicts_callback (gpointer data)
1710 {
1711   GtkPrintUnixDialog *dialog = data;
1712   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1713
1714   priv->mark_conflicts_id = 0;
1715
1716   mark_conflicts (dialog);
1717
1718   return FALSE;
1719 }
1720
1721 static void
1722 unschedule_idle_mark_conflicts (GtkPrintUnixDialog *dialog)
1723 {
1724   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1725
1726   if (priv->mark_conflicts_id != 0)
1727     {
1728       g_source_remove (priv->mark_conflicts_id);
1729       priv->mark_conflicts_id = 0;
1730     }
1731 }
1732
1733 static void
1734 schedule_idle_mark_conflicts (GtkPrintUnixDialog *dialog)
1735 {
1736   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1737
1738   if (priv->mark_conflicts_id != 0)
1739     return;
1740
1741   priv->mark_conflicts_id = gdk_threads_add_idle (mark_conflicts_callback,
1742                                         dialog);
1743 }
1744
1745 static void
1746 options_changed_cb (GtkPrintUnixDialog *dialog)
1747 {
1748   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1749
1750   schedule_idle_mark_conflicts (dialog);
1751
1752   g_free (priv->waiting_for_printer);
1753   priv->waiting_for_printer = NULL;
1754 }
1755
1756 static void
1757 remove_custom_widget (GtkWidget    *widget,
1758                       GtkContainer *container)
1759 {
1760   gtk_container_remove (container, widget);
1761 }
1762
1763 static void
1764 extension_point_clear_children (GtkContainer *container)
1765 {
1766   gtk_container_foreach (container,
1767                          (GtkCallback)remove_custom_widget,
1768                          container);
1769 }
1770
1771 static void
1772 clear_per_printer_ui (GtkPrintUnixDialog *dialog)
1773 {
1774   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1775
1776   gtk_container_foreach (GTK_CONTAINER (priv->finishing_table),
1777                          (GtkCallback)gtk_widget_destroy,
1778                          NULL);
1779   gtk_table_resize (GTK_TABLE (priv->finishing_table), 1, 2);
1780   gtk_container_foreach (GTK_CONTAINER (priv->image_quality_table),
1781                          (GtkCallback)gtk_widget_destroy,
1782                          NULL);
1783   gtk_table_resize (GTK_TABLE (priv->image_quality_table), 1, 2);
1784   gtk_container_foreach (GTK_CONTAINER (priv->color_table),
1785                          (GtkCallback)gtk_widget_destroy,
1786                          NULL);
1787   gtk_table_resize (GTK_TABLE (priv->color_table), 1, 2);
1788   gtk_container_foreach (GTK_CONTAINER (priv->advanced_vbox),
1789                          (GtkCallback)gtk_widget_destroy,
1790                          NULL);
1791   extension_point_clear_children (GTK_CONTAINER (priv->extension_point));
1792 }
1793
1794 static void
1795 printer_details_acquired (GtkPrinter         *printer,
1796                           gboolean            success,
1797                           GtkPrintUnixDialog *dialog)
1798 {
1799   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1800
1801   disconnect_printer_details_request (dialog, !success);
1802
1803   if (success)
1804     {
1805       GtkTreeSelection *selection;
1806       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
1807
1808       selected_printer_changed (selection, dialog);
1809     }
1810 }
1811
1812 static void
1813 selected_printer_changed (GtkTreeSelection   *selection,
1814                           GtkPrintUnixDialog *dialog)
1815 {
1816   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1817   GtkPrinter *printer;
1818   GtkTreeIter iter, filter_iter;
1819
1820   /* Whenever the user selects a printer we stop looking for
1821      the printer specified in the initial settings */
1822   if (priv->waiting_for_printer &&
1823       !priv->internal_printer_change)
1824     {
1825       g_free (priv->waiting_for_printer);
1826       priv->waiting_for_printer = NULL;
1827     }
1828
1829   disconnect_printer_details_request (dialog, FALSE);
1830
1831   printer = NULL;
1832   if (gtk_tree_selection_get_selected (selection, NULL, &filter_iter))
1833     {
1834       gtk_tree_model_filter_convert_iter_to_child_iter (priv->printer_list_filter,
1835                                                         &iter,
1836                                                         &filter_iter);
1837
1838       gtk_tree_model_get (priv->printer_list, &iter,
1839                           PRINTER_LIST_COL_PRINTER_OBJ, &printer,
1840                           -1);
1841     }
1842
1843   /* sets GTK_RESPONSE_OK button sensitivity depending on whether the printer
1844    * accepts/rejects jobs
1845    */
1846   if (printer != NULL)
1847     {
1848       if (!gtk_printer_is_accepting_jobs (printer))
1849         {
1850           gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
1851         }
1852       else
1853         {
1854           if (priv->current_printer == printer && gtk_printer_has_details (printer))
1855             gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, TRUE);
1856         }
1857     }
1858
1859   if (printer != NULL && !gtk_printer_has_details (printer))
1860     {
1861       gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
1862       priv->request_details_tag =
1863         g_signal_connect (printer, "details-acquired",
1864                           G_CALLBACK (printer_details_acquired), dialog);
1865       /* take the reference */
1866       priv->request_details_printer = printer;
1867       gtk_printer_request_details (printer);
1868       set_busy_cursor (dialog, TRUE);
1869       gtk_list_store_set (GTK_LIST_STORE (priv->printer_list),
1870                           g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter"),
1871                           PRINTER_LIST_COL_STATE, _("Getting printer information..."),
1872                           -1);
1873       return;
1874     }
1875
1876   if (printer == priv->current_printer)
1877     {
1878       if (printer)
1879         g_object_unref (printer);
1880       return;
1881     }
1882
1883   if (priv->options)
1884     {
1885       g_object_unref (priv->options);
1886       priv->options = NULL;
1887
1888       clear_per_printer_ui (dialog);
1889     }
1890
1891   if (priv->current_printer)
1892     {
1893       g_object_unref (priv->current_printer);
1894     }
1895
1896   priv->printer_capabilities = 0;
1897
1898   if (gtk_printer_is_accepting_jobs (printer))
1899     gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, TRUE);
1900   priv->current_printer = printer;
1901
1902   if (printer != NULL)
1903     {
1904       if (!priv->page_setup_set)
1905         {
1906           /* if no explicit page setup has been set, use the printer default */
1907           GtkPageSetup *page_setup;
1908
1909           page_setup = gtk_printer_get_default_page_size (printer);
1910
1911           if (!page_setup)
1912             page_setup = gtk_page_setup_new ();
1913
1914           if (page_setup && priv->page_setup)
1915             gtk_page_setup_set_orientation (page_setup, gtk_page_setup_get_orientation (priv->page_setup));
1916
1917           g_object_unref (priv->page_setup);
1918           priv->page_setup = page_setup;
1919         }
1920
1921       priv->printer_capabilities = gtk_printer_get_capabilities (printer);
1922       priv->options = _gtk_printer_get_options (printer,
1923                                                 priv->initial_settings,
1924                                                 priv->page_setup,
1925                                                 priv->manual_capabilities);
1926
1927       priv->options_changed_handler =
1928         g_signal_connect_swapped (priv->options, "changed", G_CALLBACK (options_changed_cb), dialog);
1929       schedule_idle_mark_conflicts (dialog);
1930     }
1931
1932   update_dialog_from_settings (dialog);
1933   update_dialog_from_capabilities (dialog);
1934
1935   priv->internal_page_setup_change = TRUE;
1936   update_paper_sizes (dialog);
1937   priv->internal_page_setup_change = FALSE;
1938
1939   g_object_notify ( G_OBJECT(dialog), "selected-printer");
1940 }
1941
1942 static void
1943 update_collate_icon (GtkToggleButton    *toggle_button,
1944                      GtkPrintUnixDialog *dialog)
1945 {
1946   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1947
1948   gtk_widget_queue_draw (priv->collate_image);
1949 }
1950
1951 static void
1952 paint_page (GtkWidget *widget,
1953             cairo_t   *cr,
1954             gfloat     scale,
1955             gint       x_offset,
1956             gint       y_offset,
1957             gchar     *text,
1958             gint       text_x)
1959 {
1960   GtkStyleContext *context;
1961   gint x, y, width, height;
1962   gint text_y, linewidth;
1963   GdkRGBA color;
1964
1965   x = x_offset * scale;
1966   y = y_offset * scale;
1967   width = 20 * scale;
1968   height = 26 * scale;
1969
1970   linewidth = 2;
1971   text_y = 21;
1972
1973   context = gtk_widget_get_style_context (widget);
1974
1975   gtk_style_context_save (context);
1976   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
1977
1978   gtk_style_context_get_background_color (context, 0, &color);
1979   gdk_cairo_set_source_rgba (cr, &color);
1980   cairo_rectangle (cr, x, y, width, height);
1981   cairo_fill (cr);
1982
1983   gtk_style_context_get_color (context, 0, &color);
1984   gdk_cairo_set_source_rgba (cr, &color);
1985   cairo_set_line_width (cr, linewidth);
1986   cairo_rectangle (cr, x + linewidth/2.0, y + linewidth/2.0, width - linewidth, height - linewidth);
1987   cairo_stroke (cr);
1988
1989   cairo_select_font_face (cr, "Sans",
1990                           CAIRO_FONT_SLANT_NORMAL,
1991                           CAIRO_FONT_WEIGHT_NORMAL);
1992   cairo_set_font_size (cr, (gint)(9 * scale));
1993   cairo_move_to (cr, x + (gint)(text_x * scale), y + (gint)(text_y * scale));
1994   cairo_show_text (cr, text);
1995
1996   gtk_style_context_restore (context);
1997 }
1998
1999 static gboolean
2000 draw_collate_cb (GtkWidget          *widget,
2001                  cairo_t            *cr,
2002                  GtkPrintUnixDialog *dialog)
2003 {
2004   GtkSettings *settings;
2005   gint size;
2006   gfloat scale;
2007   gboolean collate, reverse, rtl;
2008   gint copies;
2009   gint text_x;
2010
2011   collate = dialog_get_collate (dialog);
2012   reverse = dialog_get_reverse (dialog);
2013   copies = dialog_get_n_copies (dialog);
2014
2015   rtl = (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL);
2016
2017   settings = gtk_widget_get_settings (widget);
2018   gtk_icon_size_lookup_for_settings (settings,
2019                                      GTK_ICON_SIZE_DIALOG,
2020                                      &size,
2021                                      NULL);
2022   scale = size / 48.0;
2023   text_x = rtl ? 4 : 11;
2024
2025   if (copies == 1)
2026     {
2027       paint_page (widget, cr, scale, rtl ? 40: 15, 5, reverse ? "1" : "2", text_x);
2028       paint_page (widget, cr, scale, rtl ? 50: 5, 15, reverse ? "2" : "1", text_x);
2029     }
2030   else
2031     {
2032       paint_page (widget, cr, scale, rtl ? 40: 15, 5, collate == reverse ? "1" : "2", text_x);
2033       paint_page (widget, cr, scale, rtl ? 50: 5, 15, reverse ? "2" : "1", text_x);
2034
2035       paint_page (widget, cr, scale, rtl ? 5 : 50, 5, reverse ? "1" : "2", text_x);
2036       paint_page (widget, cr, scale, rtl ? 15 : 40, 15, collate == reverse ? "2" : "1", text_x);
2037     }
2038
2039   return TRUE;
2040 }
2041
2042 static void
2043 gtk_print_unix_dialog_style_updated (GtkWidget *widget)
2044 {
2045   GTK_WIDGET_CLASS (gtk_print_unix_dialog_parent_class)->style_updated (widget);
2046
2047   if (gtk_widget_has_screen (widget))
2048     {
2049       GtkPrintUnixDialog *dialog = (GtkPrintUnixDialog *)widget;
2050       GtkPrintUnixDialogPrivate *priv = dialog->priv;
2051       GtkSettings *settings;
2052       gint size;
2053       gfloat scale;
2054
2055       settings = gtk_widget_get_settings (widget);
2056       gtk_icon_size_lookup_for_settings (settings,
2057                                          GTK_ICON_SIZE_DIALOG,
2058                                          &size,
2059                                          NULL);
2060       scale = size / 48.0;
2061
2062       gtk_widget_set_size_request (priv->collate_image,
2063                                    (50 + 20) * scale,
2064                                    (15 + 26) * scale);
2065     }
2066 }
2067
2068 static void
2069 update_entry_sensitivity (GtkWidget *button,
2070                           GtkWidget *range)
2071 {
2072   gboolean active;
2073
2074   active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
2075
2076   gtk_widget_set_sensitive (range, active);
2077
2078   if (active)
2079     gtk_widget_grab_focus (range);
2080 }
2081
2082 static void
2083 emit_ok_response (GtkTreeView       *tree_view,
2084                   GtkTreePath       *path,
2085                   GtkTreeViewColumn *column,
2086                   gpointer          *user_data)
2087 {
2088   GtkPrintUnixDialog *print_dialog;
2089
2090   print_dialog = (GtkPrintUnixDialog *) user_data;
2091
2092   gtk_dialog_response (GTK_DIALOG (print_dialog), GTK_RESPONSE_OK);
2093 }
2094
2095 static void
2096 create_main_page (GtkPrintUnixDialog *dialog)
2097 {
2098   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2099   GtkWidget *main_vbox, *label, *vbox, *hbox;
2100   GtkWidget *scrolled, *treeview, *frame, *table;
2101   GtkWidget *entry, *spinbutton;
2102   GtkWidget *radio, *check, *image;
2103   GtkCellRenderer *renderer;
2104   GtkTreeViewColumn *column;
2105   GtkTreeSelection *selection;
2106   GtkWidget *custom_input;
2107   const gchar *range_tooltip;
2108
2109   main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
2110   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
2111   gtk_widget_show (main_vbox);
2112
2113   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
2114   gtk_box_pack_start (GTK_BOX (main_vbox), vbox, TRUE, TRUE, 0);
2115   gtk_widget_show (vbox);
2116
2117   scrolled = gtk_scrolled_window_new (NULL, NULL);
2118   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
2119                                   GTK_POLICY_AUTOMATIC,
2120                                   GTK_POLICY_AUTOMATIC);
2121   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
2122                                        GTK_SHADOW_IN);
2123   gtk_widget_show (scrolled);
2124   gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
2125
2126   treeview = gtk_tree_view_new_with_model ((GtkTreeModel *) priv->printer_list_filter);
2127   priv->printer_treeview = treeview;
2128   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), TRUE);
2129   gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), PRINTER_LIST_COL_NAME);
2130   gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), TRUE);
2131   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
2132   gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
2133   g_signal_connect (selection, "changed", G_CALLBACK (selected_printer_changed), dialog);
2134
2135   renderer = gtk_cell_renderer_pixbuf_new ();
2136   column = gtk_tree_view_column_new_with_attributes ("",
2137                                                      renderer,
2138                                                      "icon-name",
2139                                                      PRINTER_LIST_COL_ICON,
2140                                                      NULL);
2141   gtk_tree_view_column_set_cell_data_func (column, renderer, set_cell_sensitivity_func, NULL, NULL);
2142   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2143
2144   renderer = gtk_cell_renderer_text_new ();
2145   column = gtk_tree_view_column_new_with_attributes (_("Printer"),
2146                                                      renderer,
2147                                                      "text",
2148                                                      PRINTER_LIST_COL_NAME,
2149                                                      NULL);
2150   gtk_tree_view_column_set_cell_data_func (column, renderer, set_cell_sensitivity_func, NULL, NULL);
2151   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2152
2153   renderer = gtk_cell_renderer_text_new ();
2154   /* Translators: this is the header for the location column in the print dialog */
2155   column = gtk_tree_view_column_new_with_attributes (_("Location"),
2156                                                      renderer,
2157                                                      "text",
2158                                                      PRINTER_LIST_COL_LOCATION,
2159                                                      NULL);
2160   gtk_tree_view_column_set_cell_data_func (column, renderer, set_cell_sensitivity_func, NULL, NULL);
2161   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2162
2163   renderer = gtk_cell_renderer_text_new ();
2164   g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
2165   /* Translators: this is the header for the printer status column in the print dialog */
2166   column = gtk_tree_view_column_new_with_attributes (_("Status"),
2167                                                      renderer,
2168                                                      "text",
2169                                                      PRINTER_LIST_COL_STATE,
2170                                                      NULL);
2171   gtk_tree_view_column_set_cell_data_func (column, renderer, set_cell_sensitivity_func, NULL, NULL);
2172   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
2173
2174   g_signal_connect (GTK_TREE_VIEW (treeview), "row-activated", G_CALLBACK (emit_ok_response), dialog);
2175
2176   gtk_widget_show (treeview);
2177   gtk_container_add (GTK_CONTAINER (scrolled), treeview);
2178
2179   custom_input = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 18);
2180   gtk_widget_show (custom_input);
2181   gtk_box_pack_start (GTK_BOX (vbox), custom_input, FALSE, FALSE, 0);
2182   priv->extension_point = custom_input;
2183
2184   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 18);
2185   gtk_widget_show (hbox);
2186   gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
2187
2188   table = gtk_table_new (4, 2, FALSE);
2189   priv->range_table = table;
2190   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2191   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2192   frame = wrap_in_frame (_("Range"), table);
2193   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
2194   gtk_widget_show (table);
2195
2196   radio = gtk_radio_button_new_with_mnemonic (NULL, _("_All Pages"));
2197   priv->all_pages_radio = radio;
2198   gtk_widget_show (radio);
2199   gtk_table_attach (GTK_TABLE (table), radio,
2200                     0, 2, 0, 1,  GTK_FILL, 0,
2201                     0, 0);
2202   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
2203                                               _("C_urrent Page"));
2204   if (priv->current_page == -1)
2205     gtk_widget_set_sensitive (radio, FALSE);
2206   priv->current_page_radio = radio;
2207   gtk_widget_show (radio);
2208   gtk_table_attach (GTK_TABLE (table), radio,
2209                     0, 2, 1, 2,  GTK_FILL, 0,
2210                     0, 0);
2211
2212   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
2213                                               _("Se_lection"));
2214
2215   gtk_widget_set_sensitive (radio, priv->has_selection);
2216   priv->selection_radio = radio;
2217   gtk_table_attach (GTK_TABLE (table), radio,
2218                     0, 2, 2, 3,  GTK_FILL, 0,
2219                     0, 0);
2220   gtk_table_set_row_spacing (GTK_TABLE (table), 2, 0);
2221
2222   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), _("Pag_es:"));
2223   range_tooltip = _("Specify one or more page ranges,\n e.g. 1-3,7,11");
2224   gtk_widget_set_tooltip_text (radio, range_tooltip);
2225
2226   priv->page_range_radio = radio;
2227   gtk_widget_show (radio);
2228   gtk_table_attach (GTK_TABLE (table), radio,
2229                     0, 1, 3, 4,  GTK_FILL, 0,
2230                     0, 0);
2231   entry = gtk_entry_new ();
2232   gtk_widget_set_tooltip_text (entry, range_tooltip);
2233   atk_object_set_name (gtk_widget_get_accessible (entry), _("Pages"));
2234   atk_object_set_description (gtk_widget_get_accessible (entry), range_tooltip);
2235   priv->page_range_entry = entry;
2236   gtk_widget_show (entry);
2237   gtk_table_attach (GTK_TABLE (table), entry,
2238                     1, 2, 3, 4,  GTK_FILL, 0,
2239                     0, 0);
2240   g_signal_connect (radio, "toggled", G_CALLBACK (update_entry_sensitivity), entry);
2241   update_entry_sensitivity (radio, entry);
2242
2243   table = gtk_table_new (3, 2, FALSE);
2244   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2245   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2246   frame = wrap_in_frame (_("Copies"), table);
2247   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
2248   gtk_widget_show (table);
2249
2250   /* FIXME chpe: too much space between Copies and spinbutton, put those 2 in a hbox and make it span 2 columns */
2251   label = gtk_label_new_with_mnemonic (_("Copie_s:"));
2252   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2253   gtk_widget_show (label);
2254   gtk_table_attach (GTK_TABLE (table), label,
2255                     0, 1, 0, 1,  GTK_FILL, 0,
2256                     0, 0);
2257   spinbutton = gtk_spin_button_new_with_range (1.0, 100.0, 1.0);
2258   priv->copies_spin = spinbutton;
2259   gtk_widget_show (spinbutton);
2260   gtk_table_attach (GTK_TABLE (table), spinbutton,
2261                     1, 2, 0, 1,  GTK_FILL, 0,
2262                     0, 0);
2263   gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
2264   g_signal_connect_swapped (spinbutton, "value-changed",
2265                             G_CALLBACK (update_dialog_from_capabilities), dialog);
2266   g_signal_connect_swapped (spinbutton, "changed",
2267                             G_CALLBACK (update_dialog_from_capabilities), dialog);
2268
2269   check = gtk_check_button_new_with_mnemonic (_("C_ollate"));
2270   priv->collate_check = check;
2271   g_signal_connect (check, "toggled", G_CALLBACK (update_collate_icon), dialog);
2272   gtk_widget_show (check);
2273   gtk_table_attach (GTK_TABLE (table), check,
2274                     0, 1, 1, 2,  GTK_FILL, 0,
2275                     0, 0);
2276
2277   check = gtk_check_button_new_with_mnemonic (_("_Reverse"));
2278   g_signal_connect (check, "toggled", G_CALLBACK (update_collate_icon), dialog);
2279   priv->reverse_check = check;
2280   gtk_widget_show (check);
2281   gtk_table_attach (GTK_TABLE (table), check,
2282                     0, 1, 2, 3,  GTK_FILL, 0,
2283                     0, 0);
2284
2285   image = gtk_drawing_area_new ();
2286   gtk_widget_set_has_window (image, FALSE);
2287
2288   priv->collate_image = image;
2289   gtk_widget_show (image);
2290   gtk_widget_set_size_request (image, 70, 90);
2291   gtk_table_attach (GTK_TABLE (table), image,
2292                     1, 2, 1, 3, GTK_FILL, 0,
2293                     0, 0);
2294   g_signal_connect (image, "draw",
2295                     G_CALLBACK (draw_collate_cb), dialog);
2296
2297   label = gtk_label_new (_("General"));
2298   gtk_widget_show (label);
2299
2300   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), main_vbox, label);
2301 }
2302
2303 static gboolean
2304 is_range_separator (gchar c)
2305 {
2306   return (c == ',' || c == ';' || c == ':');
2307 }
2308
2309 static GtkPageRange *
2310 dialog_get_page_ranges (GtkPrintUnixDialog *dialog,
2311                         gint               *n_ranges_out)
2312 {
2313   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2314   gint i, n_ranges;
2315   const gchar *text, *p;
2316   gchar *next;
2317   GtkPageRange *ranges;
2318   gint start, end;
2319
2320   text = gtk_entry_get_text (GTK_ENTRY (priv->page_range_entry));
2321
2322   if (*text == 0)
2323     {
2324       *n_ranges_out = 0;
2325       return NULL;
2326     }
2327
2328   n_ranges = 1;
2329   p = text;
2330   while (*p)
2331     {
2332       if (is_range_separator (*p))
2333         n_ranges++;
2334       p++;
2335     }
2336
2337   ranges = g_new0 (GtkPageRange, n_ranges);
2338
2339   i = 0;
2340   p = text;
2341   while (*p)
2342     {
2343       while (isspace (*p)) p++;
2344
2345       if (*p == '-')
2346         {
2347           /* a half-open range like -2 */
2348           start = 1;
2349         }
2350       else
2351         {
2352           start = (int)strtol (p, &next, 10);
2353           if (start < 1)
2354             start = 1;
2355           p = next;
2356         }
2357
2358       end = start;
2359
2360       while (isspace (*p)) p++;
2361
2362       if (*p == '-')
2363         {
2364           p++;
2365           end = (int)strtol (p, &next, 10);
2366           if (next == p) /* a half-open range like 2- */
2367             end = 0;
2368           else if (end < start)
2369             end = start;
2370         }
2371
2372       ranges[i].start = start - 1;
2373       ranges[i].end = end - 1;
2374       i++;
2375
2376       /* Skip until end or separator */
2377       while (*p && !is_range_separator (*p))
2378         p++;
2379
2380       /* if not at end, skip separator */
2381       if (*p)
2382         p++;
2383     }
2384
2385   *n_ranges_out = i;
2386
2387   return ranges;
2388 }
2389
2390 static void
2391 dialog_set_page_ranges (GtkPrintUnixDialog *dialog,
2392                         GtkPageRange       *ranges,
2393                         gint                n_ranges)
2394 {
2395   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2396   gint i;
2397   GString *s = g_string_new (NULL);
2398
2399   for (i = 0; i < n_ranges; i++)
2400     {
2401       g_string_append_printf (s, "%d", ranges[i].start + 1);
2402       if (ranges[i].end > ranges[i].start)
2403         g_string_append_printf (s, "-%d", ranges[i].end + 1);
2404       else if (ranges[i].end == -1)
2405         g_string_append (s, "-");
2406
2407       if (i != n_ranges - 1)
2408         g_string_append (s, ",");
2409     }
2410
2411   gtk_entry_set_text (GTK_ENTRY (priv->page_range_entry), s->str);
2412
2413   g_string_free (s, TRUE);
2414 }
2415
2416 static GtkPrintPages
2417 dialog_get_print_pages (GtkPrintUnixDialog *dialog)
2418 {
2419   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2420
2421   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->all_pages_radio)))
2422     return GTK_PRINT_PAGES_ALL;
2423   else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->current_page_radio)))
2424     return GTK_PRINT_PAGES_CURRENT;
2425   else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->selection_radio)))
2426     return GTK_PRINT_PAGES_SELECTION;
2427   else
2428     return GTK_PRINT_PAGES_RANGES;
2429 }
2430
2431 static void
2432 dialog_set_print_pages (GtkPrintUnixDialog *dialog,
2433                         GtkPrintPages       pages)
2434 {
2435   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2436
2437   if (pages == GTK_PRINT_PAGES_RANGES)
2438     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->page_range_radio), TRUE);
2439   else if (pages == GTK_PRINT_PAGES_CURRENT)
2440     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->current_page_radio), TRUE);
2441   else if (pages == GTK_PRINT_PAGES_SELECTION)
2442     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selection_radio), TRUE);
2443   else
2444     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_pages_radio), TRUE);
2445 }
2446
2447 static gdouble
2448 dialog_get_scale (GtkPrintUnixDialog *dialog)
2449 {
2450   if (gtk_widget_is_sensitive (dialog->priv->scale_spin))
2451     return gtk_spin_button_get_value (GTK_SPIN_BUTTON (dialog->priv->scale_spin));
2452   else
2453     return 100.0;
2454 }
2455
2456 static void
2457 dialog_set_scale (GtkPrintUnixDialog *dialog,
2458                   gdouble             val)
2459 {
2460   gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->priv->scale_spin), val);
2461 }
2462
2463 static GtkPageSet
2464 dialog_get_page_set (GtkPrintUnixDialog *dialog)
2465 {
2466   if (gtk_widget_is_sensitive (dialog->priv->page_set_combo))
2467     return (GtkPageSet)gtk_combo_box_get_active (GTK_COMBO_BOX (dialog->priv->page_set_combo));
2468   else
2469     return GTK_PAGE_SET_ALL;
2470 }
2471
2472 static void
2473 dialog_set_page_set (GtkPrintUnixDialog *dialog,
2474                      GtkPageSet          val)
2475 {
2476   gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->priv->page_set_combo),
2477                             (int)val);
2478 }
2479
2480 static gint
2481 dialog_get_n_copies (GtkPrintUnixDialog *dialog)
2482 {
2483   if (gtk_widget_is_sensitive (dialog->priv->copies_spin))
2484     return gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dialog->priv->copies_spin));
2485   return 1;
2486 }
2487
2488 static void
2489 dialog_set_n_copies (GtkPrintUnixDialog *dialog,
2490                      gint                n_copies)
2491 {
2492   gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->priv->copies_spin),
2493                              n_copies);
2494 }
2495
2496 static gboolean
2497 dialog_get_collate (GtkPrintUnixDialog *dialog)
2498 {
2499   if (gtk_widget_is_sensitive (dialog->priv->collate_check))
2500     return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->collate_check));
2501   return FALSE;
2502 }
2503
2504 static void
2505 dialog_set_collate (GtkPrintUnixDialog *dialog,
2506                     gboolean            collate)
2507 {
2508   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->collate_check),
2509                                 collate);
2510 }
2511
2512 static gboolean
2513 dialog_get_reverse (GtkPrintUnixDialog *dialog)
2514 {
2515   if (gtk_widget_is_sensitive (dialog->priv->reverse_check))
2516     return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->reverse_check));
2517   return FALSE;
2518 }
2519
2520 static void
2521 dialog_set_reverse (GtkPrintUnixDialog *dialog,
2522                     gboolean            reverse)
2523 {
2524   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->reverse_check),
2525                                 reverse);
2526 }
2527
2528 static gint
2529 dialog_get_pages_per_sheet (GtkPrintUnixDialog *dialog)
2530 {
2531   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2532   const gchar *val;
2533   gint num;
2534
2535   val = gtk_printer_option_widget_get_value (priv->pages_per_sheet);
2536
2537   num = 1;
2538
2539   if (val)
2540     {
2541       num = atoi(val);
2542       if (num < 1)
2543         num = 1;
2544     }
2545
2546   return num;
2547 }
2548
2549 static GtkNumberUpLayout
2550 dialog_get_number_up_layout (GtkPrintUnixDialog *dialog)
2551 {
2552   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2553   GtkPrintCapabilities       caps;
2554   GtkNumberUpLayout          layout;
2555   const gchar               *val;
2556   GEnumClass                *enum_class;
2557   GEnumValue                *enum_value;
2558
2559   val = gtk_printer_option_widget_get_value (priv->number_up_layout);
2560
2561   caps = priv->manual_capabilities | priv->printer_capabilities;
2562
2563   if ((caps & GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT) == 0)
2564     return GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM;
2565
2566   if (gtk_widget_get_direction (GTK_WIDGET (dialog)) == GTK_TEXT_DIR_LTR)
2567     layout = GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM;
2568   else
2569     layout = GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM;
2570
2571   if (val == NULL)
2572     return layout;
2573
2574   if (val[0] == '\0' && priv->options)
2575     {
2576       GtkPrinterOption *option = gtk_printer_option_set_lookup (priv->options, "gtk-n-up-layout");
2577       if (option)
2578         val = option->value;
2579     }
2580
2581   enum_class = g_type_class_ref (GTK_TYPE_NUMBER_UP_LAYOUT);
2582   enum_value = g_enum_get_value_by_nick (enum_class, val);
2583   if (enum_value)
2584     layout = enum_value->value;
2585   g_type_class_unref (enum_class);
2586
2587   return layout;
2588 }
2589
2590 static gboolean
2591 draw_page_cb (GtkWidget          *widget,
2592               cairo_t            *cr,
2593               GtkPrintUnixDialog *dialog)
2594 {
2595   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2596   GtkStyleContext *context;
2597   gdouble ratio;
2598   gint w, h, tmp, shadow_offset;
2599   gint pages_x, pages_y, i, x, y, layout_w, layout_h;
2600   gdouble page_width, page_height;
2601   GtkPageOrientation orientation;
2602   gboolean landscape;
2603   PangoLayout *layout;
2604   PangoFontDescription *font;
2605   gchar *text;
2606   GdkRGBA color;
2607   GtkNumberUpLayout number_up_layout;
2608   gint start_x, end_x, start_y, end_y;
2609   gint dx, dy;
2610   gint width, height;
2611   gboolean horizontal;
2612   GtkPageSetup *page_setup;
2613   gdouble paper_width, paper_height;
2614   gdouble pos_x, pos_y;
2615   gint pages_per_sheet;
2616   gboolean ltr = TRUE;
2617
2618   orientation = gtk_page_setup_get_orientation (priv->page_setup);
2619   landscape =
2620     (orientation == GTK_PAGE_ORIENTATION_LANDSCAPE) ||
2621     (orientation == GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE);
2622
2623   number_up_layout = dialog_get_number_up_layout (dialog);
2624   width = gtk_widget_get_allocated_width (widget);
2625   height = gtk_widget_get_allocated_height (widget);
2626
2627   cairo_save (cr);
2628
2629   page_setup = gtk_print_unix_dialog_get_page_setup (dialog);
2630
2631   if (page_setup != NULL)
2632     {
2633       if (!landscape)
2634         {
2635           paper_width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM);
2636           paper_height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM);
2637         }
2638       else
2639         {
2640           paper_width = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM);
2641           paper_height = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM);
2642         }
2643
2644       if (paper_width < paper_height)
2645         {
2646           h = EXAMPLE_PAGE_AREA_SIZE - 3;
2647           w = (paper_height != 0) ? h * paper_width / paper_height : 0;
2648         }
2649       else
2650         {
2651           w = EXAMPLE_PAGE_AREA_SIZE - 3;
2652           h = (paper_width != 0) ? w * paper_height / paper_width : 0;
2653         }
2654
2655       if (paper_width == 0)
2656         w = 0;
2657
2658       if (paper_height == 0)
2659         h = 0;
2660     }
2661   else
2662     {
2663       ratio = G_SQRT2;
2664       w = (EXAMPLE_PAGE_AREA_SIZE - 3) / ratio;
2665       h = EXAMPLE_PAGE_AREA_SIZE - 3;
2666     }
2667
2668   pages_per_sheet = dialog_get_pages_per_sheet (dialog);
2669   switch (pages_per_sheet)
2670     {
2671     default:
2672     case 1:
2673       pages_x = 1; pages_y = 1;
2674       break;
2675     case 2:
2676       landscape = !landscape;
2677       pages_x = 1; pages_y = 2;
2678       break;
2679     case 4:
2680       pages_x = 2; pages_y = 2;
2681       break;
2682     case 6:
2683       landscape = !landscape;
2684       pages_x = 2; pages_y = 3;
2685       break;
2686     case 9:
2687       pages_x = 3; pages_y = 3;
2688       break;
2689     case 16:
2690       pages_x = 4; pages_y = 4;
2691       break;
2692     }
2693
2694   if (landscape)
2695     {
2696       tmp = w;
2697       w = h;
2698       h = tmp;
2699
2700       tmp = pages_x;
2701       pages_x = pages_y;
2702       pages_y = tmp;
2703     }
2704
2705   context = gtk_widget_get_style_context (widget);
2706
2707   gtk_style_context_save (context);
2708   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
2709
2710   pos_x = (width - w) / 2;
2711   pos_y = (height - h) / 2 - 10;
2712   cairo_translate (cr, pos_x, pos_y);
2713
2714   shadow_offset = 3;
2715
2716   gtk_style_context_get_color (context, 0, &color);
2717   cairo_set_source_rgba (cr, color.red, color.green, color.blue, 0.5);
2718   cairo_rectangle (cr, shadow_offset + 1, shadow_offset + 1, w, h);
2719   cairo_fill (cr);
2720
2721   gtk_style_context_get_background_color (context, 0, &color);
2722   gdk_cairo_set_source_rgba (cr, &color);
2723   cairo_rectangle (cr, 1, 1, w, h);
2724   cairo_fill (cr);
2725   cairo_set_line_width (cr, 1.0);
2726   cairo_rectangle (cr, 0.5, 0.5, w + 1, h + 1);
2727
2728   gtk_style_context_get_color (context, 0, &color);
2729   gdk_cairo_set_source_rgba (cr, &color);
2730   cairo_stroke (cr);
2731
2732   i = 1;
2733
2734   page_width = (double)w / pages_x;
2735   page_height = (double)h / pages_y;
2736
2737   layout  = pango_cairo_create_layout (cr);
2738
2739   font = pango_font_description_new ();
2740   pango_font_description_set_family (font, "sans");
2741
2742   if (page_height > 0)
2743     pango_font_description_set_absolute_size (font, page_height * 0.4 * PANGO_SCALE);
2744   else
2745     pango_font_description_set_absolute_size (font, 1);
2746
2747   pango_layout_set_font_description (layout, font);
2748   pango_font_description_free (font);
2749
2750   pango_layout_set_width (layout, page_width * PANGO_SCALE);
2751   pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
2752
2753   switch (number_up_layout)
2754     {
2755       default:
2756       case GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM:
2757         start_x = 0;
2758         end_x = pages_x - 1;
2759         start_y = 0;
2760         end_y = pages_y - 1;
2761         dx = 1;
2762         dy = 1;
2763         horizontal = TRUE;
2764         break;
2765       case GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP:
2766         start_x = 0;
2767         end_x = pages_x - 1;
2768         start_y = pages_y - 1;
2769         end_y = 0;
2770         dx = 1;
2771         dy = - 1;
2772         horizontal = TRUE;
2773         break;
2774       case GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM:
2775         start_x = pages_x - 1;
2776         end_x = 0;
2777         start_y = 0;
2778         end_y = pages_y - 1;
2779         dx = - 1;
2780         dy = 1;
2781         horizontal = TRUE;
2782         break;
2783       case GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP:
2784         start_x = pages_x - 1;
2785         end_x = 0;
2786         start_y = pages_y - 1;
2787         end_y = 0;
2788         dx = - 1;
2789         dy = - 1;
2790         horizontal = TRUE;
2791         break;
2792       case GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT:
2793         start_x = 0;
2794         end_x = pages_x - 1;
2795         start_y = 0;
2796         end_y = pages_y - 1;
2797         dx = 1;
2798         dy = 1;
2799         horizontal = FALSE;
2800         break;
2801       case GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT:
2802         start_x = pages_x - 1;
2803         end_x = 0;
2804         start_y = 0;
2805         end_y = pages_y - 1;
2806         dx = - 1;
2807         dy = 1;
2808         horizontal = FALSE;
2809         break;
2810       case GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT:
2811         start_x = 0;
2812         end_x = pages_x - 1;
2813         start_y = pages_y - 1;
2814         end_y = 0;
2815         dx = 1;
2816         dy = - 1;
2817         horizontal = FALSE;
2818         break;
2819       case GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT:
2820         start_x = pages_x - 1;
2821         end_x = 0;
2822         start_y = pages_y - 1;
2823         end_y = 0;
2824         dx = - 1;
2825         dy = - 1;
2826         horizontal = FALSE;
2827         break;
2828     }
2829
2830   if (horizontal)
2831     for (y = start_y; y != end_y + dy; y += dy)
2832       {
2833         for (x = start_x; x != end_x + dx; x += dx)
2834           {
2835             text = g_strdup_printf ("%d", i++);
2836             pango_layout_set_text (layout, text, -1);
2837             g_free (text);
2838             pango_layout_get_size (layout, &layout_w, &layout_h);
2839             cairo_save (cr);
2840             cairo_translate (cr,
2841                              x * page_width,
2842                              y * page_height + (page_height - layout_h / 1024.0) / 2);
2843
2844             pango_cairo_show_layout (cr, layout);
2845             cairo_restore (cr);
2846           }
2847       }
2848   else
2849     for (x = start_x; x != end_x + dx; x += dx)
2850       {
2851         for (y = start_y; y != end_y + dy; y += dy)
2852           {
2853             text = g_strdup_printf ("%d", i++);
2854             pango_layout_set_text (layout, text, -1);
2855             g_free (text);
2856             pango_layout_get_size (layout, &layout_w, &layout_h);
2857             cairo_save (cr);
2858             cairo_translate (cr,
2859                              x * page_width,
2860                              y * page_height + (page_height - layout_h / 1024.0) / 2);
2861
2862             pango_cairo_show_layout (cr, layout);
2863             cairo_restore (cr);
2864           }
2865       }
2866
2867   g_object_unref (layout);
2868
2869   if (page_setup != NULL)
2870     {
2871       pos_x += 1;
2872       pos_y += 1;
2873
2874       if (pages_per_sheet == 2 || pages_per_sheet == 6)
2875         {
2876           paper_width = gtk_page_setup_get_paper_height (page_setup, _gtk_print_get_default_user_units ());
2877           paper_height = gtk_page_setup_get_paper_width (page_setup, _gtk_print_get_default_user_units ());
2878         }
2879       else
2880         {
2881           paper_width = gtk_page_setup_get_paper_width (page_setup, _gtk_print_get_default_user_units ());
2882           paper_height = gtk_page_setup_get_paper_height (page_setup, _gtk_print_get_default_user_units ());
2883         }
2884
2885       cairo_restore (cr);
2886       cairo_save (cr);
2887
2888       layout  = pango_cairo_create_layout (cr);
2889
2890       font = pango_font_description_new ();
2891       pango_font_description_set_family (font, "sans");
2892
2893       PangoContext *pango_c = NULL;
2894       PangoFontDescription *pango_f = NULL;
2895       gint font_size = 12 * PANGO_SCALE;
2896
2897       pango_c = gtk_widget_get_pango_context (widget);
2898       if (pango_c != NULL)
2899         {
2900           pango_f = pango_context_get_font_description (pango_c);
2901           if (pango_f != NULL)
2902             font_size = pango_font_description_get_size (pango_f);
2903         }
2904
2905       pango_font_description_set_size (font, font_size);
2906       pango_layout_set_font_description (layout, font);
2907       pango_font_description_free (font);
2908
2909       pango_layout_set_width (layout, -1);
2910       pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
2911
2912       if (_gtk_print_get_default_user_units () == GTK_UNIT_MM)
2913         text = g_strdup_printf ("%.1f mm", paper_height);
2914       else
2915         text = g_strdup_printf ("%.2f inch", paper_height);
2916
2917       pango_layout_set_text (layout, text, -1);
2918       g_free (text);
2919       pango_layout_get_size (layout, &layout_w, &layout_h);
2920
2921       ltr = gtk_widget_get_direction (GTK_WIDGET (dialog)) == GTK_TEXT_DIR_LTR;
2922
2923       if (ltr)
2924         cairo_translate (cr, pos_x - layout_w / PANGO_SCALE - 2 * RULER_DISTANCE,
2925                              (height - layout_h / PANGO_SCALE) / 2);
2926       else
2927         cairo_translate (cr, pos_x + w + shadow_offset + 2 * RULER_DISTANCE,
2928                              (height - layout_h / PANGO_SCALE) / 2);
2929
2930       pango_cairo_show_layout (cr, layout);
2931
2932       cairo_restore (cr);
2933       cairo_save (cr);
2934
2935       if (_gtk_print_get_default_user_units () == GTK_UNIT_MM)
2936         text = g_strdup_printf ("%.1f mm", paper_width);
2937       else
2938         text = g_strdup_printf ("%.2f inch", paper_width);
2939
2940       pango_layout_set_text (layout, text, -1);
2941       g_free (text);
2942       pango_layout_get_size (layout, &layout_w, &layout_h);
2943
2944       cairo_translate (cr, (width - layout_w / PANGO_SCALE) / 2,
2945                            pos_y + h + shadow_offset + 2 * RULER_DISTANCE);
2946
2947       pango_cairo_show_layout (cr, layout);
2948
2949       g_object_unref (layout);
2950
2951       cairo_restore (cr);
2952
2953       cairo_set_line_width (cr, 1);
2954
2955       if (ltr)
2956         {
2957           cairo_move_to (cr, pos_x - RULER_DISTANCE, pos_y);
2958           cairo_line_to (cr, pos_x - RULER_DISTANCE, pos_y + h);
2959           cairo_stroke (cr);
2960
2961           cairo_move_to (cr, pos_x - RULER_DISTANCE - RULER_RADIUS, pos_y - 0.5);
2962           cairo_line_to (cr, pos_x - RULER_DISTANCE + RULER_RADIUS, pos_y - 0.5);
2963           cairo_stroke (cr);
2964
2965           cairo_move_to (cr, pos_x - RULER_DISTANCE - RULER_RADIUS, pos_y + h + 0.5);
2966           cairo_line_to (cr, pos_x - RULER_DISTANCE + RULER_RADIUS, pos_y + h + 0.5);
2967           cairo_stroke (cr);
2968         }
2969       else
2970         {
2971           cairo_move_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE, pos_y);
2972           cairo_line_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE, pos_y + h);
2973           cairo_stroke (cr);
2974
2975           cairo_move_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE - RULER_RADIUS, pos_y - 0.5);
2976           cairo_line_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE + RULER_RADIUS, pos_y - 0.5);
2977           cairo_stroke (cr);
2978
2979           cairo_move_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE - RULER_RADIUS, pos_y + h + 0.5);
2980           cairo_line_to (cr, pos_x + w + shadow_offset + RULER_DISTANCE + RULER_RADIUS, pos_y + h + 0.5);
2981           cairo_stroke (cr);
2982         }
2983
2984       cairo_move_to (cr, pos_x, pos_y + h + shadow_offset + RULER_DISTANCE);
2985       cairo_line_to (cr, pos_x + w, pos_y + h + shadow_offset + RULER_DISTANCE);
2986       cairo_stroke (cr);
2987
2988       cairo_move_to (cr, pos_x - 0.5, pos_y + h + shadow_offset + RULER_DISTANCE - RULER_RADIUS);
2989       cairo_line_to (cr, pos_x - 0.5, pos_y + h + shadow_offset + RULER_DISTANCE + RULER_RADIUS);
2990       cairo_stroke (cr);
2991
2992       cairo_move_to (cr, pos_x + w + 0.5, pos_y + h + shadow_offset + RULER_DISTANCE - RULER_RADIUS);
2993       cairo_line_to (cr, pos_x + w + 0.5, pos_y + h + shadow_offset + RULER_DISTANCE + RULER_RADIUS);
2994       cairo_stroke (cr);
2995     }
2996
2997   gtk_style_context_restore (context);
2998
2999   return TRUE;
3000 }
3001
3002 static void
3003 redraw_page_layout_preview (GtkPrintUnixDialog *dialog)
3004 {
3005   GtkPrintUnixDialogPrivate *priv = dialog->priv;
3006
3007   if (priv->page_layout_preview)
3008     gtk_widget_queue_draw (priv->page_layout_preview);
3009 }
3010
3011 static void
3012 update_number_up_layout (GtkPrintUnixDialog *dialog)
3013 {
3014   GtkPrintUnixDialogPrivate *priv = dialog->priv;
3015   GtkPrintCapabilities       caps;
3016   GtkPrinterOptionSet       *set;
3017   GtkNumberUpLayout          layout;
3018   GtkPrinterOption          *option;
3019   GtkPrinterOption          *old_option;
3020   GtkPageOrientation         page_orientation;
3021
3022   set = priv->options;
3023
3024   caps = priv->manual_capabilities | priv->printer_capabilities;
3025
3026   if (caps & GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT)
3027     {
3028       if (priv->number_up_layout_n_option == NULL)
3029         {
3030           priv->number_up_layout_n_option = gtk_printer_option_set_lookup (set, "gtk-n-up-layout");
3031           if (priv->number_up_layout_n_option == NULL)
3032             {
3033               char *n_up_layout[] = { "lrtb", "lrbt", "rltb", "rlbt", "tblr", "tbrl", "btlr", "btrl" };
3034                /* Translators: These strings name the possible arrangements of
3035                 * multiple pages on a sheet when printing (same as in gtkprintbackendcups.c)
3036                 */
3037               char *n_up_layout_display[] = { N_("Left to right, top to bottom"), N_("Left to right, bottom to top"),
3038                                               N_("Right to left, top to bottom"), N_("Right to left, bottom to top"),
3039                                               N_("Top to bottom, left to right"), N_("Top to bottom, right to left"),
3040                                               N_("Bottom to top, left to right"), N_("Bottom to top, right to left") };
3041               int i;
3042
3043               priv->number_up_layout_n_option = gtk_printer_option_new ("gtk-n-up-layout",
3044                                                                         _("Page Ordering"),
3045                                                                         GTK_PRINTER_OPTION_TYPE_PICKONE);
3046               gtk_printer_option_allocate_choices (priv->number_up_layout_n_option, 8);
3047
3048               for (i = 0; i < G_N_ELEMENTS (n_up_layout_display); i++)
3049                 {
3050                   priv->number_up_layout_n_option->choices[i] = g_strdup (n_up_layout[i]);
3051                   priv->number_up_layout_n_option->choices_display[i] = g_strdup (_(n_up_layout_display[i]));
3052                 }
3053             }
3054           g_object_ref (priv->number_up_layout_n_option);
3055
3056           priv->number_up_layout_2_option = gtk_printer_option_new ("gtk-n-up-layout",
3057                                                                     _("Page Ordering"),
3058                                                                     GTK_PRINTER_OPTION_TYPE_PICKONE);
3059           gtk_printer_option_allocate_choices (priv->number_up_layout_2_option, 2);
3060         }
3061
3062       page_orientation = gtk_page_setup_get_orientation (priv->page_setup);
3063       if (page_orientation == GTK_PAGE_ORIENTATION_PORTRAIT ||
3064           page_orientation == GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT)
3065         {
3066           if (! (priv->number_up_layout_2_option->choices[0] == priv->number_up_layout_n_option->choices[0] &&
3067                  priv->number_up_layout_2_option->choices[1] == priv->number_up_layout_n_option->choices[2]))
3068             {
3069               g_free (priv->number_up_layout_2_option->choices_display[0]);
3070               g_free (priv->number_up_layout_2_option->choices_display[1]);
3071               priv->number_up_layout_2_option->choices[0] = priv->number_up_layout_n_option->choices[0];
3072               priv->number_up_layout_2_option->choices[1] = priv->number_up_layout_n_option->choices[2];
3073               priv->number_up_layout_2_option->choices_display[0] = g_strdup ( _("Left to right"));
3074               priv->number_up_layout_2_option->choices_display[1] = g_strdup ( _("Right to left"));
3075             }
3076         }
3077       else
3078         {
3079           if (! (priv->number_up_layout_2_option->choices[0] == priv->number_up_layout_n_option->choices[0] &&
3080                  priv->number_up_layout_2_option->choices[1] == priv->number_up_layout_n_option->choices[1]))
3081             {
3082               g_free (priv->number_up_layout_2_option->choices_display[0]);
3083               g_free (priv->number_up_layout_2_option->choices_display[1]);
3084               priv->number_up_layout_2_option->choices[0] = priv->number_up_layout_n_option->choices[0];
3085               priv->number_up_layout_2_option->choices[1] = priv->number_up_layout_n_option->choices[1];
3086               priv->number_up_layout_2_option->choices_display[0] = g_strdup ( _("Top to bottom"));
3087               priv->number_up_layout_2_option->choices_display[1] = g_strdup ( _("Bottom to top"));
3088             }
3089         }
3090
3091       layout = dialog_get_number_up_layout (dialog);
3092
3093       old_option = gtk_printer_option_set_lookup (set, "gtk-n-up-layout");
3094       if (old_option != NULL)
3095         gtk_printer_option_set_remove (set, old_option);
3096
3097       if (dialog_get_pages_per_sheet (dialog) != 1)
3098         {
3099           GEnumClass *enum_class;
3100           GEnumValue *enum_value;
3101           enum_class = g_type_class_ref (GTK_TYPE_NUMBER_UP_LAYOUT);
3102
3103           if (dialog_get_pages_per_sheet (dialog) == 2)
3104             {
3105               option = priv->number_up_layout_2_option;
3106
3107               switch (layout)
3108                 {
3109                 case GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM:
3110                 case GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT:
3111                   enum_value = g_enum_get_value (enum_class, GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM);
3112                   break;
3113
3114                 case GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP:
3115                 case GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT:
3116                   enum_value = g_enum_get_value (enum_class, GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP);
3117                   break;
3118
3119                 case GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM:
3120                 case GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT:
3121                   enum_value = g_enum_get_value (enum_class, GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM);
3122                   break;
3123
3124                 case GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP:
3125                 case GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT:
3126                   enum_value = g_enum_get_value (enum_class, GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP);
3127                   break;
3128
3129                 default:
3130                   g_assert_not_reached();
3131                   enum_value = NULL;
3132                 }
3133             }
3134           else
3135             {
3136               option = priv->number_up_layout_n_option;
3137
3138               enum_value = g_enum_get_value (enum_class, layout);
3139             }
3140
3141           g_assert (enum_value != NULL);
3142           gtk_printer_option_set (option, enum_value->value_nick);
3143           g_type_class_unref (enum_class);
3144
3145           gtk_printer_option_set_add (set, option);
3146         }
3147     }
3148
3149   setup_option (dialog, "gtk-n-up-layout", priv->number_up_layout);
3150
3151   if (priv->number_up_layout != NULL)
3152     gtk_widget_set_sensitive (GTK_WIDGET (priv->number_up_layout),
3153                               (caps & GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT) &&
3154                               (dialog_get_pages_per_sheet (dialog) > 1));
3155 }
3156
3157 static void
3158 custom_paper_dialog_response_cb (GtkDialog *custom_paper_dialog,
3159                                  gint       response_id,
3160                                  gpointer   user_data)
3161 {
3162   GtkPrintUnixDialog        *print_dialog = GTK_PRINT_UNIX_DIALOG (user_data);
3163   GtkPrintUnixDialogPrivate *priv = print_dialog->priv;
3164   GtkTreeModel              *model;
3165   GtkTreeIter                iter;
3166
3167   _gtk_print_load_custom_papers (priv->custom_paper_list);
3168
3169   priv->internal_page_setup_change = TRUE;
3170   update_paper_sizes (print_dialog);
3171   priv->internal_page_setup_change = FALSE;
3172
3173   if (priv->page_setup_set)
3174     {
3175       model = GTK_TREE_MODEL (priv->custom_paper_list);
3176       if (gtk_tree_model_get_iter_first (model, &iter))
3177         {
3178           do
3179             {
3180               GtkPageSetup *page_setup;
3181               gtk_tree_model_get (model, &iter, 0, &page_setup, -1);
3182
3183               if (page_setup &&
3184                   g_strcmp0 (gtk_paper_size_get_display_name (gtk_page_setup_get_paper_size (page_setup)),
3185                              gtk_paper_size_get_display_name (gtk_page_setup_get_paper_size (priv->page_setup))) == 0)
3186                 gtk_print_unix_dialog_set_page_setup (print_dialog, page_setup);
3187
3188               g_object_unref (page_setup);
3189             } while (gtk_tree_model_iter_next (model, &iter));
3190         }
3191     }
3192
3193   gtk_widget_destroy (GTK_WIDGET (custom_paper_dialog));
3194 }
3195
3196 static void
3197 orientation_changed (GtkComboBox        *combo_box,
3198                      GtkPrintUnixDialog *dialog)
3199 {
3200   GtkPrintUnixDialogPrivate *priv = dialog->priv;
3201   GtkPageOrientation         orientation;
3202   GtkPageSetup              *page_setup;
3203
3204   if (priv->internal_page_setup_change)
3205     return;
3206
3207   orientation = (GtkPageOrientation) gtk_combo_box_get_active (GTK_COMBO_BOX (priv->orientation_combo));
3208
3209   if (priv->page_setup)
3210     {
3211       page_setup = gtk_page_setup_copy (priv->page_setup);
3212       if (page_setup)
3213         gtk_page_setup_set_orientation (page_setup, orientation);
3214
3215       gtk_print_unix_dialog_set_page_setup (dialog, page_setup);
3216     }
3217
3218   redraw_page_layout_preview (dialog);
3219 }
3220
3221 static void
3222 paper_size_changed (GtkComboBox        *combo_box,
3223                     GtkPrintUnixDialog *dialog)
3224 {
3225   GtkPrintUnixDialogPrivate *priv = dialog->priv;
3226   GtkTreeIter iter;
3227   GtkPageSetup *page_setup, *last_page_setup;
3228   GtkPageOrientation orientation;
3229
3230   if (priv->internal_page_setup_change)
3231     return;
3232
3233   if (gtk_combo_box_get_active_iter (combo_box, &iter))
3234     {
3235       gtk_tree_model_get (gtk_combo_box_get_model (combo_box),
3236                           &iter, PAGE_SETUP_LIST_COL_PAGE_SETUP, &page_setup, -1);
3237
3238       if (page_setup == NULL)
3239         {
3240           GtkWidget *custom_paper_dialog;
3241
3242           /* Change from "manage" menu item to last value */
3243           if (priv->page_setup)
3244             last_page_setup = g_object_ref (priv->page_setup);
3245           else
3246             last_page_setup = gtk_page_setup_new (); /* "good" default */
3247
3248           if (!set_paper_size (dialog, last_page_setup, FALSE, FALSE))
3249             set_paper_size (dialog, last_page_setup, TRUE, TRUE);
3250           g_object_unref (last_page_setup);
3251
3252           /* And show the custom paper dialog */
3253           custom_paper_dialog = _gtk_custom_paper_unix_dialog_new (GTK_WINDOW (dialog), _("Manage Custom Sizes"));
3254           g_signal_connect (custom_paper_dialog, "response", G_CALLBACK (custom_paper_dialog_response_cb), dialog);
3255           gtk_window_present (GTK_WINDOW (custom_paper_dialog));
3256
3257           return;
3258         }
3259
3260       if (priv->page_setup)
3261         orientation = gtk_page_setup_get_orientation (priv->page_setup);
3262       else
3263         orientation = GTK_PAGE_ORIENTATION_PORTRAIT;
3264
3265       gtk_page_setup_set_orientation (page_setup, orientation);
3266       gtk_print_unix_dialog_set_page_setup (dialog, page_setup);
3267
3268       g_object_unref (page_setup);
3269     }
3270
3271   redraw_page_layout_preview (dialog);
3272 }
3273
3274 static gboolean
3275 paper_size_row_is_separator (GtkTreeModel *model,
3276                              GtkTreeIter  *iter,
3277                              gpointer      data)
3278 {
3279   gboolean separator;
3280
3281   gtk_tree_model_get (model, iter, PAGE_SETUP_LIST_COL_IS_SEPARATOR, &separator, -1);
3282   return separator;
3283 }
3284
3285 static void
3286 page_name_func (GtkCellLayout   *cell_layout,
3287                 GtkCellRenderer *cell,
3288                 GtkTreeModel    *tree_model,
3289                 GtkTreeIter     *iter,
3290                 gpointer         data)
3291 {
3292   GtkPageSetup *page_setup;
3293   GtkPaperSize *paper_size;
3294
3295   gtk_tree_model_get (tree_model, iter,
3296                       PAGE_SETUP_LIST_COL_PAGE_SETUP, &page_setup, -1);
3297   if (page_setup)
3298     {
3299       paper_size = gtk_page_setup_get_paper_size (page_setup);
3300       g_object_set (cell, "text",  gtk_paper_size_get_display_name (paper_size), NULL);
3301       g_object_unref (page_setup);
3302     }
3303   else
3304     g_object_set (cell, "text",  _("Manage Custom Sizes..."), NULL);
3305 }
3306
3307 static void
3308 create_page_setup_page (GtkPrintUnixDialog *dialog)
3309 {
3310   GtkPrintUnixDialogPrivate *priv = dialog->priv;
3311   GtkWidget *main_vbox, *label, *hbox, *hbox2;
3312   GtkWidget *frame, *table, *widget;
3313   GtkWidget *combo, *spinbutton, *draw;
3314   GtkCellRenderer *cell;
3315
3316   main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
3317   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
3318   gtk_widget_show (main_vbox);
3319
3320   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 18);
3321   gtk_widget_show (hbox);
3322   gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
3323
3324   table = gtk_table_new (5, 2, FALSE);
3325   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3326   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3327   frame = wrap_in_frame (_("Layout"), table);
3328   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
3329   gtk_widget_show (table);
3330
3331   label = gtk_label_new_with_mnemonic (_("T_wo-sided:"));
3332   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3333   gtk_widget_show (label);
3334   gtk_table_attach (GTK_TABLE (table), label,
3335                     0, 1, 0, 1,  GTK_FILL, 0,
3336                     0, 0);
3337
3338   widget = gtk_printer_option_widget_new (NULL);
3339   priv->duplex = GTK_PRINTER_OPTION_WIDGET (widget);
3340   gtk_widget_show (widget);
3341   gtk_table_attach (GTK_TABLE (table), widget,
3342                     1, 2, 0, 1,  GTK_FILL, 0,
3343                     0, 0);
3344   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3345
3346   label = gtk_label_new_with_mnemonic (_("Pages per _side:"));
3347   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3348   gtk_widget_show (label);
3349   gtk_table_attach (GTK_TABLE (table), label,
3350                     0, 1, 1, 2,  GTK_FILL, 0,
3351                     0, 0);
3352
3353   widget = gtk_printer_option_widget_new (NULL);
3354   g_signal_connect_swapped (widget, "changed", G_CALLBACK (redraw_page_layout_preview), dialog);
3355   g_signal_connect_swapped (widget, "changed", G_CALLBACK (update_number_up_layout), dialog);
3356   priv->pages_per_sheet = GTK_PRINTER_OPTION_WIDGET (widget);
3357   gtk_widget_show (widget);
3358   gtk_table_attach (GTK_TABLE (table), widget,
3359                     1, 2, 1, 2,  GTK_FILL, 0,
3360                     0, 0);
3361   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3362
3363   label = gtk_label_new_with_mnemonic (_("Page or_dering:"));
3364   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3365   gtk_widget_show (label);
3366   gtk_table_attach (GTK_TABLE (table), label,
3367                     0, 1, 2, 3,  GTK_FILL, 0,
3368                     0, 0);
3369
3370   widget = gtk_printer_option_widget_new (NULL);
3371   g_signal_connect_swapped (widget, "changed", G_CALLBACK (redraw_page_layout_preview), dialog);
3372   priv->number_up_layout = GTK_PRINTER_OPTION_WIDGET (widget);
3373   gtk_widget_show (widget);
3374   gtk_table_attach (GTK_TABLE (table), widget,
3375                     1, 2, 2, 3,  GTK_FILL, 0,
3376                     0, 0);
3377   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3378
3379   label = gtk_label_new_with_mnemonic (_("_Only print:"));
3380   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3381   gtk_widget_show (label);
3382   gtk_table_attach (GTK_TABLE (table), label,
3383                     0, 1, 3, 4,  GTK_FILL, 0,
3384                     0, 0);
3385
3386   combo = gtk_combo_box_text_new ();
3387   priv->page_set_combo = combo;
3388   gtk_widget_show (combo);
3389   gtk_table_attach (GTK_TABLE (table), combo,
3390                     1, 2, 3, 4,  GTK_FILL, 0,
3391                     0, 0);
3392   gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
3393   /* In enum order */
3394   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("All sheets"));
3395   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("Even sheets"));
3396   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("Odd sheets"));
3397   gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
3398
3399   label = gtk_label_new_with_mnemonic (_("Sc_ale:"));
3400   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3401   gtk_widget_show (label);
3402   gtk_table_attach (GTK_TABLE (table), label,
3403                     0, 1, 4, 5,  GTK_FILL, 0,
3404                     0, 0);
3405
3406   hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
3407   gtk_widget_show (hbox2);
3408   gtk_table_attach (GTK_TABLE (table), hbox2,
3409                     1, 2, 4, 5,  GTK_FILL, 0,
3410                     0, 0);
3411
3412   spinbutton = gtk_spin_button_new_with_range (1.0, 1000.0, 1.0);
3413   priv->scale_spin = spinbutton;
3414   gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinbutton), 1);
3415   gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinbutton), 100.0);
3416   gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0);
3417   gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
3418   gtk_widget_show (spinbutton);
3419   label = gtk_label_new ("%"); /* FIXMEchpe does there exist any language where % needs to be translated? */
3420   gtk_widget_show (label);
3421   gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
3422
3423   table = gtk_table_new (4, 2, FALSE);
3424   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3425   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3426   frame = wrap_in_frame (_("Paper"), table);
3427   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 6);
3428   gtk_widget_show (table);
3429
3430   label = gtk_label_new_with_mnemonic (_("Paper _type:"));
3431   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3432   gtk_widget_show (label);
3433   gtk_table_attach (GTK_TABLE (table), label,
3434                     0, 1, 0, 1,  GTK_FILL, 0,
3435                     0, 0);
3436
3437   widget = gtk_printer_option_widget_new (NULL);
3438   priv->paper_type = GTK_PRINTER_OPTION_WIDGET (widget);
3439   gtk_widget_show (widget);
3440   gtk_table_attach (GTK_TABLE (table), widget,
3441                     1, 2, 0, 1,  GTK_FILL, 0,
3442                     0, 0);
3443   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3444
3445   label = gtk_label_new_with_mnemonic (_("Paper _source:"));
3446   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3447   gtk_widget_show (label);
3448   gtk_table_attach (GTK_TABLE (table), label,
3449                     0, 1, 1, 2,  GTK_FILL, 0,
3450                     0, 0);
3451
3452   widget = gtk_printer_option_widget_new (NULL);
3453   priv->paper_source = GTK_PRINTER_OPTION_WIDGET (widget);
3454   gtk_widget_show (widget);
3455   gtk_table_attach (GTK_TABLE (table), widget,
3456                     1, 2, 1, 2,  GTK_FILL, 0,
3457                     0, 0);
3458   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3459
3460   label = gtk_label_new_with_mnemonic (_("Output t_ray:"));
3461   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3462   gtk_widget_show (label);
3463   gtk_table_attach (GTK_TABLE (table), label,
3464                     0, 1, 2, 3,  GTK_FILL, 0,
3465                     0, 0);
3466
3467   widget = gtk_printer_option_widget_new (NULL);
3468   priv->output_tray = GTK_PRINTER_OPTION_WIDGET (widget);
3469   gtk_widget_show (widget);
3470   gtk_table_attach (GTK_TABLE (table), widget,
3471                     1, 2, 2, 3,  GTK_FILL, 0,
3472                     0, 0);
3473   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3474
3475
3476   label = gtk_label_new_with_mnemonic (_("_Paper size:"));
3477   priv->paper_size_combo_label = GTK_WIDGET (label);
3478   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3479   gtk_widget_show (label);
3480   gtk_table_attach (GTK_TABLE (table), label,
3481                     0, 1, 3, 4,  GTK_FILL, 0,
3482                     0, 0);
3483
3484   combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->page_setup_list));
3485   priv->paper_size_combo = GTK_WIDGET (combo);
3486   gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo),
3487                                         paper_size_row_is_separator, NULL, NULL);
3488   cell = gtk_cell_renderer_text_new ();
3489   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
3490   gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell,
3491                                       page_name_func, NULL, NULL);
3492   gtk_table_attach (GTK_TABLE (table), combo,
3493                     1, 2, 3, 4,  GTK_FILL, 0,
3494                     0, 0);
3495   gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
3496   gtk_widget_set_sensitive (combo, FALSE);
3497   gtk_widget_show (combo);
3498
3499
3500   label = gtk_label_new_with_mnemonic (_("Or_ientation:"));
3501   priv->orientation_combo_label = GTK_WIDGET (label);
3502   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3503   gtk_widget_show (label);
3504   gtk_table_attach (GTK_TABLE (table), label,
3505                     0, 1, 4, 5,
3506                     GTK_FILL, 0, 0, 0);
3507
3508   combo = gtk_combo_box_text_new ();
3509   priv->orientation_combo = GTK_WIDGET (combo);
3510   gtk_table_attach (GTK_TABLE (table), combo,
3511                     1, 2, 4, 5,  GTK_FILL, 0,
3512                     0, 0);
3513   gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
3514   /* In enum order */
3515   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("Portrait"));
3516   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("Landscape"));
3517   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("Reverse portrait"));
3518   gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _("Reverse landscape"));
3519   gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
3520   gtk_widget_set_sensitive (combo, FALSE);
3521   gtk_widget_show (combo);
3522
3523
3524   /* Add the page layout preview */
3525   hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
3526   gtk_widget_show (hbox2);
3527   gtk_box_pack_start (GTK_BOX (main_vbox), hbox2, TRUE, TRUE, 0);
3528
3529   draw = gtk_drawing_area_new ();
3530   gtk_widget_set_has_window (draw, FALSE);
3531   priv->page_layout_preview = draw;
3532   gtk_widget_set_size_request (draw, 280, 160);
3533   g_signal_connect (draw, "draw", G_CALLBACK (draw_page_cb), dialog);
3534   gtk_widget_show (draw);
3535
3536   gtk_box_pack_start (GTK_BOX (hbox2), draw, TRUE, FALSE, 0);
3537
3538   label = gtk_label_new (_("Page Setup"));
3539   gtk_widget_show (label);
3540
3541   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
3542                             main_vbox, label);
3543 }
3544
3545 static void
3546 create_job_page (GtkPrintUnixDialog *dialog)
3547 {
3548   GtkPrintUnixDialogPrivate *priv = dialog->priv;
3549   GtkWidget *main_table, *label;
3550   GtkWidget *frame, *table, *radio;
3551   GtkWidget *entry, *widget;
3552   const gchar *at_tooltip;
3553   const gchar *on_hold_tooltip;
3554
3555   main_table = gtk_table_new (2, 2, FALSE);
3556   gtk_container_set_border_width (GTK_CONTAINER (main_table), 12);
3557   gtk_table_set_row_spacings (GTK_TABLE (main_table), 18);
3558   gtk_table_set_col_spacings (GTK_TABLE (main_table), 18);
3559
3560   table = gtk_table_new (2, 2, FALSE);
3561   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3562   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3563   frame = wrap_in_frame (_("Job Details"), table);
3564   gtk_table_attach (GTK_TABLE (main_table), frame,
3565                     0, 1, 0, 1,  GTK_FILL, 0,
3566                     0, 0);
3567   gtk_widget_show (table);
3568
3569   label = gtk_label_new_with_mnemonic (_("Pri_ority:"));
3570   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3571   gtk_widget_show (label);
3572   gtk_table_attach (GTK_TABLE (table), label,
3573                     0, 1, 0, 1,  GTK_FILL, 0,
3574                     0, 0);
3575
3576   widget = gtk_printer_option_widget_new (NULL);
3577   priv->job_prio = GTK_PRINTER_OPTION_WIDGET (widget);
3578   gtk_widget_show (widget);
3579   gtk_table_attach (GTK_TABLE (table), widget,
3580                     1, 2, 0, 1,  GTK_FILL, 0,
3581                     0, 0);
3582   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3583
3584   label = gtk_label_new_with_mnemonic (_("_Billing info:"));
3585   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3586   gtk_widget_show (label);
3587   gtk_table_attach (GTK_TABLE (table), label,
3588                     0, 1, 1, 2,  GTK_FILL, 0,
3589                     0, 0);
3590
3591   widget = gtk_printer_option_widget_new (NULL);
3592   priv->billing_info = GTK_PRINTER_OPTION_WIDGET (widget);
3593   gtk_widget_show (widget);
3594   gtk_table_attach (GTK_TABLE (table), widget,
3595                     1, 2, 1, 2,  GTK_FILL, 0,
3596                     0, 0);
3597   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3598
3599   table = gtk_table_new (2, 2, FALSE);
3600   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3601   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3602   frame = wrap_in_frame (_("Print Document"), table);
3603   gtk_table_attach (GTK_TABLE (main_table), frame,
3604                     0, 1, 1, 2,  GTK_FILL, 0,
3605                     0, 0);
3606   gtk_widget_show (table);
3607
3608   /* Translators: this is one of the choices for the print at option
3609    * in the print dialog
3610    */
3611   radio = gtk_radio_button_new_with_mnemonic (NULL, _("_Now"));
3612   priv->print_now_radio = radio;
3613   gtk_widget_show (radio);
3614   gtk_table_attach (GTK_TABLE (table), radio,
3615                     0, 2, 0, 1,  GTK_FILL, 0,
3616                     0, 0);
3617   /* Translators: this is one of the choices for the print at option
3618    * in the print dialog. It also serves as the label for an entry that
3619    * allows the user to enter a time.
3620    */
3621   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
3622                                               _("A_t:"));
3623
3624   /* Translators: Ability to parse the am/pm format depends on actual locale.
3625    * You can remove the am/pm values below for your locale if they are not
3626    * supported.
3627    */
3628   at_tooltip = _("Specify the time of print,\n e.g. 15:30, 2:35 pm, 14:15:20, 11:46:30 am, 4 pm");
3629   gtk_widget_set_tooltip_text (radio, at_tooltip);
3630   priv->print_at_radio = radio;
3631   gtk_widget_show (radio);
3632   gtk_table_attach (GTK_TABLE (table), radio,
3633                     0, 1, 1, 2,  GTK_FILL, 0,
3634                     0, 0);
3635
3636   entry = gtk_entry_new ();
3637   gtk_widget_set_tooltip_text (entry, at_tooltip);
3638   atk_object_set_name (gtk_widget_get_accessible (entry), _("Time of print"));
3639   atk_object_set_description (gtk_widget_get_accessible (entry), at_tooltip);
3640   priv->print_at_entry = entry;
3641   gtk_widget_show (entry);
3642   gtk_table_attach (GTK_TABLE (table), entry,
3643                     1, 2, 1, 2,  GTK_FILL, 0,
3644                     0, 0);
3645
3646   g_signal_connect (radio, "toggled", G_CALLBACK (update_entry_sensitivity), entry);
3647   update_entry_sensitivity (radio, entry);
3648
3649   /* Translators: this is one of the choices for the print at option
3650    * in the print dialog. It means that the print job will not be
3651    * printed until it explicitly gets 'released'.
3652    */
3653   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
3654                                               _("On _hold"));
3655   on_hold_tooltip = _("Hold the job until it is explicitly released");
3656   gtk_widget_set_tooltip_text (radio, on_hold_tooltip);
3657   priv->print_hold_radio = radio;
3658   gtk_widget_show (radio);
3659   gtk_table_attach (GTK_TABLE (table), radio,
3660                     0, 2, 2, 3,  GTK_FILL, 0,
3661                     0, 0);
3662
3663   g_signal_connect_swapped (priv->print_now_radio, "toggled",
3664                             G_CALLBACK (update_print_at_option), dialog);
3665   g_signal_connect_swapped (priv->print_at_radio, "toggled",
3666                             G_CALLBACK (update_print_at_option), dialog);
3667   g_signal_connect_swapped (priv->print_at_entry, "changed",
3668                             G_CALLBACK (update_print_at_option), dialog);
3669   g_signal_connect_swapped (priv->print_hold_radio, "toggled",
3670                             G_CALLBACK (update_print_at_option), dialog);
3671
3672   table = gtk_table_new (2, 2, FALSE);
3673   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3674   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3675   frame = wrap_in_frame (_("Add Cover Page"), table);
3676   gtk_table_attach (GTK_TABLE (main_table), frame,
3677                     1, 2, 0, 1,  GTK_FILL, 0,
3678                     0, 0);
3679   gtk_widget_show (table);
3680
3681   /* Translators, this is the label used for the option in the print
3682    * dialog that controls the front cover page.
3683    */
3684   label = gtk_label_new_with_mnemonic (_("Be_fore:"));
3685   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3686   gtk_widget_show (label);
3687   gtk_table_attach (GTK_TABLE (table), label,
3688                     0, 1, 0, 1,  GTK_FILL, 0,
3689                     0, 0);
3690
3691   widget = gtk_printer_option_widget_new (NULL);
3692   priv->cover_before = GTK_PRINTER_OPTION_WIDGET (widget);
3693   gtk_widget_show (widget);
3694   gtk_table_attach (GTK_TABLE (table), widget,
3695                     1, 2, 0, 1,  GTK_FILL, 0,
3696                     0, 0);
3697   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3698
3699   /* Translators, this is the label used for the option in the print
3700    * dialog that controls the back cover page.
3701    */
3702   label = gtk_label_new_with_mnemonic (_("_After:"));
3703   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
3704   gtk_widget_show (label);
3705   gtk_table_attach (GTK_TABLE (table), label,
3706                     0, 1, 1, 2,  GTK_FILL, 0,
3707                     0, 0);
3708
3709   widget = gtk_printer_option_widget_new (NULL);
3710   priv->cover_after = GTK_PRINTER_OPTION_WIDGET (widget);
3711   gtk_widget_show (widget);
3712   gtk_table_attach (GTK_TABLE (table), widget,
3713                     1, 2, 1, 2,  GTK_FILL, 0,
3714                     0, 0);
3715   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
3716
3717   /* Translators: this is the tab label for the notebook tab containing
3718    * job-specific options in the print dialog
3719    */
3720   label = gtk_label_new (_("Job"));
3721   gtk_widget_show (label);
3722
3723   priv->job_page = main_table;
3724   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
3725                             main_table, label);
3726 }
3727
3728 static void
3729 create_optional_page (GtkPrintUnixDialog  *dialog,
3730                       const gchar         *text,
3731                       GtkWidget          **table_out,
3732                       GtkWidget          **page_out)
3733 {
3734   GtkPrintUnixDialogPrivate *priv = dialog->priv;
3735   GtkWidget *table, *label, *scrolled;
3736
3737   scrolled = gtk_scrolled_window_new (NULL, NULL);
3738   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
3739                                   GTK_POLICY_NEVER,
3740                                   GTK_POLICY_AUTOMATIC);
3741
3742   table = gtk_table_new (1, 2, FALSE);
3743   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
3744   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
3745   gtk_container_set_border_width (GTK_CONTAINER (table), 12);
3746   gtk_widget_show (table);
3747
3748   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
3749                                          table);
3750   gtk_viewport_set_shadow_type (GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (scrolled))),
3751                                 GTK_SHADOW_NONE);
3752
3753   label = gtk_label_new (text);
3754   gtk_widget_show (label);
3755
3756   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
3757                             scrolled, label);
3758
3759   *table_out = table;
3760   *page_out = scrolled;
3761 }
3762
3763 static void
3764 create_advanced_page (GtkPrintUnixDialog *dialog)
3765 {
3766   GtkPrintUnixDialogPrivate *priv = dialog->priv;
3767   GtkWidget *main_vbox, *label, *scrolled;
3768
3769   scrolled = gtk_scrolled_window_new (NULL, NULL);
3770   priv->advanced_page = scrolled;
3771   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
3772                                   GTK_POLICY_NEVER,
3773                                   GTK_POLICY_AUTOMATIC);
3774
3775   main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
3776   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
3777   gtk_widget_show (main_vbox);
3778
3779   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
3780                                          main_vbox);
3781   gtk_viewport_set_shadow_type (GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (scrolled))),
3782                                 GTK_SHADOW_NONE);
3783
3784   priv->advanced_vbox = main_vbox;
3785
3786   label = gtk_label_new (_("Advanced"));
3787   gtk_widget_show (label);
3788
3789   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
3790                             scrolled, label);
3791 }
3792
3793 static void
3794 populate_dialog (GtkPrintUnixDialog *print_dialog)
3795 {
3796   GtkPrintUnixDialogPrivate *priv = print_dialog->priv;
3797   GtkDialog *dialog = GTK_DIALOG (print_dialog);
3798   GtkWidget *vbox, *conflict_hbox, *image, *label;
3799   GtkWidget *action_area, *content_area;
3800
3801   content_area = gtk_dialog_get_content_area (dialog);
3802   action_area = gtk_dialog_get_action_area (dialog);
3803
3804   gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
3805   gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */
3806   gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
3807   gtk_box_set_spacing (GTK_BOX (action_area), 6);
3808
3809   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
3810   gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
3811   gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
3812   gtk_widget_show (vbox);
3813
3814   priv->notebook = gtk_notebook_new ();
3815   gtk_box_pack_start (GTK_BOX (vbox), priv->notebook, TRUE, TRUE, 0);
3816   gtk_widget_show (priv->notebook);
3817
3818   create_printer_list_model (print_dialog);
3819
3820   create_main_page (print_dialog);
3821   create_page_setup_page (print_dialog);
3822   create_job_page (print_dialog);
3823   /* Translators: this will appear as tab label in print dialog. */
3824   create_optional_page (print_dialog, _("Image Quality"),
3825                         &priv->image_quality_table,
3826                         &priv->image_quality_page);
3827   /* Translators: this will appear as tab label in print dialog. */
3828   create_optional_page (print_dialog, _("Color"),
3829                         &priv->color_table,
3830                         &priv->color_page);
3831   /* Translators: this will appear as tab label in print dialog. */
3832   /* It's a typographical term, as in "Binding and finishing" */
3833   create_optional_page (print_dialog, _("Finishing"),
3834                         &priv->finishing_table,
3835                         &priv->finishing_page);
3836   create_advanced_page (print_dialog);
3837
3838   priv->conflicts_widget = conflict_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
3839   gtk_box_pack_end (GTK_BOX (vbox), conflict_hbox, FALSE, FALSE, 0);
3840   image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU);
3841   gtk_widget_show (image);
3842   gtk_box_pack_start (GTK_BOX (conflict_hbox), image, FALSE, TRUE, 0);
3843   label = gtk_label_new (_("Some of the settings in the dialog conflict"));
3844   gtk_widget_show (label);
3845   gtk_box_pack_start (GTK_BOX (conflict_hbox), label, FALSE, TRUE, 0);
3846
3847   load_print_backends (print_dialog);
3848 }
3849
3850 /**
3851  * gtk_print_unix_dialog_new:
3852  * @title: (allow-none): Title of the dialog, or %NULL
3853  * @parent: (allow-none): Transient parent of the dialog, or %NULL
3854  *
3855  * Creates a new #GtkPrintUnixDialog.
3856  *
3857  * Return value: a new #GtkPrintUnixDialog
3858  *
3859  * Since: 2.10
3860  **/
3861 GtkWidget *
3862 gtk_print_unix_dialog_new (const gchar *title,
3863                            GtkWindow   *parent)
3864 {
3865   GtkWidget *result;
3866   const gchar *_title = _("Print");
3867
3868   if (title)
3869     _title = title;
3870
3871   result = g_object_new (GTK_TYPE_PRINT_UNIX_DIALOG,
3872                          "transient-for", parent,
3873                          "title", _title,
3874                          NULL);
3875
3876   return result;
3877 }
3878
3879 /**
3880  * gtk_print_unix_dialog_get_selected_printer:
3881  * @dialog: a #GtkPrintUnixDialog
3882  *
3883  * Gets the currently selected printer.
3884  *
3885  * Returns: (transfer none): the currently selected printer
3886  *
3887  * Since: 2.10
3888  */
3889 GtkPrinter *
3890 gtk_print_unix_dialog_get_selected_printer (GtkPrintUnixDialog *dialog)
3891 {
3892   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
3893
3894   return dialog->priv->current_printer;
3895 }
3896
3897 /**
3898  * gtk_print_unix_dialog_set_page_setup:
3899  * @dialog: a #GtkPrintUnixDialog
3900  * @page_setup: a #GtkPageSetup
3901  *
3902  * Sets the page setup of the #GtkPrintUnixDialog.
3903  *
3904  * Since: 2.10
3905  */
3906 void
3907 gtk_print_unix_dialog_set_page_setup (GtkPrintUnixDialog *dialog,
3908                                       GtkPageSetup       *page_setup)
3909 {
3910   GtkPrintUnixDialogPrivate *priv;
3911
3912   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
3913   g_return_if_fail (GTK_IS_PAGE_SETUP (page_setup));
3914
3915   priv = dialog->priv;
3916
3917   if (priv->page_setup != page_setup)
3918     {
3919       g_object_unref (priv->page_setup);
3920       priv->page_setup = g_object_ref (page_setup);
3921
3922       priv->page_setup_set = TRUE;
3923
3924       g_object_notify (G_OBJECT (dialog), "page-setup");
3925     }
3926 }
3927
3928 /**
3929  * gtk_print_unix_dialog_get_page_setup:
3930  * @dialog: a #GtkPrintUnixDialog
3931  *
3932  * Gets the page setup that is used by the #GtkPrintUnixDialog.
3933  *
3934  * Returns: (transfer none): the page setup of @dialog.
3935  *
3936  * Since: 2.10
3937  */
3938 GtkPageSetup *
3939 gtk_print_unix_dialog_get_page_setup (GtkPrintUnixDialog *dialog)
3940 {
3941   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
3942
3943   return dialog->priv->page_setup;
3944 }
3945
3946 /**
3947  * gtk_print_unix_dialog_get_page_setup_set:
3948  * @dialog: a #GtkPrintUnixDialog
3949  *
3950  * Gets the page setup that is used by the #GtkPrintUnixDialog.
3951  *
3952  * Returns: whether a page setup was set by user.
3953  *
3954  * Since: 2.18
3955  */
3956 gboolean
3957 gtk_print_unix_dialog_get_page_setup_set (GtkPrintUnixDialog *dialog)
3958 {
3959   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
3960
3961   return dialog->priv->page_setup_set;
3962 }
3963
3964 /**
3965  * gtk_print_unix_dialog_set_current_page:
3966  * @dialog: a #GtkPrintUnixDialog
3967  * @current_page: the current page number.
3968  *
3969  * Sets the current page number. If @current_page is not -1, this enables
3970  * the current page choice for the range of pages to print.
3971  *
3972  * Since: 2.10
3973  */
3974 void
3975 gtk_print_unix_dialog_set_current_page (GtkPrintUnixDialog *dialog,
3976                                         gint                current_page)
3977 {
3978   GtkPrintUnixDialogPrivate *priv;
3979
3980   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
3981
3982   priv = dialog->priv;
3983
3984   if (priv->current_page != current_page)
3985     {
3986       priv->current_page = current_page;
3987
3988       if (priv->current_page_radio)
3989         gtk_widget_set_sensitive (priv->current_page_radio, current_page != -1);
3990
3991       g_object_notify (G_OBJECT (dialog), "current-page");
3992     }
3993 }
3994
3995 /**
3996  * gtk_print_unix_dialog_get_current_page:
3997  * @dialog: a #GtkPrintUnixDialog
3998  *
3999  * Gets the current page of the #GtkPrintDialog.
4000  *
4001  * Returns: the current page of @dialog
4002  *
4003  * Since: 2.10
4004  */
4005 gint
4006 gtk_print_unix_dialog_get_current_page (GtkPrintUnixDialog *dialog)
4007 {
4008   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), -1);
4009
4010   return dialog->priv->current_page;
4011 }
4012
4013 static gboolean
4014 set_active_printer (GtkPrintUnixDialog *dialog,
4015                     const gchar        *printer_name)
4016 {
4017   GtkPrintUnixDialogPrivate *priv = dialog->priv;
4018   GtkTreeModel *model;
4019   GtkTreeIter iter, filter_iter;
4020   GtkTreeSelection *selection;
4021   GtkPrinter *printer;
4022
4023   model = GTK_TREE_MODEL (priv->printer_list);
4024
4025   if (gtk_tree_model_get_iter_first (model, &iter))
4026     {
4027       do
4028         {
4029           gtk_tree_model_get (GTK_TREE_MODEL (priv->printer_list), &iter,
4030                               PRINTER_LIST_COL_PRINTER_OBJ, &printer, -1);
4031           if (printer == NULL)
4032             continue;
4033
4034           if (strcmp (gtk_printer_get_name (printer), printer_name) == 0)
4035             {
4036               gtk_tree_model_filter_convert_child_iter_to_iter (priv->printer_list_filter,
4037                                                                 &filter_iter, &iter);
4038
4039               selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
4040               priv->internal_printer_change = TRUE;
4041               gtk_tree_selection_select_iter (selection, &filter_iter);
4042               priv->internal_printer_change = FALSE;
4043               g_free (priv->waiting_for_printer);
4044               priv->waiting_for_printer = NULL;
4045
4046               g_object_unref (printer);
4047               return TRUE;
4048             }
4049
4050           g_object_unref (printer);
4051
4052         } while (gtk_tree_model_iter_next (model, &iter));
4053     }
4054
4055   return FALSE;
4056 }
4057
4058 /**
4059  * gtk_print_unix_dialog_set_settings:
4060  * @dialog: a #GtkPrintUnixDialog
4061  * @settings: (allow-none): a #GtkPrintSettings, or %NULL
4062  *
4063  * Sets the #GtkPrintSettings for the #GtkPrintUnixDialog. Typically,
4064  * this is used to restore saved print settings from a previous print
4065  * operation before the print dialog is shown.
4066  *
4067  * Since: 2.10
4068  **/
4069 void
4070 gtk_print_unix_dialog_set_settings (GtkPrintUnixDialog *dialog,
4071                                     GtkPrintSettings   *settings)
4072 {
4073   GtkPrintUnixDialogPrivate *priv;
4074   const gchar *printer;
4075   GtkPageRange *ranges;
4076   gint num_ranges;
4077
4078   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
4079   g_return_if_fail (settings == NULL || GTK_IS_PRINT_SETTINGS (settings));
4080
4081   priv = dialog->priv;
4082
4083   if (settings != NULL)
4084     {
4085       dialog_set_collate (dialog, gtk_print_settings_get_collate (settings));
4086       dialog_set_reverse (dialog, gtk_print_settings_get_reverse (settings));
4087       dialog_set_n_copies (dialog, gtk_print_settings_get_n_copies (settings));
4088       dialog_set_scale (dialog, gtk_print_settings_get_scale (settings));
4089       dialog_set_page_set (dialog, gtk_print_settings_get_page_set (settings));
4090       dialog_set_print_pages (dialog, gtk_print_settings_get_print_pages (settings));
4091       ranges = gtk_print_settings_get_page_ranges (settings, &num_ranges);
4092       if (ranges)
4093         {
4094           dialog_set_page_ranges (dialog, ranges, num_ranges);
4095           g_free (ranges);
4096         }
4097
4098       priv->format_for_printer =
4099         g_strdup (gtk_print_settings_get (settings, "format-for-printer"));
4100     }
4101
4102   if (priv->initial_settings)
4103     g_object_unref (priv->initial_settings);
4104
4105   priv->initial_settings = settings;
4106
4107   g_free (priv->waiting_for_printer);
4108   priv->waiting_for_printer = NULL;
4109
4110   if (settings)
4111     {
4112       g_object_ref (settings);
4113
4114       printer = gtk_print_settings_get_printer (settings);
4115
4116       if (printer && !set_active_printer (dialog, printer))
4117         priv->waiting_for_printer = g_strdup (printer);
4118     }
4119
4120   g_object_notify (G_OBJECT (dialog), "print-settings");
4121 }
4122
4123 /**
4124  * gtk_print_unix_dialog_get_settings:
4125  * @dialog: a #GtkPrintUnixDialog
4126  *
4127  * Gets a new #GtkPrintSettings object that represents the
4128  * current values in the print dialog. Note that this creates a
4129  * <emphasis>new object</emphasis>, and you need to unref it
4130  * if don't want to keep it.
4131  *
4132  * Returns: a new #GtkPrintSettings object with the values from @dialog
4133  *
4134  * Since: 2.10
4135  */
4136 GtkPrintSettings *
4137 gtk_print_unix_dialog_get_settings (GtkPrintUnixDialog *dialog)
4138 {
4139   GtkPrintUnixDialogPrivate *priv;
4140   GtkPrintSettings *settings;
4141   GtkPrintPages print_pages;
4142   GtkPageRange *ranges;
4143   gint n_ranges;
4144
4145   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
4146
4147   priv = dialog->priv;
4148   settings = gtk_print_settings_new ();
4149
4150   if (priv->current_printer)
4151     gtk_print_settings_set_printer (settings,
4152                                     gtk_printer_get_name (priv->current_printer));
4153   else
4154     gtk_print_settings_set_printer (settings, "default");
4155
4156   gtk_print_settings_set (settings, "format-for-printer",
4157                           priv->format_for_printer);
4158
4159   gtk_print_settings_set_collate (settings,
4160                                   dialog_get_collate (dialog));
4161
4162   gtk_print_settings_set_reverse (settings,
4163                                   dialog_get_reverse (dialog));
4164
4165   gtk_print_settings_set_n_copies (settings,
4166                                    dialog_get_n_copies (dialog));
4167
4168   gtk_print_settings_set_scale (settings,
4169                                 dialog_get_scale (dialog));
4170
4171   gtk_print_settings_set_page_set (settings,
4172                                    dialog_get_page_set (dialog));
4173
4174   print_pages = dialog_get_print_pages (dialog);
4175   gtk_print_settings_set_print_pages (settings, print_pages);
4176
4177   ranges = dialog_get_page_ranges (dialog, &n_ranges);
4178   if (ranges)
4179     {
4180       gtk_print_settings_set_page_ranges  (settings, ranges, n_ranges);
4181       g_free (ranges);
4182     }
4183
4184   /* TODO: print when. How to handle? */
4185
4186   if (priv->current_printer)
4187     _gtk_printer_get_settings_from_options (priv->current_printer,
4188                                             priv->options,
4189                                             settings);
4190
4191   return settings;
4192 }
4193
4194 /**
4195  * gtk_print_unix_dialog_add_custom_tab:
4196  * @dialog: a #GtkPrintUnixDialog
4197  * @child: the widget to put in the custom tab
4198  * @tab_label: the widget to use as tab label
4199  *
4200  * Adds a custom tab to the print dialog.
4201  *
4202  * Since: 2.10
4203  */
4204 void
4205 gtk_print_unix_dialog_add_custom_tab (GtkPrintUnixDialog *dialog,
4206                                       GtkWidget          *child,
4207                                       GtkWidget          *tab_label)
4208 {
4209   gtk_notebook_insert_page (GTK_NOTEBOOK (dialog->priv->notebook),
4210                             child, tab_label, 2);
4211   gtk_widget_show (child);
4212   gtk_widget_show (tab_label);
4213 }
4214
4215 /**
4216  * gtk_print_unix_dialog_set_manual_capabilities:
4217  * @dialog: a #GtkPrintUnixDialog
4218  * @capabilities: the printing capabilities of your application
4219  *
4220  * This lets you specify the printing capabilities your application
4221  * supports. For instance, if you can handle scaling the output then
4222  * you pass #GTK_PRINT_CAPABILITY_SCALE. If you don't pass that, then
4223  * the dialog will only let you select the scale if the printing
4224  * system automatically handles scaling.
4225  *
4226  * Since: 2.10
4227  */
4228 void
4229 gtk_print_unix_dialog_set_manual_capabilities (GtkPrintUnixDialog   *dialog,
4230                                                GtkPrintCapabilities  capabilities)
4231 {
4232   GtkPrintUnixDialogPrivate *priv = dialog->priv;
4233
4234   if (priv->manual_capabilities != capabilities)
4235     {
4236       priv->manual_capabilities = capabilities;
4237       update_dialog_from_capabilities (dialog);
4238
4239       if (priv->current_printer)
4240         {
4241           GtkTreeSelection *selection;
4242
4243           selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
4244
4245           g_object_unref (priv->current_printer);
4246           priv->current_printer = NULL;
4247           priv->internal_printer_change = TRUE;
4248           selected_printer_changed (selection, dialog);
4249           priv->internal_printer_change = FALSE;
4250        }
4251
4252       g_object_notify (G_OBJECT (dialog), "manual-capabilities");
4253     }
4254 }
4255
4256 /**
4257  * gtk_print_unix_dialog_get_manual_capabilities:
4258  * @dialog: a #GtkPrintUnixDialog
4259  *
4260  * Gets the value of #GtkPrintUnixDialog::manual-capabilities property.
4261  *
4262  * Returns: the printing capabilities
4263  *
4264  * Since: 2.18
4265  */
4266 GtkPrintCapabilities
4267 gtk_print_unix_dialog_get_manual_capabilities (GtkPrintUnixDialog *dialog)
4268 {
4269   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
4270
4271   return dialog->priv->manual_capabilities;
4272 }
4273
4274 /**
4275  * gtk_print_unix_dialog_set_support_selection:
4276  * @dialog: a #GtkPrintUnixDialog
4277  * @support_selection: %TRUE to allow print selection
4278  *
4279  * Sets whether the print dialog allows user to print a selection.
4280  *
4281  * Since: 2.18
4282  */
4283 void
4284 gtk_print_unix_dialog_set_support_selection (GtkPrintUnixDialog *dialog,
4285                                              gboolean            support_selection)
4286 {
4287   GtkPrintUnixDialogPrivate *priv;
4288
4289   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
4290
4291   priv = dialog->priv;
4292
4293   support_selection = support_selection != FALSE;
4294   if (priv->support_selection != support_selection)
4295     {
4296       priv->support_selection = support_selection;
4297
4298       if (priv->selection_radio)
4299         {
4300           if (support_selection)
4301             {
4302               gtk_widget_set_sensitive (priv->selection_radio, priv->has_selection);
4303               gtk_table_set_row_spacing (GTK_TABLE (priv->range_table),
4304                                          2,
4305                                          gtk_table_get_default_row_spacing (GTK_TABLE (priv->range_table)));
4306               gtk_widget_show (priv->selection_radio);
4307             }
4308           else
4309             {
4310               gtk_widget_set_sensitive (priv->selection_radio, FALSE);
4311               gtk_table_set_row_spacing (GTK_TABLE (priv->range_table), 2, 0);
4312               gtk_widget_hide (priv->selection_radio);
4313             }
4314         }
4315
4316       g_object_notify (G_OBJECT (dialog), "support-selection");
4317     }
4318 }
4319
4320 /**
4321  * gtk_print_unix_dialog_get_support_selection:
4322  * @dialog: a #GtkPrintUnixDialog
4323  *
4324  * Gets the value of #GtkPrintUnixDialog::support-selection property.
4325  *
4326  * Returns: whether the application supports print of selection
4327  *
4328  * Since: 2.18
4329  */
4330 gboolean
4331 gtk_print_unix_dialog_get_support_selection (GtkPrintUnixDialog *dialog)
4332 {
4333   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
4334
4335   return dialog->priv->support_selection;
4336 }
4337
4338 /**
4339  * gtk_print_unix_dialog_set_has_selection:
4340  * @dialog: a #GtkPrintUnixDialog
4341  * @has_selection: %TRUE indicates that a selection exists
4342  *
4343  * Sets whether a selection exists.
4344  *
4345  * Since: 2.18
4346  */
4347 void
4348 gtk_print_unix_dialog_set_has_selection (GtkPrintUnixDialog *dialog,
4349                                          gboolean            has_selection)
4350 {
4351   GtkPrintUnixDialogPrivate *priv;
4352
4353   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
4354
4355   priv = dialog->priv;
4356
4357   has_selection = has_selection != FALSE;
4358   if (priv->has_selection != has_selection)
4359     {
4360       priv->has_selection = has_selection;
4361
4362       if (priv->selection_radio)
4363         {
4364           if (priv->support_selection)
4365             gtk_widget_set_sensitive (priv->selection_radio, has_selection);
4366           else
4367             gtk_widget_set_sensitive (priv->selection_radio, FALSE);
4368         }
4369
4370       g_object_notify (G_OBJECT (dialog), "has-selection");
4371     }
4372 }
4373
4374 /**
4375  * gtk_print_unix_dialog_get_has_selection:
4376  * @dialog: a #GtkPrintUnixDialog
4377  *
4378  * Gets the value of #GtkPrintUnixDialog::has-selection property.
4379  *
4380  * Returns: whether there is a selection
4381  *
4382  * Since: 2.18
4383  */
4384 gboolean
4385 gtk_print_unix_dialog_get_has_selection (GtkPrintUnixDialog *dialog)
4386 {
4387   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
4388
4389   return dialog->priv->has_selection;
4390 }
4391
4392 /**
4393  * gtk_print_unix_dialog_set_embed_page_setup
4394  * @dialog: a #GtkPrintUnixDialog
4395  * @embed: embed page setup selection
4396  *
4397  * Embed page size combo box and orientation combo box into page setup page.
4398  *
4399  * Since: 2.18
4400  */
4401 void
4402 gtk_print_unix_dialog_set_embed_page_setup (GtkPrintUnixDialog *dialog,
4403                                             gboolean            embed)
4404 {
4405   GtkPrintUnixDialogPrivate *priv;
4406
4407   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
4408
4409   priv = dialog->priv;
4410
4411   embed = embed != FALSE;
4412   if (priv->embed_page_setup != embed)
4413     {
4414       priv->embed_page_setup = embed;
4415
4416       gtk_widget_set_sensitive (priv->paper_size_combo, priv->embed_page_setup);
4417       gtk_widget_set_sensitive (priv->orientation_combo, priv->embed_page_setup);
4418
4419       if (priv->embed_page_setup)
4420         {
4421           if (priv->paper_size_combo != NULL)
4422             g_signal_connect (priv->paper_size_combo, "changed", G_CALLBACK (paper_size_changed), dialog);
4423
4424           if (priv->orientation_combo)
4425             g_signal_connect (priv->orientation_combo, "changed", G_CALLBACK (orientation_changed), dialog);
4426         }
4427       else
4428         {
4429           if (priv->paper_size_combo != NULL)
4430             g_signal_handlers_disconnect_by_func (priv->paper_size_combo, G_CALLBACK (paper_size_changed), dialog);
4431
4432           if (priv->orientation_combo)
4433             g_signal_handlers_disconnect_by_func (priv->orientation_combo, G_CALLBACK (orientation_changed), dialog);
4434         }
4435
4436       priv->internal_page_setup_change = TRUE;
4437       update_paper_sizes (dialog);
4438       priv->internal_page_setup_change = FALSE;
4439     }
4440 }
4441
4442 /**
4443  * gtk_print_unix_dialog_get_embed_page_setup:
4444  * @dialog: a #GtkPrintUnixDialog
4445  *
4446  * Gets the value of #GtkPrintUnixDialog::embed-page-setup property.
4447  *
4448  * Returns: whether there is a selection
4449  *
4450  * Since: 2.18
4451  */
4452 gboolean
4453 gtk_print_unix_dialog_get_embed_page_setup (GtkPrintUnixDialog *dialog)
4454 {
4455   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), FALSE);
4456
4457   return dialog->priv->embed_page_setup;
4458 }