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  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <ctype.h>
  25 #include <stdio.h>
  26 #include <math.h>
  27
  28 #include "gtkintl.h"
  29 #include "gtkprivate.h"
  30
  31 #include "gtkspinbutton.h"
  32 #include "gtkcellrendererpixbuf.h"
  33 #include "gtkcellrenderertext.h"
  34 #include "gtkstock.h"
  35 #include "gtkiconfactory.h"
  36 #include "gtkimage.h"
  37 #include "gtktreeselection.h"
  38 #include "gtknotebook.h"
  39 #include "gtkscrolledwindow.h"
  40 #include "gtkcombobox.h"
  41 #include "gtktogglebutton.h"
  42 #include "gtkradiobutton.h"
  43 #include "gtkdrawingarea.h"
  44 #include "gtkvbox.h"
  45 #include "gtktable.h"
  46 #include "gtkframe.h"
  47 #include "gtkalignment.h"
  48 #include "gtklabel.h"
  49 #include "gtktooltips.h"
  50 #include "gtkeventbox.h"
  51
  52 #include "gtkprintbackend.h"
  53 #include "gtkprinter-private.h"
  54 #include "gtkprintunixdialog.h"
  55 #include "gtkprinteroptionwidget.h"
  56 #include "gtkalias.h"
  57
  58 #define EXAMPLE_PAGE_AREA_SIZE 140
  59
  60 #define GTK_PRINT_UNIX_DIALOG_GET_PRIVATE(o)  \
  61    (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINT_UNIX_DIALOG, GtkPrintUnixDialogPrivate))
  62
  63 static void     gtk_print_unix_dialog_destroy      (GtkPrintUnixDialog *dialog);
  64 static void     gtk_print_unix_dialog_finalize     (GObject            *object);
  65 static void     gtk_print_unix_dialog_set_property (GObject            *object,
  66                                                     guint               prop_id,
  67                                                     const GValue       *value,
  68                                                     GParamSpec         *pspec);
  69 static void     gtk_print_unix_dialog_get_property (GObject            *object,
  70                                                     guint               prop_id,
  71                                                     GValue             *value,
  72                                                     GParamSpec         *pspec);
  73 static void     gtk_print_unix_dialog_style_set    (GtkWidget          *widget,
  74                                                     GtkStyle           *previous_style);
  75 static void     populate_dialog                    (GtkPrintUnixDialog *dialog);
  76 static void     unschedule_idle_mark_conflicts     (GtkPrintUnixDialog *dialog);
  77 static void     selected_printer_changed           (GtkTreeSelection   *selection,
  78                                                     GtkPrintUnixDialog *dialog);
  79 static void     clear_per_printer_ui               (GtkPrintUnixDialog *dialog);
  80 static void     printer_added_cb                   (GtkPrintBackend    *backend,
  81                                                     GtkPrinter         *printer,
  82                                                     GtkPrintUnixDialog *dialog);
  83 static void     printer_removed_cb                 (GtkPrintBackend    *backend,
  84                                                     GtkPrinter         *printer,
  85                                                     GtkPrintUnixDialog *dialog);
  86 static void     printer_status_cb                  (GtkPrintBackend    *backend,
  87                                                     GtkPrinter         *printer,
  88                                                     GtkPrintUnixDialog *dialog);
  89 static void     update_collate_icon                (GtkToggleButton    *toggle_button,
  90                                                     GtkPrintUnixDialog *dialog);
  91 static gboolean dialog_get_collate                 (GtkPrintUnixDialog *dialog);
  92 static gboolean dialog_get_reverse                 (GtkPrintUnixDialog *dialog);
  93 static gint     dialog_get_n_copies                (GtkPrintUnixDialog *dialog);
  94
  95 enum {
  96   PROP_0,
  97   PROP_PAGE_SETUP,
  98   PROP_CURRENT_PAGE,
  99   PROP_PRINT_SETTINGS,
 100   PROP_SELECTED_PRINTER
 101 };
 102
 103 enum {
 104   PRINTER_LIST_COL_ICON,
 105   PRINTER_LIST_COL_NAME,
 106   PRINTER_LIST_COL_STATE,
 107   PRINTER_LIST_COL_JOBS,
 108   PRINTER_LIST_COL_LOCATION,
 109   PRINTER_LIST_COL_PRINTER_OBJ,
 110   PRINTER_LIST_N_COLS
 111 };
 112
 113 struct GtkPrintUnixDialogPrivate
 114 {
 115   GtkWidget *notebook;
 116
 117   GtkWidget *printer_treeview;
 118
 119   GtkPrintCapabilities manual_capabilities;
 120   GtkPrintCapabilities printer_capabilities;
 121
 122   GtkTreeModel *printer_list;
 123   GtkTreeModelFilter *printer_list_filter;
 124
 125   GtkPageSetup *page_setup;
 126
 127   GtkTooltips *tooltips;
 128   GtkWidget *all_pages_radio;
 129   GtkWidget *current_page_radio;
 130   GtkWidget *page_range_radio;
 131   GtkWidget *page_range_entry;
 132
 133   GtkWidget *copies_spin;
 134   GtkWidget *collate_check;
 135   GtkWidget *reverse_check;
 136   GtkWidget *collate_image;
 137   GtkWidget *page_layout_preview;
 138   GtkWidget *scale_spin;
 139   GtkWidget *page_set_combo;
 140   GtkWidget *print_now_radio;
 141   GtkWidget *print_at_radio;
 142   GtkWidget *print_at_entry;
 143   GtkWidget *print_hold_radio;
 144   GtkWidget *preview_button;
 145   gboolean updating_print_at;
 146   GtkPrinterOptionWidget *pages_per_sheet;
 147   GtkPrinterOptionWidget *duplex;
 148   GtkPrinterOptionWidget *paper_type;
 149   GtkPrinterOptionWidget *paper_source;
 150   GtkPrinterOptionWidget *output_tray;
 151   GtkPrinterOptionWidget *job_prio;
 152   GtkPrinterOptionWidget *billing_info;
 153   GtkPrinterOptionWidget *cover_before;
 154   GtkPrinterOptionWidget *cover_after;
 155
 156   GtkWidget *conflicts_widget;
 157
 158   GtkWidget *job_page;
 159   GtkWidget *finishing_table;
 160   GtkWidget *finishing_page;
 161   GtkWidget *image_quality_table;
 162   GtkWidget *image_quality_page;
 163   GtkWidget *color_table;
 164   GtkWidget *color_page;
 165
 166   GtkWidget *advanced_vbox;
 167   GtkWidget *advanced_page;
 168
 169   GtkWidget *extension_point;
 170
 171   /* These are set initially on selected printer (either default printer,
 172    * printer taken from set settings, or user-selected), but when any setting
 173    * is changed by the user it is cleared.
 174    */
 175   GtkPrintSettings *initial_settings;
 176
 177   /* This is the initial printer set by set_settings. We look for it in the
 178    * added printers. We clear this whenever the user manually changes
 179    * to another printer, when the user changes a setting or when we find
 180    * this printer.
 181    */
 182   char *waiting_for_printer;
 183   gboolean internal_printer_change;
 184
 185   GList *print_backends;
 186
 187   GtkPrinter *current_printer;
 188   guint request_details_tag;
 189   GtkPrinterOptionSet *options;
 190   gulong options_changed_handler;
 191   gulong mark_conflicts_id;
 192
 193   gchar *format_for_printer;
 194
 195   gint current_page;
 196 };
 197
 198 G_DEFINE_TYPE (GtkPrintUnixDialog, gtk_print_unix_dialog, GTK_TYPE_DIALOG)
 199
 200 static gboolean
 201 is_default_printer (GtkPrintUnixDialog *dialog,
 202                     GtkPrinter         *printer)
 203 {
 204   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 205
 206   if (priv->format_for_printer)
 207     return strcmp (priv->format_for_printer,
 208                    gtk_printer_get_name (printer)) == 0;
 209  else
 210    return gtk_printer_is_default (printer);
 211 }
 212
 213 static void
 214 gtk_print_unix_dialog_class_init (GtkPrintUnixDialogClass *class)
 215 {
 216   GObjectClass *object_class;
 217   GtkWidgetClass *widget_class;
 218
 219   object_class = (GObjectClass *) class;
 220   widget_class = (GtkWidgetClass *) class;
 221
 222   object_class->finalize = gtk_print_unix_dialog_finalize;
 223   object_class->set_property = gtk_print_unix_dialog_set_property;
 224   object_class->get_property = gtk_print_unix_dialog_get_property;
 225
 226   widget_class->style_set = gtk_print_unix_dialog_style_set;
 227
 228   g_object_class_install_property (object_class,
 229                                    PROP_PAGE_SETUP,
 230                                    g_param_spec_object ("page-setup",
 231                                                         P_("Page Setup"),
 232                                                         P_("The GtkPageSetup to use"),
 233                                                         GTK_TYPE_PAGE_SETUP,
 234                                                         GTK_PARAM_READWRITE));
 235
 236   g_object_class_install_property (object_class,
 237                                    PROP_CURRENT_PAGE,
 238                                    g_param_spec_int ("current-page",
 239                                                      P_("Current Page"),
 240                                                      P_("The current page in the document"),
 241                                                      -1,
 242                                                      G_MAXINT,
 243                                                      -1,
 244                                                      GTK_PARAM_READWRITE));
 245
 246   g_object_class_install_property (object_class,
 247                                    PROP_PRINT_SETTINGS,
 248                                    g_param_spec_object ("print-settings",
 249                                                         P_("Print Settings"),
 250                                                         P_("The GtkPrintSettings used for initializing the dialog"),
 251                                                         GTK_TYPE_PRINT_SETTINGS,
 252                                                         GTK_PARAM_READWRITE));
 253
 254   g_object_class_install_property (object_class,
 255                                    PROP_SELECTED_PRINTER,
 256                                    g_param_spec_object ("selected-printer",
 257                                                         P_("Selected Printer"),
 258                                                         P_("The GtkPrinter which is selected"),
 259                                                         GTK_TYPE_PRINTER,
 260                                                         GTK_PARAM_READABLE));
 261
 262
 263   g_type_class_add_private (class, sizeof (GtkPrintUnixDialogPrivate));
 264 }
 265
 266 static void
 267 gtk_print_unix_dialog_init (GtkPrintUnixDialog *dialog)
 268 {
 269   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 270
 271   priv = dialog->priv = GTK_PRINT_UNIX_DIALOG_GET_PRIVATE (dialog);
 272   priv->print_backends = NULL;
 273   priv->current_page = -1;
 274
 275   priv->tooltips = gtk_tooltips_new ();
 276   g_object_ref_sink (priv->tooltips);
 277
 278   priv->page_setup = gtk_page_setup_new ();
 279
 280   g_signal_connect (dialog,
 281                     "destroy",
 282                     (GCallback) gtk_print_unix_dialog_destroy,
 283                     NULL);
 284
 285   priv->preview_button = gtk_button_new_from_stock (GTK_STOCK_PRINT_PREVIEW);
 286   gtk_widget_show (priv->preview_button);
 287
 288   gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
 289                                 priv->preview_button,
 290                                 GTK_RESPONSE_APPLY);
 291   gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 292                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 293                           GTK_STOCK_PRINT, GTK_RESPONSE_OK,
 294                           NULL);
 295
 296   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 297   gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
 298
 299   populate_dialog (dialog);
 300 }
 301
 302 static void
 303 gtk_print_unix_dialog_destroy (GtkPrintUnixDialog *dialog)
 304 {
 305   /* Make sure we don't destroy custom widgets owned by the backends */
 306   clear_per_printer_ui (dialog);
 307 }
 308
 309 static void
 310 gtk_print_unix_dialog_finalize (GObject *object)
 311 {
 312   GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
 313   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 314   GtkPrintBackend *backend;
 315   GList *node;
 316
 317   unschedule_idle_mark_conflicts (dialog);
 318
 319   if (priv->tooltips)
 320     {
 321       g_object_unref (priv->tooltips);
 322       priv->tooltips = NULL;
 323     }
 324
 325   if (priv->request_details_tag)
 326     {
 327       g_source_remove (priv->request_details_tag);
 328       priv->request_details_tag = 0;
 329     }
 330
 331   if (priv->current_printer)
 332     {
 333       g_object_unref (priv->current_printer);
 334       priv->current_printer = NULL;
 335     }
 336
 337   if (priv->printer_list)
 338     {
 339       g_object_unref (priv->printer_list);
 340       priv->printer_list = NULL;
 341     }
 342
 343   if (priv->printer_list_filter)
 344     {
 345       g_object_unref (priv->printer_list_filter);
 346       priv->printer_list_filter = NULL;
 347     }
 348
 349
 350   if (priv->options)
 351     {
 352       g_object_unref (priv->options);
 353       priv->options = NULL;
 354     }
 355
 356  if (priv->page_setup)
 357     {
 358       g_object_unref (priv->page_setup);
 359       priv->page_setup = NULL;
 360     }
 361
 362   if (priv->initial_settings)
 363     {
 364       g_object_unref (priv->initial_settings);
 365       priv->initial_settings = NULL;
 366     }
 367
 368   g_free (priv->waiting_for_printer);
 369   priv->waiting_for_printer = NULL;
 370
 371   g_free (priv->format_for_printer);
 372   priv->format_for_printer = NULL;
 373
 374   for (node = priv->print_backends; node != NULL; node = node->next)
 375     {
 376       backend = GTK_PRINT_BACKEND (node->data);
 377
 378       g_signal_handlers_disconnect_by_func (backend, printer_added_cb, dialog);
 379       g_signal_handlers_disconnect_by_func (backend, printer_removed_cb, dialog);
 380       g_signal_handlers_disconnect_by_func (backend, printer_status_cb, dialog);
 381
 382       gtk_print_backend_destroy (backend);
 383       g_object_unref (backend);
 384     }
 385
 386   g_list_free (priv->print_backends);
 387   priv->print_backends = NULL;
 388
 389   G_OBJECT_CLASS (gtk_print_unix_dialog_parent_class)->finalize (object);
 390 }
 391
 392 static void
 393 printer_removed_cb (GtkPrintBackend    *backend,
 394                     GtkPrinter         *printer,
 395                     GtkPrintUnixDialog *dialog)
 396 {
 397   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 398   GtkTreeIter *iter;
 399
 400   iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");
 401   gtk_list_store_remove (GTK_LIST_STORE (priv->printer_list), iter);
 402 }
 403
 404 static void
 405 printer_status_cb (GtkPrintBackend    *backend,
 406                    GtkPrinter         *printer,
 407                    GtkPrintUnixDialog *dialog)
 408 {
 409   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 410   GtkTreeIter *iter;
 411
 412   iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");
 413
 414   gtk_list_store_set (GTK_LIST_STORE (priv->printer_list), iter,
 415                       PRINTER_LIST_COL_ICON, gtk_printer_get_icon_name (printer),
 416                       PRINTER_LIST_COL_STATE, gtk_printer_get_state_message (printer),
 417                       PRINTER_LIST_COL_JOBS, gtk_printer_get_job_count (printer),
 418                       PRINTER_LIST_COL_LOCATION, gtk_printer_get_location (printer),
 419                       -1);
 420
 421 }
 422
 423 static void
 424 printer_added_cb (GtkPrintBackend    *backend,
 425                   GtkPrinter         *printer,
 426                   GtkPrintUnixDialog *dialog)
 427 {
 428   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 429   GtkTreeIter iter, filter_iter;
 430   GtkTreeSelection *selection;
 431   GtkTreePath *path;
 432
 433   gtk_list_store_append (GTK_LIST_STORE (priv->printer_list), &iter);
 434
 435   g_object_set_data_full (G_OBJECT (printer),
 436                          "gtk-print-tree-iter",
 437                           gtk_tree_iter_copy (&iter),
 438                           (GDestroyNotify) gtk_tree_iter_free);
 439
 440   gtk_list_store_set (GTK_LIST_STORE (priv->printer_list), &iter,
 441                       PRINTER_LIST_COL_ICON, gtk_printer_get_icon_name (printer),
 442                       PRINTER_LIST_COL_NAME, gtk_printer_get_name (printer),
 443                       PRINTER_LIST_COL_STATE, gtk_printer_get_state_message (printer),
 444                       PRINTER_LIST_COL_JOBS, gtk_printer_get_job_count (printer),
 445                       PRINTER_LIST_COL_LOCATION, gtk_printer_get_location (printer),
 446                       PRINTER_LIST_COL_PRINTER_OBJ, printer,
 447                       -1);
 448
 449   gtk_tree_model_filter_convert_child_iter_to_iter (priv->printer_list_filter,
 450                                                     &filter_iter, &iter);
 451   path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->printer_list_filter), &filter_iter);
 452
 453   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
 454
 455   if (priv->waiting_for_printer != NULL &&
 456       strcmp (gtk_printer_get_name (printer),
 457               priv->waiting_for_printer) == 0)
 458     {
 459       priv->internal_printer_change = TRUE;
 460       gtk_tree_selection_select_iter (selection, &filter_iter);
 461       gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->printer_treeview),
 462                                     path, NULL, TRUE, 0.5, 0.0);
 463       priv->internal_printer_change = FALSE;
 464       g_free (priv->waiting_for_printer);
 465       priv->waiting_for_printer = NULL;
 466     }
 467   else if (is_default_printer (dialog, printer) &&
 468            gtk_tree_selection_count_selected_rows (selection) == 0)
 469     {
 470       priv->internal_printer_change = TRUE;
 471       gtk_tree_selection_select_iter (selection, &filter_iter);
 472       gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->printer_treeview),
 473                                     path, NULL, TRUE, 0.5, 0.0);
 474       priv->internal_printer_change = FALSE;
 475     }
 476
 477   gtk_tree_path_free (path);
 478 }
 479
 480 static void
 481 printer_list_initialize (GtkPrintUnixDialog *dialog,
 482                          GtkPrintBackend    *print_backend)
 483 {
 484   GList *list;
 485   GList *node;
 486
 487   g_return_if_fail (print_backend != NULL);
 488
 489   g_signal_connect_object (print_backend,
 490                            "printer-added",
 491                            (GCallback) printer_added_cb,
 492                            G_OBJECT (dialog), 0);
 493
 494   g_signal_connect_object (print_backend,
 495                            "printer-removed",
 496                            (GCallback) printer_removed_cb,
 497                            G_OBJECT (dialog), 0);
 498
 499   g_signal_connect_object (print_backend,
 500                            "printer-status-changed",
 501                            (GCallback) printer_status_cb,
 502                            G_OBJECT (dialog), 0);
 503
 504   list = gtk_print_backend_get_printer_list (print_backend);
 505
 506   node = list;
 507   while (node != NULL)
 508     {
 509       printer_added_cb (print_backend, node->data, dialog);
 510       node = node->next;
 511     }
 512
 513   g_list_free (list);
 514 }
 515
 516 static void
 517 load_print_backends (GtkPrintUnixDialog *dialog)
 518 {
 519   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 520   GList *node;
 521
 522   if (g_module_supported ())
 523     priv->print_backends = gtk_print_backend_load_modules ();
 524
 525   for (node = priv->print_backends; node != NULL; node = node->next)
 526     printer_list_initialize (dialog, GTK_PRINT_BACKEND (node->data));
 527 }
 528
 529 static void
 530 gtk_print_unix_dialog_set_property (GObject      *object,
 531                                     guint         prop_id,
 532                                     const GValue *value,
 533                                     GParamSpec   *pspec)
 534
 535 {
 536   GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
 537
 538   switch (prop_id)
 539     {
 540     case PROP_PAGE_SETUP:
 541       gtk_print_unix_dialog_set_page_setup (dialog, g_value_get_object (value));
 542       break;
 543     case PROP_CURRENT_PAGE:
 544       gtk_print_unix_dialog_set_current_page (dialog, g_value_get_int (value));
 545       break;
 546     case PROP_PRINT_SETTINGS:
 547       gtk_print_unix_dialog_set_settings (dialog, g_value_get_object (value));
 548       break;
 549     default:
 550       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 551       break;
 552     }
 553 }
 554
 555 static void
 556 gtk_print_unix_dialog_get_property (GObject    *object,
 557                                     guint       prop_id,
 558                                     GValue     *value,
 559                                     GParamSpec *pspec)
 560 {
 561   GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (object);
 562   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 563
 564   switch (prop_id)
 565     {
 566     case PROP_PAGE_SETUP:
 567       g_value_set_object (value, priv->page_setup);
 568       break;
 569     case PROP_CURRENT_PAGE:
 570       g_value_set_int (value, priv->current_page);
 571       break;
 572     case PROP_PRINT_SETTINGS:
 573       g_value_set_object (value, gtk_print_unix_dialog_get_settings (dialog));
 574       break;
 575     case PROP_SELECTED_PRINTER:
 576       g_value_set_object (value, priv->current_printer);
 577       break;
 578     default:
 579       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 580       break;
 581     }
 582 }
 583
 584 static gboolean
 585 is_printer_active (GtkTreeModel       *model,
 586                    GtkTreeIter        *iter,
 587                    GtkPrintUnixDialog *dialog)
 588 {
 589   gboolean result;
 590   GtkPrinter *printer;
 591   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 592
 593   gtk_tree_model_get (model,
 594                       iter,
 595                       PRINTER_LIST_COL_PRINTER_OBJ,
 596                       &printer,
 597                       -1);
 598
 599   if (printer == NULL)
 600     return FALSE;
 601
 602   result = gtk_printer_is_active (printer);
 603
 604   if (result &&
 605       priv->manual_capabilities & (GTK_PRINT_CAPABILITY_GENERATE_PDF |
 606                                    GTK_PRINT_CAPABILITY_GENERATE_PS))
 607     {
 608        /* Check that the printer can handle at least one of the data
 609         * formats that the application supports.
 610         */
 611        result = ((priv->manual_capabilities & GTK_PRINT_CAPABILITY_GENERATE_PDF) &&
 612                  gtk_printer_accepts_pdf (printer)) ||
 613                 ((priv->manual_capabilities & GTK_PRINT_CAPABILITY_GENERATE_PS) &&
 614                  gtk_printer_accepts_ps (printer));
 615     }
 616
 617   g_object_unref (printer);
 618
 619   return result;
 620 }
 621
 622 static gint
 623 default_printer_list_sort_func (GtkTreeModel *model,
 624                                 GtkTreeIter  *a,
 625                                 GtkTreeIter  *b,
 626                                 gpointer      user_data)
 627 {
 628   gchar *a_name;
 629   gchar *b_name;
 630   GtkPrinter *a_printer;
 631   GtkPrinter *b_printer;
 632   gint result;
 633
 634   gtk_tree_model_get (model, a,
 635                       PRINTER_LIST_COL_NAME, &a_name,
 636                       PRINTER_LIST_COL_PRINTER_OBJ, &a_printer,
 637                       -1);
 638   gtk_tree_model_get (model, b,
 639                       PRINTER_LIST_COL_NAME, &b_name,
 640                       PRINTER_LIST_COL_PRINTER_OBJ, &b_printer,
 641                       -1);
 642
 643   if (a_printer == NULL && b_printer == NULL)
 644     result = 0;
 645   else if (a_printer == NULL)
 646    result = G_MAXINT;
 647   else if (b_printer == NULL)
 648    result = G_MININT;
 649   else if (gtk_printer_is_virtual (a_printer) && gtk_printer_is_virtual (b_printer))
 650     result = 0;
 651   else if (gtk_printer_is_virtual (a_printer) && !gtk_printer_is_virtual (b_printer))
 652     result = G_MININT;
 653   else if (!gtk_printer_is_virtual (a_printer) && gtk_printer_is_virtual (b_printer))
 654     result = G_MAXINT;
 655   else if (a_name == NULL && b_name == NULL)
 656     result = 0;
 657   else if (a_name == NULL && b_name != NULL)
 658     result = 1;
 659   else if (a_name != NULL && b_name == NULL)
 660     result = -1;
 661   else
 662     result = g_ascii_strcasecmp (a_name, b_name);
 663
 664   g_free (a_name);
 665   g_free (b_name);
 666   g_object_unref (a_printer);
 667   g_object_unref (b_printer);
 668
 669   return result;
 670 }
 671
 672
 673 static void
 674 create_printer_list_model (GtkPrintUnixDialog *dialog)
 675 {
 676   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 677   GtkListStore *model;
 678   GtkTreeSortable *sort;
 679
 680   model = gtk_list_store_new (PRINTER_LIST_N_COLS,
 681                               G_TYPE_STRING,
 682                               G_TYPE_STRING,
 683                               G_TYPE_STRING,
 684                               G_TYPE_INT,
 685                               G_TYPE_STRING,
 686                               G_TYPE_OBJECT);
 687
 688   priv->printer_list = (GtkTreeModel *)model;
 689   priv->printer_list_filter = (GtkTreeModelFilter *) gtk_tree_model_filter_new ((GtkTreeModel *)model,
 690                                                                                         NULL);
 691
 692   gtk_tree_model_filter_set_visible_func (priv->printer_list_filter,
 693                                           (GtkTreeModelFilterVisibleFunc) is_printer_active,
 694                                           dialog,
 695                                           NULL);
 696
 697   sort = GTK_TREE_SORTABLE (model);
 698   gtk_tree_sortable_set_default_sort_func (sort,
 699                                            default_printer_list_sort_func,
 700                                            NULL,
 701                                            NULL);
 702
 703   gtk_tree_sortable_set_sort_column_id (sort,
 704                                         GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 705                                         GTK_SORT_ASCENDING);
 706
 707 }
 708
 709
 710 static GtkWidget *
 711 wrap_in_frame (const gchar *label,
 712                GtkWidget   *child)
 713 {
 714   GtkWidget *frame, *alignment, *label_widget;
 715   gchar *bold_text;
 716
 717   label_widget = gtk_label_new ("");
 718   gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
 719   gtk_widget_show (label_widget);
 720
 721   bold_text = g_markup_printf_escaped ("<b>%s</b>", label);
 722   gtk_label_set_markup (GTK_LABEL (label_widget), bold_text);
 723   g_free (bold_text);
 724
 725   frame = gtk_vbox_new (FALSE, 6);
 726   gtk_box_pack_start (GTK_BOX (frame), label_widget, FALSE, FALSE, 0);
 727
 728   alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
 729   gtk_alignment_set_padding (GTK_ALIGNMENT (alignment),
 730                              0, 0, 12, 0);
 731   gtk_box_pack_start (GTK_BOX (frame), alignment, FALSE, FALSE, 0);
 732
 733   gtk_container_add (GTK_CONTAINER (alignment), child);
 734
 735   gtk_widget_show (frame);
 736   gtk_widget_show (alignment);
 737
 738   return frame;
 739 }
 740
 741 static gboolean
 742 setup_option (GtkPrintUnixDialog     *dialog,
 743               const gchar            *option_name,
 744               GtkPrinterOptionWidget *widget)
 745 {
 746   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 747   GtkPrinterOption *option;
 748
 749   option = gtk_printer_option_set_lookup (priv->options, option_name);
 750   gtk_printer_option_widget_set_source (widget, option);
 751
 752   return option != NULL;
 753 }
 754
 755 static void
 756 add_option_to_extension_point (GtkPrinterOption *option,
 757                                gpointer          data)
 758 {
 759   GtkWidget *extension_point = data;
 760   GtkWidget *widget;
 761
 762   widget = gtk_printer_option_widget_new (option);
 763   gtk_widget_show (widget);
 764
 765   if (gtk_printer_option_widget_has_external_label (GTK_PRINTER_OPTION_WIDGET (widget)))
 766     {
 767       GtkWidget *label, *hbox;
 768
 769       label = gtk_printer_option_widget_get_external_label (GTK_PRINTER_OPTION_WIDGET (widget));
 770       gtk_widget_show (label);
 771       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 772       gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
 773
 774       hbox = gtk_hbox_new (FALSE, 12);
 775       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 776       gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
 777       gtk_widget_show (hbox);
 778
 779       gtk_box_pack_start (GTK_BOX (extension_point), hbox, FALSE, FALSE, 0);
 780     }
 781   else
 782     gtk_box_pack_start (GTK_BOX (extension_point), widget, FALSE, FALSE, 0);
 783 }
 784
 785 static void
 786 add_option_to_table (GtkPrinterOption *option,
 787                      gpointer          user_data)
 788 {
 789   GtkTable *table;
 790   GtkWidget *label, *widget;
 791   gint row;
 792
 793   table = GTK_TABLE (user_data);
 794
 795   if (g_str_has_prefix (option->name, "gtk-"))
 796     return;
 797
 798   widget = gtk_printer_option_widget_new (option);
 799   gtk_widget_show (widget);
 800
 801   row = table->nrows;
 802   gtk_table_resize (table, table->nrows + 1, 2);
 803
 804   if (gtk_printer_option_widget_has_external_label (GTK_PRINTER_OPTION_WIDGET (widget)))
 805     {
 806       label = gtk_printer_option_widget_get_external_label (GTK_PRINTER_OPTION_WIDGET (widget));
 807       gtk_widget_show (label);
 808
 809       gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 810       gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
 811
 812       gtk_table_attach (table, label,
 813                         0, 1, row - 1 , row,  GTK_FILL, 0, 0, 0);
 814
 815       gtk_table_attach (table, widget,
 816                         1, 2, row - 1, row,  GTK_FILL, 0, 0, 0);
 817     }
 818   else
 819     gtk_table_attach (table, widget,
 820                       0, 2, row - 1, row,  GTK_FILL, 0, 0, 0);
 821 }
 822
 823
 824 static void
 825 setup_page_table (GtkPrinterOptionSet *options,
 826                   const gchar         *group,
 827                   GtkWidget           *table,
 828                   GtkWidget           *page)
 829 {
 830   gtk_printer_option_set_foreach_in_group (options, group,
 831                                            add_option_to_table,
 832                                            table);
 833   if (GTK_TABLE (table)->nrows == 1)
 834     gtk_widget_hide (page);
 835   else
 836     gtk_widget_show (page);
 837 }
 838
 839 static void
 840 update_print_at_option (GtkPrintUnixDialog *dialog)
 841 {
 842   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 843   GtkPrinterOption *option;
 844
 845   option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time");
 846
 847   if (option == NULL)
 848     return;
 849
 850   if (priv->updating_print_at)
 851     return;
 852
 853   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->print_at_radio)))
 854     gtk_printer_option_set (option, "at");
 855   else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->print_hold_radio)))
 856     gtk_printer_option_set (option, "on-hold");
 857   else
 858     gtk_printer_option_set (option, "now");
 859
 860   option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time-text");
 861   if (option != NULL)
 862     {
 863       const char *text = gtk_entry_get_text (GTK_ENTRY (priv->print_at_entry));
 864       gtk_printer_option_set (option,text);
 865     }
 866 }
 867
 868
 869 static gboolean
 870 setup_print_at (GtkPrintUnixDialog *dialog)
 871 {
 872   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 873   GtkPrinterOption *option;
 874
 875   option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time");
 876
 877   if (option == NULL)
 878     {
 879       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_now_radio),
 880                                     TRUE);
 881       gtk_widget_set_sensitive (priv->print_at_radio, FALSE);
 882       gtk_widget_set_sensitive (priv->print_at_entry, FALSE);
 883       gtk_widget_set_sensitive (priv->print_hold_radio, FALSE);
 884       gtk_entry_set_text (GTK_ENTRY (priv->print_at_entry), "");
 885       return FALSE;
 886     }
 887
 888   priv->updating_print_at = TRUE;
 889
 890   if (gtk_printer_option_has_choice (option, "at"))
 891     {
 892       gtk_widget_set_sensitive (priv->print_at_radio, TRUE);
 893       gtk_widget_set_sensitive (priv->print_at_entry, TRUE);
 894     }
 895   else
 896     {
 897       gtk_widget_set_sensitive (priv->print_at_radio, FALSE);
 898       gtk_widget_set_sensitive (priv->print_at_entry, FALSE);
 899     }
 900
 901   gtk_widget_set_sensitive (priv->print_hold_radio,
 902                             gtk_printer_option_has_choice (option, "on-hold"));
 903
 904   update_print_at_option (dialog);
 905
 906   if (strcmp (option->value, "at") == 0)
 907     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_at_radio),
 908                                   TRUE);
 909   else if (strcmp (option->value, "on-hold") == 0)
 910     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_hold_radio),
 911                                   TRUE);
 912   else
 913     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->print_now_radio),
 914                                   TRUE);
 915
 916   option = gtk_printer_option_set_lookup (priv->options, "gtk-print-time-text");
 917   if (option != NULL)
 918     gtk_entry_set_text (GTK_ENTRY (priv->print_at_entry),
 919                         option->value);
 920
 921
 922   priv->updating_print_at = FALSE;
 923
 924   return TRUE;
 925 }
 926
 927 static void
 928 update_dialog_from_settings (GtkPrintUnixDialog *dialog)
 929 {
 930   GtkPrintUnixDialogPrivate *priv = dialog->priv;
 931   GList *groups, *l;
 932   gchar *group;
 933   GtkWidget *table, *frame;
 934   gboolean has_advanced, has_job;
 935
 936   if (priv->current_printer == NULL)
 937     {
 938        clear_per_printer_ui (dialog);
 939        gtk_widget_hide (priv->job_page);
 940        gtk_widget_hide (priv->advanced_page);
 941        gtk_widget_hide (priv->image_quality_page);
 942        gtk_widget_hide (priv->finishing_page);
 943        gtk_widget_hide (priv->color_page);
 944        gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
 945
 946        return;
 947     }
 948
 949   setup_option (dialog, "gtk-n-up", priv->pages_per_sheet);
 950   setup_option (dialog, "gtk-duplex", priv->duplex);
 951   setup_option (dialog, "gtk-paper-type", priv->paper_type);
 952   setup_option (dialog, "gtk-paper-source", priv->paper_source);
 953   setup_option (dialog, "gtk-output-tray", priv->output_tray);
 954
 955   has_job = FALSE;
 956   has_job |= setup_option (dialog, "gtk-job-prio", priv->job_prio);
 957   has_job |= setup_option (dialog, "gtk-billing-info", priv->billing_info);
 958   has_job |= setup_option (dialog, "gtk-cover-before", priv->cover_before);
 959   has_job |= setup_option (dialog, "gtk-cover-after", priv->cover_after);
 960   has_job |= setup_print_at (dialog);
 961
 962   if (has_job)
 963     gtk_widget_show (priv->job_page);
 964   else
 965     gtk_widget_hide (priv->job_page);
 966
 967
 968   setup_page_table (priv->options,
 969                     "ImageQualityPage",
 970                     priv->image_quality_table,
 971                     priv->image_quality_page);
 972
 973   setup_page_table (priv->options,
 974                     "FinishingPage",
 975                     priv->finishing_table,
 976                     priv->finishing_page);
 977
 978   setup_page_table (priv->options,
 979                     "ColorPage",
 980                     priv->color_table,
 981                     priv->color_page);
 982
 983   gtk_printer_option_set_foreach_in_group (priv->options,
 984                                            "GtkPrintDialogExtension",
 985                                            add_option_to_extension_point,
 986                                            priv->extension_point);
 987
 988   /* Put the rest of the groups in the advanced page */
 989   groups = gtk_printer_option_set_get_groups (priv->options);
 990
 991   has_advanced = FALSE;
 992   for (l = groups; l != NULL; l = l->next)
 993     {
 994       group = l->data;
 995
 996       if (group == NULL)
 997         continue;
 998
 999       if (strcmp (group, "ImageQualityPage") == 0 ||
1000           strcmp (group, "ColorPage") == 0 ||
1001           strcmp (group, "FinishingPage") == 0 ||
1002           strcmp (group, "GtkPrintDialogExtension") == 0)
1003         continue;
1004
1005       table = gtk_table_new (1, 2, FALSE);
1006       gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1007       gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1008
1009       gtk_printer_option_set_foreach_in_group (priv->options,
1010                                                group,
1011                                                add_option_to_table,
1012                                                table);
1013       if (GTK_TABLE (table)->nrows == 1)
1014         gtk_widget_destroy (table);
1015       else
1016         {
1017           has_advanced = TRUE;
1018           frame = wrap_in_frame (group, table);
1019           gtk_widget_show (table);
1020           gtk_widget_show (frame);
1021
1022           gtk_box_pack_start (GTK_BOX (priv->advanced_vbox),
1023                               frame, FALSE, FALSE, 0);
1024         }
1025     }
1026
1027   if (has_advanced)
1028     gtk_widget_show (priv->advanced_page);
1029   else
1030     gtk_widget_hide (priv->advanced_page);
1031
1032
1033   g_list_foreach (groups, (GFunc) g_free, NULL);
1034   g_list_free (groups);
1035 }
1036
1037 static void
1038 update_dialog_from_capabilities (GtkPrintUnixDialog *dialog)
1039 {
1040   GtkPrintCapabilities caps;
1041   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1042   gboolean can_collate;
1043   const gchar *copies;
1044
1045   copies = gtk_entry_get_text (GTK_ENTRY (priv->copies_spin));
1046   can_collate = (*copies != '\0' && atoi (copies) > 1);
1047
1048   caps = priv->manual_capabilities | priv->printer_capabilities;
1049
1050   gtk_widget_set_sensitive (priv->page_set_combo,
1051                             caps & GTK_PRINT_CAPABILITY_PAGE_SET);
1052   gtk_widget_set_sensitive (priv->copies_spin,
1053                             caps & GTK_PRINT_CAPABILITY_COPIES);
1054   gtk_widget_set_sensitive (priv->collate_check,
1055                             can_collate &&
1056                             (caps & GTK_PRINT_CAPABILITY_COLLATE));
1057   gtk_widget_set_sensitive (priv->reverse_check,
1058                             caps & GTK_PRINT_CAPABILITY_REVERSE);
1059   gtk_widget_set_sensitive (priv->scale_spin,
1060                             caps & GTK_PRINT_CAPABILITY_SCALE);
1061
1062   if (caps & GTK_PRINT_CAPABILITY_PREVIEW)
1063     gtk_widget_show (priv->preview_button);
1064   else
1065     gtk_widget_hide (priv->preview_button);
1066
1067   update_collate_icon (NULL, dialog);
1068
1069   gtk_tree_model_filter_refilter (priv->printer_list_filter);
1070 }
1071
1072 static void
1073 mark_conflicts (GtkPrintUnixDialog *dialog)
1074 {
1075   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1076   GtkPrinter *printer;
1077   gboolean have_conflict;
1078
1079   have_conflict = FALSE;
1080
1081   printer = priv->current_printer;
1082
1083   if (printer)
1084     {
1085
1086       g_signal_handler_block (priv->options,
1087                               priv->options_changed_handler);
1088
1089       gtk_printer_option_set_clear_conflicts (priv->options);
1090
1091       have_conflict = _gtk_printer_mark_conflicts (printer,
1092                                                    priv->options);
1093
1094       g_signal_handler_unblock (priv->options,
1095                                 priv->options_changed_handler);
1096     }
1097
1098   if (have_conflict)
1099     gtk_widget_show (priv->conflicts_widget);
1100   else
1101     gtk_widget_hide (priv->conflicts_widget);
1102 }
1103
1104 static gboolean
1105 mark_conflicts_callback (gpointer data)
1106 {
1107   GtkPrintUnixDialog *dialog = data;
1108   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1109
1110   priv->mark_conflicts_id = 0;
1111
1112   mark_conflicts (dialog);
1113
1114   return FALSE;
1115 }
1116
1117 static void
1118 unschedule_idle_mark_conflicts (GtkPrintUnixDialog *dialog)
1119 {
1120   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1121
1122   if (priv->mark_conflicts_id != 0)
1123     {
1124       g_source_remove (priv->mark_conflicts_id);
1125       priv->mark_conflicts_id = 0;
1126     }
1127 }
1128
1129 static void
1130 schedule_idle_mark_conflicts (GtkPrintUnixDialog *dialog)
1131 {
1132   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1133
1134   if (priv->mark_conflicts_id != 0)
1135     return;
1136
1137   priv->mark_conflicts_id = gdk_threads_add_idle (mark_conflicts_callback,
1138                                         dialog);
1139 }
1140
1141 static void
1142 options_changed_cb (GtkPrintUnixDialog *dialog)
1143 {
1144   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1145
1146   schedule_idle_mark_conflicts (dialog);
1147
1148   if (priv->initial_settings)
1149     {
1150       g_object_unref (priv->initial_settings);
1151       priv->initial_settings = NULL;
1152     }
1153
1154   g_free (priv->waiting_for_printer);
1155   priv->waiting_for_printer = NULL;
1156 }
1157
1158 static void
1159 remove_custom_widget (GtkWidget    *widget,
1160                       GtkContainer *container)
1161 {
1162   gtk_container_remove (container, widget);
1163 }
1164
1165 static void
1166 extension_point_clear_children (GtkContainer *container)
1167 {
1168   gtk_container_foreach (container,
1169                          (GtkCallback)remove_custom_widget,
1170                          container);
1171 }
1172
1173 static void
1174 clear_per_printer_ui (GtkPrintUnixDialog *dialog)
1175 {
1176   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1177
1178   gtk_container_foreach (GTK_CONTAINER (priv->finishing_table),
1179                          (GtkCallback)gtk_widget_destroy,
1180                          NULL);
1181   gtk_table_resize (GTK_TABLE (priv->finishing_table), 1, 2);
1182   gtk_container_foreach (GTK_CONTAINER (priv->image_quality_table),
1183                          (GtkCallback)gtk_widget_destroy,
1184                          NULL);
1185   gtk_table_resize (GTK_TABLE (priv->image_quality_table), 1, 2);
1186   gtk_container_foreach (GTK_CONTAINER (priv->color_table),
1187                          (GtkCallback)gtk_widget_destroy,
1188                          NULL);
1189   gtk_table_resize (GTK_TABLE (priv->color_table), 1, 2);
1190   gtk_container_foreach (GTK_CONTAINER (priv->advanced_vbox),
1191                          (GtkCallback)gtk_widget_destroy,
1192                          NULL);
1193   extension_point_clear_children (GTK_CONTAINER (priv->extension_point));
1194 }
1195
1196 static void
1197 printer_details_acquired (GtkPrinter         *printer,
1198                           gboolean            success,
1199                           GtkPrintUnixDialog *dialog)
1200 {
1201   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1202
1203   priv->request_details_tag = 0;
1204
1205   if (success)
1206     {
1207       GtkTreeSelection *selection;
1208       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
1209
1210       selected_printer_changed (selection, dialog);
1211     }
1212 }
1213
1214 static void
1215 selected_printer_changed (GtkTreeSelection   *selection,
1216                           GtkPrintUnixDialog *dialog)
1217 {
1218   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1219   GtkPrinter *printer;
1220   GtkTreeIter iter, filter_iter;
1221
1222   /* Whenever the user selects a printer we stop looking for
1223      the printer specified in the initial settings */
1224   if (priv->waiting_for_printer &&
1225       !priv->internal_printer_change)
1226     {
1227       g_free (priv->waiting_for_printer);
1228       priv->waiting_for_printer = NULL;
1229     }
1230
1231   if (priv->request_details_tag)
1232     {
1233       g_source_remove (priv->request_details_tag);
1234       priv->request_details_tag = 0;
1235     }
1236
1237   printer = NULL;
1238   if (gtk_tree_selection_get_selected (selection, NULL, &filter_iter))
1239     {
1240       gtk_tree_model_filter_convert_iter_to_child_iter (priv->printer_list_filter,
1241                                                         &iter,
1242                                                         &filter_iter);
1243
1244       gtk_tree_model_get (priv->printer_list, &iter,
1245                           PRINTER_LIST_COL_PRINTER_OBJ, &printer,
1246                           -1);
1247     }
1248
1249   if (printer != NULL && !gtk_printer_has_details (printer))
1250     {
1251       gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
1252       priv->request_details_tag =
1253         g_signal_connect (printer, "details-acquired",
1254                           G_CALLBACK (printer_details_acquired), dialog);
1255       gtk_printer_request_details (printer);
1256       g_object_unref (printer);
1257       return;
1258     }
1259
1260   if (printer == priv->current_printer)
1261     {
1262       if (printer)
1263         g_object_unref (printer);
1264       return;
1265     }
1266
1267   if (priv->options)
1268     {
1269       g_object_unref (priv->options);
1270       priv->options = NULL;
1271
1272       clear_per_printer_ui (dialog);
1273     }
1274
1275   if (priv->current_printer)
1276     {
1277       g_object_unref (priv->current_printer);
1278     }
1279
1280   priv->printer_capabilities = 0;
1281
1282   gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, TRUE);
1283   priv->current_printer = printer;
1284
1285   if (printer != NULL)
1286     {
1287       priv->printer_capabilities = gtk_printer_get_capabilities (printer);
1288       priv->options = _gtk_printer_get_options (printer,
1289                                                 priv->initial_settings,
1290                                                 priv->page_setup,
1291                                                 priv->manual_capabilities);
1292
1293       priv->options_changed_handler =
1294         g_signal_connect_swapped (priv->options, "changed", G_CALLBACK (options_changed_cb), dialog);
1295     }
1296
1297   update_dialog_from_settings (dialog);
1298   update_dialog_from_capabilities (dialog);
1299 }
1300
1301 static void
1302 update_collate_icon (GtkToggleButton    *toggle_button,
1303                      GtkPrintUnixDialog *dialog)
1304 {
1305   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1306
1307   gtk_widget_queue_draw (priv->collate_image);
1308 }
1309
1310 static void
1311 paint_page (GtkWidget *widget,
1312             cairo_t   *cr,
1313             gfloat     scale,
1314             gint       x_offset,
1315             gint       y_offset,
1316             gchar     *text,
1317             gint       text_x)
1318 {
1319   gint x, y, width, height;
1320   gint text_y, linewidth;
1321
1322   x = x_offset * scale;
1323   y = y_offset * scale;
1324   width = 20 * scale;
1325   height = 26 * scale;
1326
1327   linewidth = 2;
1328   text_y = 21;
1329
1330   gdk_cairo_set_source_color (cr, &widget->style->base[GTK_STATE_NORMAL]);
1331   cairo_rectangle (cr, x, y, width, height);
1332   cairo_fill (cr);
1333
1334   gdk_cairo_set_source_color (cr, &widget->style->text[GTK_STATE_NORMAL]);
1335   cairo_set_line_width (cr, linewidth);
1336   cairo_rectangle (cr, x + linewidth/2.0, y + linewidth/2.0, width - linewidth, height - linewidth);
1337   cairo_stroke (cr);
1338
1339   cairo_select_font_face (cr, "Sans",
1340                           CAIRO_FONT_SLANT_NORMAL,
1341                           CAIRO_FONT_WEIGHT_NORMAL);
1342   cairo_set_font_size (cr, (gint)(9 * scale));
1343   cairo_move_to (cr, x + (gint)(text_x * scale), y + (gint)(text_y * scale));
1344   cairo_show_text (cr, text);
1345 }
1346
1347
1348 static gboolean
1349 draw_collate_cb (GtkWidget          *widget,
1350                  GdkEventExpose     *event,
1351                  GtkPrintUnixDialog *dialog)
1352 {
1353   GtkSettings *settings;
1354   cairo_t *cr;
1355   gint size;
1356   gfloat scale;
1357   gboolean collate, reverse, rtl;
1358   gint copies;
1359   gint text_x;
1360
1361   collate = dialog_get_collate (dialog);
1362   reverse = dialog_get_reverse (dialog);
1363   copies = dialog_get_n_copies (dialog);
1364
1365   rtl = (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL);
1366
1367   settings = gtk_widget_get_settings (widget);
1368   gtk_icon_size_lookup_for_settings (settings,
1369                                      GTK_ICON_SIZE_DIALOG,
1370                                      &size,
1371                                      NULL);
1372   scale = size / 48.0;
1373   text_x = rtl ? 4 : 11;
1374
1375   cr = gdk_cairo_create (widget->window);
1376
1377   if (copies == 1)
1378     {
1379       paint_page (widget, cr, scale, rtl ? 40: 15, 5, reverse ? "1" : "2", text_x);
1380       paint_page (widget, cr, scale, rtl ? 50: 5, 15, reverse ? "2" : "1", text_x);
1381     }
1382   else
1383     {
1384       paint_page (widget, cr, scale, rtl ? 40: 15, 5, collate == reverse ? "1" : "2", text_x);
1385       paint_page (widget, cr, scale, rtl ? 50: 5, 15, reverse ? "2" : "1", text_x);
1386
1387       paint_page (widget, cr, scale, rtl ? 5 : 50, 5, reverse ? "1" : "2", text_x);
1388       paint_page (widget, cr, scale, rtl ? 15 : 40, 15, collate == reverse ? "2" : "1", text_x);
1389     }
1390
1391   cairo_destroy (cr);
1392
1393   return TRUE;
1394 }
1395
1396 static void
1397 gtk_print_unix_dialog_style_set (GtkWidget *widget,
1398                                  GtkStyle  *previous_style)
1399 {
1400   if (GTK_WIDGET_CLASS (gtk_print_unix_dialog_parent_class)->style_set)
1401     GTK_WIDGET_CLASS (gtk_print_unix_dialog_parent_class)->style_set (widget, previous_style);
1402
1403   if (gtk_widget_has_screen (widget))
1404     {
1405       GtkPrintUnixDialog *dialog = (GtkPrintUnixDialog *)widget;
1406       GtkPrintUnixDialogPrivate *priv = dialog->priv;
1407       GtkSettings *settings;
1408       gint size;
1409       gfloat scale;
1410
1411       settings = gtk_widget_get_settings (widget);
1412       gtk_icon_size_lookup_for_settings (settings,
1413                                          GTK_ICON_SIZE_DIALOG,
1414                                          &size,
1415                                          NULL);
1416       scale = size / 48.0;
1417
1418       gtk_widget_set_size_request (priv->collate_image,
1419                                    (50 + 20) * scale,
1420                                    (15 + 26) * scale);
1421     }
1422 }
1423
1424 static void
1425 update_range_sensitivity (GtkWidget *button,
1426                           GtkWidget *range)
1427 {
1428   gboolean active;
1429
1430   active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
1431
1432   gtk_widget_set_sensitive (range, active);
1433 }
1434
1435 static void
1436 create_main_page (GtkPrintUnixDialog *dialog)
1437 {
1438   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1439   GtkWidget *main_vbox, *label, *vbox, *hbox;
1440   GtkWidget *scrolled, *treeview, *frame, *table;
1441   GtkWidget *entry, *spinbutton;
1442   GtkWidget *radio, *check, *image;
1443   GtkCellRenderer *renderer;
1444   GtkTreeViewColumn *column;
1445   GtkTreeSelection *selection;
1446   GtkWidget *custom_input;
1447
1448   main_vbox = gtk_vbox_new (FALSE, 18);
1449   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
1450   gtk_widget_show (main_vbox);
1451
1452   vbox = gtk_vbox_new (FALSE, 6);
1453   gtk_box_pack_start (GTK_BOX (main_vbox), vbox, TRUE, TRUE, 0);
1454   gtk_widget_show (vbox);
1455
1456   scrolled = gtk_scrolled_window_new (NULL, NULL);
1457   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
1458                                   GTK_POLICY_AUTOMATIC,
1459                                   GTK_POLICY_AUTOMATIC);
1460   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
1461                                        GTK_SHADOW_IN);
1462   gtk_widget_show (scrolled);
1463   gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
1464
1465   treeview = gtk_tree_view_new_with_model ((GtkTreeModel *) priv->printer_list_filter);
1466   priv->printer_treeview = treeview;
1467   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), TRUE);
1468   gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), PRINTER_LIST_COL_NAME);
1469   gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), TRUE);
1470   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
1471   gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
1472   g_signal_connect (selection, "changed", G_CALLBACK (selected_printer_changed), dialog);
1473
1474   renderer = gtk_cell_renderer_pixbuf_new ();
1475   column = gtk_tree_view_column_new_with_attributes ("",
1476                                                      renderer,
1477                                                      "icon-name",
1478                                                      PRINTER_LIST_COL_ICON,
1479                                                      NULL);
1480   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
1481
1482   renderer = gtk_cell_renderer_text_new ();
1483   column = gtk_tree_view_column_new_with_attributes (_("Printer"),
1484                                                      renderer,
1485                                                      "text",
1486                                                      PRINTER_LIST_COL_NAME,
1487                                                      NULL);
1488   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
1489
1490   renderer = gtk_cell_renderer_text_new ();
1491   column = gtk_tree_view_column_new_with_attributes (_("Location"),
1492                                                      renderer,
1493                                                      "text",
1494                                                      PRINTER_LIST_COL_LOCATION,
1495                                                      NULL);
1496   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
1497
1498   renderer = gtk_cell_renderer_text_new ();
1499   g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
1500   column = gtk_tree_view_column_new_with_attributes (_("Status"),
1501                                                      renderer,
1502                                                      "text",
1503                                                      PRINTER_LIST_COL_STATE,
1504                                                      NULL);
1505   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
1506
1507   gtk_widget_show (treeview);
1508   gtk_container_add (GTK_CONTAINER (scrolled), treeview);
1509
1510   custom_input = gtk_hbox_new (FALSE, 18);
1511   gtk_widget_show (custom_input);
1512   gtk_box_pack_start (GTK_BOX (vbox), custom_input, FALSE, FALSE, 0);
1513   priv->extension_point = custom_input;
1514
1515   hbox = gtk_hbox_new (FALSE, 18);
1516   gtk_widget_show (hbox);
1517   gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
1518
1519   table = gtk_table_new (3, 2, FALSE);
1520   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1521   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1522   frame = wrap_in_frame (_("Print Pages"), table);
1523   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
1524   gtk_widget_show (table);
1525
1526   radio = gtk_radio_button_new_with_mnemonic (NULL, _("_All"));
1527   priv->all_pages_radio = radio;
1528   gtk_widget_show (radio);
1529   gtk_table_attach (GTK_TABLE (table), radio,
1530                     0, 2, 0, 1,  GTK_FILL, 0,
1531                     0, 0);
1532   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
1533                                               _("C_urrent"));
1534   if (priv->current_page == -1)
1535     gtk_widget_set_sensitive (radio, FALSE);
1536   priv->current_page_radio = radio;
1537   gtk_widget_show (radio);
1538   gtk_table_attach (GTK_TABLE (table), radio,
1539                     0, 2, 1, 2,  GTK_FILL, 0,
1540                     0, 0);
1541
1542   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), _("Ra_nge"));
1543   gtk_tooltips_set_tip (priv->tooltips, radio, _("Specify one or more page ranges,\n e.g. 1-3,7,11"), NULL);
1544
1545   priv->page_range_radio = radio;
1546   gtk_widget_show (radio);
1547   gtk_table_attach (GTK_TABLE (table), radio,
1548                     0, 1, 2, 3,  GTK_FILL, 0,
1549                     0, 0);
1550   entry = gtk_entry_new ();
1551   priv->page_range_entry = entry;
1552   gtk_widget_show (entry);
1553   gtk_table_attach (GTK_TABLE (table), entry,
1554                     1, 2, 2, 3,  GTK_FILL, 0,
1555                     0, 0);
1556   g_signal_connect (radio, "toggled", G_CALLBACK (update_range_sensitivity), entry);
1557   update_range_sensitivity (radio, entry);
1558
1559   table = gtk_table_new (3, 2, FALSE);
1560   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1561   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1562   frame = wrap_in_frame (_("Copies"), table);
1563   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
1564   gtk_widget_show (table);
1565
1566   /* FIXME chpe: too much space between Copies and spinbutton, put those 2 in a hbox and make it span 2 columns */
1567   label = gtk_label_new_with_mnemonic (_("Copie_s:"));
1568   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1569   gtk_widget_show (label);
1570   gtk_table_attach (GTK_TABLE (table), label,
1571                     0, 1, 0, 1,  GTK_FILL, 0,
1572                     0, 0);
1573   spinbutton = gtk_spin_button_new_with_range (1.0, 100.0, 1.0);
1574   priv->copies_spin = spinbutton;
1575   gtk_widget_show (spinbutton);
1576   gtk_table_attach (GTK_TABLE (table), spinbutton,
1577                     1, 2, 0, 1,  GTK_FILL, 0,
1578                     0, 0);
1579   gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
1580   g_signal_connect_swapped (spinbutton, "value-changed",
1581                             G_CALLBACK (update_dialog_from_capabilities), dialog);
1582   g_signal_connect_swapped (spinbutton, "changed",
1583                             G_CALLBACK (update_dialog_from_capabilities), dialog);
1584
1585   check = gtk_check_button_new_with_mnemonic (_("C_ollate"));
1586   priv->collate_check = check;
1587   g_signal_connect (check, "toggled", G_CALLBACK (update_collate_icon), dialog);
1588   gtk_widget_show (check);
1589   gtk_table_attach (GTK_TABLE (table), check,
1590                     0, 1, 1, 2,  GTK_FILL, 0,
1591                     0, 0);
1592
1593   check = gtk_check_button_new_with_mnemonic (_("_Reverse"));
1594   g_signal_connect (check, "toggled", G_CALLBACK (update_collate_icon), dialog);
1595   priv->reverse_check = check;
1596   gtk_widget_show (check);
1597   gtk_table_attach (GTK_TABLE (table), check,
1598                     0, 1, 2, 3,  GTK_FILL, 0,
1599                     0, 0);
1600
1601   image = gtk_drawing_area_new ();
1602   priv->collate_image = image;
1603   gtk_widget_show (image);
1604   gtk_widget_set_size_request (image, 70, 90);
1605   gtk_table_attach (GTK_TABLE (table), image,
1606                     1, 2, 1, 3, GTK_FILL, 0,
1607                     0, 0);
1608   g_signal_connect (image, "expose-event", G_CALLBACK (draw_collate_cb), dialog);
1609
1610   label = gtk_label_new (_("General"));
1611   gtk_widget_show (label);
1612
1613   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), main_vbox, label);
1614 }
1615
1616 static gboolean
1617 is_range_separator (gchar c)
1618 {
1619   return (c == ',' || c == ';' || c == ':');
1620 }
1621
1622 static GtkPageRange *
1623 dialog_get_page_ranges (GtkPrintUnixDialog *dialog,
1624                         gint               *n_ranges_out)
1625 {
1626   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1627   gint i, n_ranges;
1628   const gchar *text, *p;
1629   gchar *next;
1630   GtkPageRange *ranges;
1631   gint start, end;
1632
1633   text = gtk_entry_get_text (GTK_ENTRY (priv->page_range_entry));
1634
1635   if (*text == 0)
1636     {
1637       *n_ranges_out = 0;
1638       return NULL;
1639     }
1640
1641   n_ranges = 1;
1642   p = text;
1643   while (*p)
1644     {
1645       if (is_range_separator (*p))
1646         n_ranges++;
1647       p++;
1648     }
1649
1650   ranges = g_new0 (GtkPageRange, n_ranges);
1651
1652   i = 0;
1653   p = text;
1654   while (*p)
1655     {
1656       while (isspace (*p)) p++;
1657
1658       if (*p == '-')
1659         {
1660           /* a half-open range like -2 */
1661           start = 1;
1662         }
1663       else
1664         {
1665           start = (int)strtol (p, &next, 10);
1666           if (start < 1)
1667             start = 1;
1668           p = next;
1669         }
1670
1671       end = start;
1672
1673       while (isspace (*p)) p++;
1674
1675       if (*p == '-')
1676         {
1677           p++;
1678           end = (int)strtol (p, &next, 10);
1679           if (next == p) /* a half-open range like 2- */
1680             end = 0;
1681           else if (end < start)
1682             end = start;
1683         }
1684
1685       ranges[i].start = start - 1;
1686       ranges[i].end = end - 1;
1687       i++;
1688
1689       /* Skip until end or separator */
1690       while (*p && !is_range_separator (*p))
1691         p++;
1692
1693       /* if not at end, skip separator */
1694       if (*p)
1695         p++;
1696     }
1697
1698   *n_ranges_out = i;
1699
1700   return ranges;
1701 }
1702
1703 static void
1704 dialog_set_page_ranges (GtkPrintUnixDialog *dialog,
1705                         GtkPageRange       *ranges,
1706                         gint                n_ranges)
1707 {
1708   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1709   gint i;
1710   GString *s = g_string_new ("");
1711
1712   for (i = 0; i < n_ranges; i++)
1713     {
1714       g_string_append_printf (s, "%d", ranges[i].start + 1);
1715       if (ranges[i].end > ranges[i].start)
1716         g_string_append_printf (s, "-%d", ranges[i].end + 1);
1717       else if (ranges[i].end == -1)
1718         g_string_append (s, "-");
1719
1720       if (i != n_ranges - 1)
1721         g_string_append (s, ",");
1722     }
1723
1724   gtk_entry_set_text (GTK_ENTRY (priv->page_range_entry), s->str);
1725
1726   g_string_free (s, TRUE);
1727 }
1728
1729
1730 static GtkPrintPages
1731 dialog_get_print_pages (GtkPrintUnixDialog *dialog)
1732 {
1733   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1734
1735   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->all_pages_radio)))
1736     return GTK_PRINT_PAGES_ALL;
1737   else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->current_page_radio)))
1738     return GTK_PRINT_PAGES_CURRENT;
1739   else
1740     return GTK_PRINT_PAGES_RANGES;
1741 }
1742
1743 static void
1744 dialog_set_print_pages (GtkPrintUnixDialog *dialog,
1745                         GtkPrintPages       pages)
1746 {
1747   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1748
1749   if (pages == GTK_PRINT_PAGES_RANGES)
1750     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->page_range_radio), TRUE);
1751   else if (pages == GTK_PRINT_PAGES_CURRENT)
1752     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->current_page_radio), TRUE);
1753   else
1754     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_pages_radio), TRUE);
1755 }
1756
1757 static gdouble
1758 dialog_get_scale (GtkPrintUnixDialog *dialog)
1759 {
1760   if (GTK_WIDGET_IS_SENSITIVE (dialog->priv->scale_spin))
1761     return gtk_spin_button_get_value (GTK_SPIN_BUTTON (dialog->priv->scale_spin));
1762   else
1763     return 100.0;
1764 }
1765
1766 static void
1767 dialog_set_scale (GtkPrintUnixDialog *dialog,
1768                   gdouble             val)
1769 {
1770   gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->priv->scale_spin), val);
1771 }
1772
1773 static GtkPageSet
1774 dialog_get_page_set (GtkPrintUnixDialog *dialog)
1775 {
1776   if (GTK_WIDGET_IS_SENSITIVE (dialog->priv->page_set_combo))
1777     return (GtkPageSet)gtk_combo_box_get_active (GTK_COMBO_BOX (dialog->priv->page_set_combo));
1778   else
1779     return GTK_PAGE_SET_ALL;
1780 }
1781
1782 static void
1783 dialog_set_page_set (GtkPrintUnixDialog *dialog,
1784                      GtkPageSet          val)
1785 {
1786   gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->priv->page_set_combo),
1787                             (int)val);
1788 }
1789
1790 static gint
1791 dialog_get_n_copies (GtkPrintUnixDialog *dialog)
1792 {
1793   if (GTK_WIDGET_IS_SENSITIVE (dialog->priv->copies_spin))
1794     return gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dialog->priv->copies_spin));
1795   return 1;
1796 }
1797
1798 static void
1799 dialog_set_n_copies (GtkPrintUnixDialog *dialog,
1800                      gint                n_copies)
1801 {
1802   gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->priv->copies_spin),
1803                              n_copies);
1804 }
1805
1806 static gboolean
1807 dialog_get_collate (GtkPrintUnixDialog *dialog)
1808 {
1809   if (GTK_WIDGET_IS_SENSITIVE (dialog->priv->collate_check))
1810     return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->collate_check));
1811   return FALSE;
1812 }
1813
1814 static void
1815 dialog_set_collate (GtkPrintUnixDialog *dialog,
1816                     gboolean            collate)
1817 {
1818   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->collate_check),
1819                                 collate);
1820 }
1821
1822 static gboolean
1823 dialog_get_reverse (GtkPrintUnixDialog *dialog)
1824 {
1825   if (GTK_WIDGET_IS_SENSITIVE (dialog->priv->reverse_check))
1826     return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->priv->reverse_check));
1827   return FALSE;
1828 }
1829
1830 static void
1831 dialog_set_reverse (GtkPrintUnixDialog *dialog,
1832                     gboolean            reverse)
1833 {
1834   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->reverse_check),
1835                                 reverse);
1836 }
1837
1838 static gint
1839 dialog_get_pages_per_sheet (GtkPrintUnixDialog *dialog)
1840 {
1841   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1842   const gchar *val;
1843   gint num;
1844
1845   val = gtk_printer_option_widget_get_value (priv->pages_per_sheet);
1846
1847   num = 1;
1848
1849   if (val)
1850     {
1851       num = atoi(val);
1852       if (num < 1)
1853         num = 1;
1854     }
1855
1856   return num;
1857 }
1858
1859
1860 static gboolean
1861 draw_page_cb (GtkWidget          *widget,
1862               GdkEventExpose     *event,
1863               GtkPrintUnixDialog *dialog)
1864 {
1865   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1866   cairo_t *cr;
1867   gdouble ratio;
1868   gint w, h, tmp, shadow_offset;
1869   gint pages_x, pages_y, i, x, y, layout_w, layout_h;
1870   gdouble page_width, page_height;
1871   GtkPageOrientation orientation;
1872   gboolean landscape;
1873   PangoLayout *layout;
1874   PangoFontDescription *font;
1875   gchar *text;
1876   GdkColor *color;
1877
1878   orientation = gtk_page_setup_get_orientation (priv->page_setup);
1879   landscape =
1880     (orientation == GTK_PAGE_ORIENTATION_LANDSCAPE) ||
1881     (orientation == GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE);
1882
1883   cr = gdk_cairo_create (widget->window);
1884
1885   ratio = G_SQRT2;
1886
1887   w = (EXAMPLE_PAGE_AREA_SIZE - 3) / ratio;
1888   h = w * ratio;
1889
1890   switch (dialog_get_pages_per_sheet (dialog))
1891     {
1892     default:
1893     case 1:
1894       pages_x = 1; pages_y = 1;
1895       break;
1896     case 2:
1897       landscape = !landscape;
1898       pages_x = 1; pages_y = 2;
1899       break;
1900     case 4:
1901       pages_x = 2; pages_y = 2;
1902       break;
1903     case 6:
1904       landscape = !landscape;
1905       pages_x = 2; pages_y = 3;
1906       break;
1907     case 9:
1908       pages_x = 3; pages_y = 3;
1909       break;
1910     case 16:
1911       pages_x = 4; pages_y = 4;
1912       break;
1913     }
1914
1915   if (landscape)
1916     {
1917       tmp = w;
1918       w = h;
1919       h = tmp;
1920
1921       tmp = pages_x;
1922       pages_x = pages_y;
1923       pages_y = tmp;
1924     }
1925
1926   shadow_offset = 3;
1927
1928   color = &widget->style->text[GTK_STATE_NORMAL];
1929   cairo_set_source_rgba (cr, color->red / 65535., color->green / 65535., color->blue / 65535, 0.5);
1930   cairo_rectangle (cr, shadow_offset + 1, shadow_offset + 1, w, h);
1931   cairo_fill (cr);
1932
1933   gdk_cairo_set_source_color (cr, &widget->style->base[GTK_STATE_NORMAL]);
1934   cairo_rectangle (cr, 1, 1, w, h);
1935   cairo_fill (cr);
1936   cairo_set_line_width (cr, 1.0);
1937   cairo_rectangle (cr, 0.5, 0.5, w+1, h+1);
1938
1939   gdk_cairo_set_source_color (cr, &widget->style->text[GTK_STATE_NORMAL]);
1940   cairo_stroke (cr);
1941
1942   i = 1;
1943
1944   page_width = (double)w / pages_x;
1945   page_height = (double)h / pages_y;
1946
1947   layout  = pango_cairo_create_layout (cr);
1948
1949   font = pango_font_description_new ();
1950   pango_font_description_set_family (font, "sans");
1951   pango_font_description_set_absolute_size (font, page_height * 0.4 * PANGO_SCALE);
1952   pango_layout_set_font_description (layout, font);
1953   pango_font_description_free (font);
1954
1955   pango_layout_set_width (layout, page_width * PANGO_SCALE);
1956   pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
1957
1958   for (y = 0; y < pages_y; y++)
1959     {
1960       for (x = 0; x < pages_x; x++)
1961         {
1962           text = g_strdup_printf ("%d", i++);
1963           pango_layout_set_text (layout, text, -1);
1964           g_free (text);
1965           pango_layout_get_size (layout, &layout_w, &layout_h);
1966           cairo_save (cr);
1967           cairo_translate (cr,
1968                            x * page_width,
1969                            y * page_height + (page_height - layout_h / 1024.0) / 2
1970                            );
1971
1972           pango_cairo_show_layout (cr, layout);
1973           cairo_restore (cr);
1974         }
1975     }
1976
1977   cairo_destroy (cr);
1978
1979   return TRUE;
1980 }
1981
1982 static void
1983 redraw_page_layout_preview (GtkPrintUnixDialog *dialog)
1984 {
1985   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1986
1987   if (priv->page_layout_preview)
1988     gtk_widget_queue_draw (priv->page_layout_preview);
1989 }
1990
1991 static void
1992 create_page_setup_page (GtkPrintUnixDialog *dialog)
1993 {
1994   GtkPrintUnixDialogPrivate *priv = dialog->priv;
1995   GtkWidget *main_vbox, *label, *hbox, *hbox2;
1996   GtkWidget *frame, *table, *widget;
1997   GtkWidget *combo, *spinbutton, *draw;
1998
1999   main_vbox = gtk_vbox_new (FALSE, 18);
2000   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
2001   gtk_widget_show (main_vbox);
2002
2003   hbox = gtk_hbox_new (FALSE, 18);
2004   gtk_widget_show (hbox);
2005   gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
2006
2007   table = gtk_table_new (5, 2, FALSE);
2008   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2009   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2010   frame = wrap_in_frame (_("Layout"), table);
2011   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
2012   gtk_widget_show (table);
2013
2014   label = gtk_label_new_with_mnemonic (_("Pages per _side:"));
2015   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2016   gtk_widget_show (label);
2017   gtk_table_attach (GTK_TABLE (table), label,
2018                     0, 1, 0, 1,  GTK_FILL, 0,
2019                     0, 0);
2020
2021   widget = gtk_printer_option_widget_new (NULL);
2022   g_signal_connect_swapped (widget, "changed", G_CALLBACK (redraw_page_layout_preview), dialog);
2023   priv->pages_per_sheet = GTK_PRINTER_OPTION_WIDGET (widget);
2024   gtk_widget_show (widget);
2025   gtk_table_attach (GTK_TABLE (table), widget,
2026                     1, 2, 0, 1,  GTK_FILL, 0,
2027                     0, 0);
2028   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2029
2030   label = gtk_label_new_with_mnemonic (_("T_wo-sided:"));
2031   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2032   gtk_widget_show (label);
2033   gtk_table_attach (GTK_TABLE (table), label,
2034                     0, 1, 1, 2,  GTK_FILL, 0,
2035                     0, 0);
2036
2037   widget = gtk_printer_option_widget_new (NULL);
2038   priv->duplex = GTK_PRINTER_OPTION_WIDGET (widget);
2039   gtk_widget_show (widget);
2040   gtk_table_attach (GTK_TABLE (table), widget,
2041                     1, 2, 1, 2,  GTK_FILL, 0,
2042                     0, 0);
2043   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2044
2045   label = gtk_label_new_with_mnemonic (_("_Only print:"));
2046   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2047   gtk_widget_show (label);
2048   gtk_table_attach (GTK_TABLE (table), label,
2049                     0, 1, 2, 3,  GTK_FILL, 0,
2050                     0, 0);
2051
2052   combo = gtk_combo_box_new_text ();
2053   priv->page_set_combo = combo;
2054   gtk_widget_show (combo);
2055   gtk_table_attach (GTK_TABLE (table), combo,
2056                     1, 2, 2, 3,  GTK_FILL, 0,
2057                     0, 0);
2058   gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
2059   /* In enum order */
2060   gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("All sheets"));
2061   gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Even sheets"));
2062   gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _("Odd sheets"));
2063   gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
2064
2065   label = gtk_label_new_with_mnemonic (_("Sc_ale:"));
2066   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2067   gtk_widget_show (label);
2068   gtk_table_attach (GTK_TABLE (table), label,
2069                     0, 1, 3, 4,  GTK_FILL, 0,
2070                     0, 0);
2071
2072   hbox2 = gtk_hbox_new (FALSE, 6);
2073   gtk_widget_show (hbox2);
2074   gtk_table_attach (GTK_TABLE (table), hbox2,
2075                     1, 2, 3, 4,  GTK_FILL, 0,
2076                     0, 0);
2077
2078   spinbutton = gtk_spin_button_new_with_range (1.0, 1000.0, 1.0);
2079   priv->scale_spin = spinbutton;
2080   gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinbutton), 1);
2081   gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinbutton), 100.0);
2082   gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0);
2083   gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
2084   gtk_widget_show (spinbutton);
2085   label = gtk_label_new ("%"); /* FIXMEchpe does there exist any language where % needs to be translated? */
2086   gtk_widget_show (label);
2087   gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
2088
2089   table = gtk_table_new (4, 2, FALSE);
2090   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2091   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2092   frame = wrap_in_frame (_("Paper"), table);
2093   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 6);
2094   gtk_widget_show (table);
2095
2096   label = gtk_label_new_with_mnemonic (_("Paper _type:"));
2097   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2098   gtk_widget_show (label);
2099   gtk_table_attach (GTK_TABLE (table), label,
2100                     0, 1, 0, 1,  GTK_FILL, 0,
2101                     0, 0);
2102
2103   widget = gtk_printer_option_widget_new (NULL);
2104   priv->paper_type = GTK_PRINTER_OPTION_WIDGET (widget);
2105   gtk_widget_show (widget);
2106   gtk_table_attach (GTK_TABLE (table), widget,
2107                     1, 2, 0, 1,  GTK_FILL, 0,
2108                     0, 0);
2109   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2110
2111   label = gtk_label_new_with_mnemonic (_("Paper _source:"));
2112   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2113   gtk_widget_show (label);
2114   gtk_table_attach (GTK_TABLE (table), label,
2115                     0, 1, 1, 2,  GTK_FILL, 0,
2116                     0, 0);
2117
2118   widget = gtk_printer_option_widget_new (NULL);
2119   priv->paper_source = GTK_PRINTER_OPTION_WIDGET (widget);
2120   gtk_widget_show (widget);
2121   gtk_table_attach (GTK_TABLE (table), widget,
2122                     1, 2, 1, 2,  GTK_FILL, 0,
2123                     0, 0);
2124   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2125
2126   label = gtk_label_new_with_mnemonic (_("Output t_ray:"));
2127   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2128   gtk_widget_show (label);
2129   gtk_table_attach (GTK_TABLE (table), label,
2130                     0, 1, 2, 3,  GTK_FILL, 0,
2131                     0, 0);
2132
2133   widget = gtk_printer_option_widget_new (NULL);
2134   priv->output_tray = GTK_PRINTER_OPTION_WIDGET (widget);
2135   gtk_widget_show (widget);
2136   gtk_table_attach (GTK_TABLE (table), widget,
2137                     1, 2, 2, 3,  GTK_FILL, 0,
2138                     0, 0);
2139   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2140
2141   /* Add the page layout preview */
2142   hbox2 = gtk_hbox_new (FALSE, 0);
2143   gtk_widget_show (hbox2);
2144   gtk_box_pack_start (GTK_BOX (main_vbox), hbox2, TRUE, TRUE, 0);
2145
2146   draw = gtk_drawing_area_new ();
2147   priv->page_layout_preview = draw;
2148   gtk_widget_set_size_request (draw, 200, 200);
2149   g_signal_connect (draw, "expose-event", G_CALLBACK (draw_page_cb), dialog);
2150   gtk_widget_show (draw);
2151
2152   gtk_box_pack_start (GTK_BOX (hbox2), draw, TRUE, FALSE, 0);
2153
2154   label = gtk_label_new (_("Page Setup"));
2155   gtk_widget_show (label);
2156
2157   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
2158                             main_vbox, label);
2159 }
2160
2161 static void
2162 create_job_page (GtkPrintUnixDialog *dialog)
2163 {
2164   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2165   GtkWidget *main_table, *label;
2166   GtkWidget *frame, *table, *radio;
2167   GtkWidget *entry, *widget;
2168
2169   main_table = gtk_table_new (2, 2, FALSE);
2170   gtk_container_set_border_width (GTK_CONTAINER (main_table), 12);
2171   gtk_table_set_row_spacings (GTK_TABLE (main_table), 18);
2172   gtk_table_set_col_spacings (GTK_TABLE (main_table), 18);
2173
2174   table = gtk_table_new (2, 2, FALSE);
2175   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2176   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2177   frame = wrap_in_frame (_("Job Details"), table);
2178   gtk_table_attach (GTK_TABLE (main_table), frame,
2179                     0, 1, 0, 1,  GTK_FILL, 0,
2180                     0, 0);
2181   gtk_widget_show (table);
2182
2183   label = gtk_label_new_with_mnemonic (_("Pri_ority:"));
2184   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2185   gtk_widget_show (label);
2186   gtk_table_attach (GTK_TABLE (table), label,
2187                     0, 1, 0, 1,  GTK_FILL, 0,
2188                     0, 0);
2189
2190   widget = gtk_printer_option_widget_new (NULL);
2191   priv->job_prio = GTK_PRINTER_OPTION_WIDGET (widget);
2192   gtk_widget_show (widget);
2193   gtk_table_attach (GTK_TABLE (table), widget,
2194                     1, 2, 0, 1,  GTK_FILL, 0,
2195                     0, 0);
2196   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2197
2198   label = gtk_label_new_with_mnemonic (_("_Billing info:"));
2199   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2200   gtk_widget_show (label);
2201   gtk_table_attach (GTK_TABLE (table), label,
2202                     0, 1, 1, 2,  GTK_FILL, 0,
2203                     0, 0);
2204
2205   widget = gtk_printer_option_widget_new (NULL);
2206   priv->billing_info = GTK_PRINTER_OPTION_WIDGET (widget);
2207   gtk_widget_show (widget);
2208   gtk_table_attach (GTK_TABLE (table), widget,
2209                     1, 2, 1, 2,  GTK_FILL, 0,
2210                     0, 0);
2211   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2212
2213   table = gtk_table_new (2, 2, FALSE);
2214   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2215   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2216   frame = wrap_in_frame (_("Print Document"), table);
2217   gtk_table_attach (GTK_TABLE (main_table), frame,
2218                     0, 1, 1, 2,  GTK_FILL, 0,
2219                     0, 0);
2220   gtk_widget_show (table);
2221
2222   radio = gtk_radio_button_new_with_mnemonic (NULL, _("_Now"));
2223   priv->print_now_radio = radio;
2224   gtk_widget_show (radio);
2225   gtk_table_attach (GTK_TABLE (table), radio,
2226                     0, 2, 0, 1,  GTK_FILL, 0,
2227                     0, 0);
2228   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
2229                                               _("A_t:"));
2230   priv->print_at_radio = radio;
2231   gtk_widget_show (radio);
2232   gtk_table_attach (GTK_TABLE (table), radio,
2233                     0, 1, 1, 2,  GTK_FILL, 0,
2234                     0, 0);
2235
2236   entry = gtk_entry_new ();
2237   priv->print_at_entry = entry;
2238   gtk_widget_show (entry);
2239   gtk_table_attach (GTK_TABLE (table), entry,
2240                     1, 2, 1, 2,  GTK_FILL, 0,
2241                     0, 0);
2242
2243   radio = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)),
2244                                               _("On _hold"));
2245   priv->print_hold_radio = radio;
2246   gtk_widget_show (radio);
2247   gtk_table_attach (GTK_TABLE (table), radio,
2248                     0, 2, 2, 3,  GTK_FILL, 0,
2249                     0, 0);
2250
2251   g_signal_connect_swapped (priv->print_now_radio, "toggled",
2252                             G_CALLBACK (update_print_at_option), dialog);
2253   g_signal_connect_swapped (priv->print_at_radio, "toggled",
2254                             G_CALLBACK (update_print_at_option), dialog);
2255   g_signal_connect_swapped (priv->print_at_entry, "changed",
2256                             G_CALLBACK (update_print_at_option), dialog);
2257   g_signal_connect_swapped (priv->print_hold_radio, "toggled",
2258                             G_CALLBACK (update_print_at_option), dialog);
2259
2260   table = gtk_table_new (2, 2, FALSE);
2261   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2262   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2263   frame = wrap_in_frame (_("Add Cover Page"), table);
2264   gtk_table_attach (GTK_TABLE (main_table), frame,
2265                     1, 2, 0, 1,  GTK_FILL, 0,
2266                     0, 0);
2267   gtk_widget_show (table);
2268
2269   label = gtk_label_new_with_mnemonic (_("Be_fore:"));
2270   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2271   gtk_widget_show (label);
2272   gtk_table_attach (GTK_TABLE (table), label,
2273                     0, 1, 0, 1,  GTK_FILL, 0,
2274                     0, 0);
2275
2276   widget = gtk_printer_option_widget_new (NULL);
2277   priv->cover_before = GTK_PRINTER_OPTION_WIDGET (widget);
2278   gtk_widget_show (widget);
2279   gtk_table_attach (GTK_TABLE (table), widget,
2280                     1, 2, 0, 1,  GTK_FILL, 0,
2281                     0, 0);
2282   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2283
2284   label = gtk_label_new_with_mnemonic (_("_After:"));
2285   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2286   gtk_widget_show (label);
2287   gtk_table_attach (GTK_TABLE (table), label,
2288                     0, 1, 1, 2,  GTK_FILL, 0,
2289                     0, 0);
2290
2291   widget = gtk_printer_option_widget_new (NULL);
2292   priv->cover_after = GTK_PRINTER_OPTION_WIDGET (widget);
2293   gtk_widget_show (widget);
2294   gtk_table_attach (GTK_TABLE (table), widget,
2295                     1, 2, 1, 2,  GTK_FILL, 0,
2296                     0, 0);
2297   gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
2298
2299   label = gtk_label_new (_("Job"));
2300   gtk_widget_show (label);
2301
2302   priv->job_page = main_table;
2303   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
2304                             main_table, label);
2305 }
2306
2307 static void
2308 create_optional_page (GtkPrintUnixDialog  *dialog,
2309                       const gchar         *text,
2310                       GtkWidget          **table_out,
2311                       GtkWidget          **page_out)
2312 {
2313   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2314   GtkWidget *table, *label, *scrolled;
2315
2316   scrolled = gtk_scrolled_window_new (NULL, NULL);
2317   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
2318                                   GTK_POLICY_NEVER,
2319                                   GTK_POLICY_AUTOMATIC);
2320
2321   table = gtk_table_new (1, 2, FALSE);
2322   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
2323   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
2324   gtk_container_set_border_width (GTK_CONTAINER (table), 12);
2325   gtk_widget_show (table);
2326
2327   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
2328                                          table);
2329   gtk_viewport_set_shadow_type (GTK_VIEWPORT (GTK_BIN(scrolled)->child),
2330                                 GTK_SHADOW_NONE);
2331
2332   label = gtk_label_new (text);
2333   gtk_widget_show (label);
2334
2335   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
2336                             scrolled, label);
2337
2338   *table_out = table;
2339   *page_out = scrolled;
2340 }
2341
2342 static void
2343 create_advanced_page (GtkPrintUnixDialog *dialog)
2344 {
2345   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2346   GtkWidget *main_vbox, *label, *scrolled;
2347
2348   scrolled = gtk_scrolled_window_new (NULL, NULL);
2349   priv->advanced_page = scrolled;
2350   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
2351                                   GTK_POLICY_NEVER,
2352                                   GTK_POLICY_AUTOMATIC);
2353
2354   main_vbox = gtk_vbox_new (FALSE, 18);
2355   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
2356   gtk_widget_show (main_vbox);
2357
2358   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
2359                                          main_vbox);
2360   gtk_viewport_set_shadow_type (GTK_VIEWPORT (GTK_BIN(scrolled)->child),
2361                                 GTK_SHADOW_NONE);
2362
2363   priv->advanced_vbox = main_vbox;
2364
2365   label = gtk_label_new (_("Advanced"));
2366   gtk_widget_show (label);
2367
2368   gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
2369                             scrolled, label);
2370 }
2371
2372
2373 static void
2374 populate_dialog (GtkPrintUnixDialog *print_dialog)
2375 {
2376   GtkPrintUnixDialogPrivate *priv = print_dialog->priv;
2377   GtkDialog *dialog = GTK_DIALOG (print_dialog);
2378   GtkWidget *vbox, *conflict_hbox, *image, *label;
2379
2380   gtk_dialog_set_has_separator (dialog, FALSE);
2381   gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
2382   gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
2383   gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
2384   gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
2385
2386   vbox = gtk_vbox_new (FALSE, 6);
2387   gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2388   gtk_box_pack_start (GTK_BOX (dialog->vbox), vbox, TRUE, TRUE, 0);
2389   gtk_widget_show (vbox);
2390
2391   priv->notebook = gtk_notebook_new ();
2392   gtk_box_pack_start (GTK_BOX (vbox), priv->notebook, TRUE, TRUE, 0);
2393   gtk_widget_show (priv->notebook);
2394
2395   create_printer_list_model (print_dialog);
2396
2397   create_main_page (print_dialog);
2398   create_page_setup_page (print_dialog);
2399   create_job_page (print_dialog);
2400   create_optional_page (print_dialog, _("Image Quality"),
2401                         &priv->image_quality_table,
2402                         &priv->image_quality_page);
2403   create_optional_page (print_dialog, _("Color"),
2404                         &priv->color_table,
2405                         &priv->color_page);
2406   create_optional_page (print_dialog, _("Finishing"),
2407                         &priv->finishing_table,
2408                         &priv->finishing_page);
2409   create_advanced_page (print_dialog);
2410
2411   priv->conflicts_widget = conflict_hbox = gtk_hbox_new (FALSE, 12);
2412   gtk_box_pack_end (GTK_BOX (vbox), conflict_hbox, FALSE, FALSE, 0);
2413   image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU);
2414   gtk_widget_show (image);
2415   gtk_box_pack_start (GTK_BOX (conflict_hbox), image, FALSE, TRUE, 0);
2416   label = gtk_label_new (_("Some of the settings in the dialog conflict"));
2417   gtk_widget_show (label);
2418   gtk_box_pack_start (GTK_BOX (conflict_hbox), label, FALSE, TRUE, 0);
2419
2420   load_print_backends (print_dialog);
2421 }
2422
2423 /**
2424  * gtk_print_unix_dialog_new:
2425  * @title: Title of the dialog, or %NULL
2426  * @parent: Transient parent of the dialog, or %NULL
2427  *
2428  * Creates a new #GtkPrintUnixDialog.
2429  *
2430  * Return value: a new #GtkPrintUnixDialog
2431  *
2432  * Since: 2.10
2433  **/
2434 GtkWidget *
2435 gtk_print_unix_dialog_new (const gchar *title,
2436                            GtkWindow   *parent)
2437 {
2438   GtkWidget *result;
2439   const gchar *_title = _("Print");
2440
2441   if (title)
2442     _title = title;
2443
2444   result = g_object_new (GTK_TYPE_PRINT_UNIX_DIALOG,
2445                          "transient-for", parent,
2446                          "title", _title,
2447                          "has-separator", FALSE,
2448                          NULL);
2449
2450   return result;
2451 }
2452
2453 /**
2454  * gtk_print_unix_dialog_get_selected_printer:
2455  * @dialog: a #GtkPrintUnixDialog
2456  *
2457  * Gets the currently selected printer.
2458  *
2459  * Returns: the currently selected printer
2460  *
2461  * Since: 2.10
2462  */
2463 GtkPrinter *
2464 gtk_print_unix_dialog_get_selected_printer (GtkPrintUnixDialog *dialog)
2465 {
2466   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
2467
2468   return dialog->priv->current_printer;
2469 }
2470
2471 /**
2472  * gtk_print_unix_dialog_set_page_setup:
2473  * @dialog: a #GtkPrintUnixDialog
2474  * @page_setup: a #GtkPageSetup
2475  *
2476  * Sets the page setup of the #GtkPrintUnixDialog.
2477  *
2478  * Since: 2.10
2479  */
2480 void
2481 gtk_print_unix_dialog_set_page_setup (GtkPrintUnixDialog *dialog,
2482                                       GtkPageSetup       *page_setup)
2483 {
2484   GtkPrintUnixDialogPrivate *priv;
2485
2486   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
2487   g_return_if_fail (GTK_IS_PAGE_SETUP (page_setup));
2488
2489   priv = dialog->priv;
2490
2491   if (priv->page_setup != page_setup)
2492     {
2493       g_object_unref (priv->page_setup);
2494       priv->page_setup = g_object_ref (page_setup);
2495
2496       g_object_notify (G_OBJECT (dialog), "page-setup");
2497     }
2498 }
2499
2500 /**
2501  * gtk_print_unix_dialog_get_page_setup:
2502  * @dialog: a #GtkPrintUnixDialog
2503  *
2504  * Gets the page setup that is used by the #GtkPrintUnixDialog.
2505  *
2506  * Returns: the page setup of @dialog.
2507  *
2508  * Since: 2.10
2509  */
2510 GtkPageSetup *
2511 gtk_print_unix_dialog_get_page_setup (GtkPrintUnixDialog *dialog)
2512 {
2513   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
2514
2515   return dialog->priv->page_setup;
2516 }
2517
2518 /**
2519  * gtk_print_unix_dialog_set_current_page:
2520  * @dialog: a #GtkPrintUnixDialog
2521  * @current_page: the current page number.
2522  *
2523  * Sets the current page number. If @current_page is not -1, this enables
2524  * the current page choice for the range of pages to print.
2525  *
2526  * Since: 2.10
2527  */
2528 void
2529 gtk_print_unix_dialog_set_current_page (GtkPrintUnixDialog *dialog,
2530                                         gint                current_page)
2531 {
2532   GtkPrintUnixDialogPrivate *priv;
2533
2534   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
2535
2536   priv = dialog->priv;
2537
2538   if (priv->current_page != current_page)
2539     {
2540       priv->current_page = current_page;
2541
2542       if (priv->current_page_radio)
2543         gtk_widget_set_sensitive (priv->current_page_radio, current_page != -1);
2544
2545       g_object_notify (G_OBJECT (dialog), "current-page");
2546     }
2547 }
2548
2549 /**
2550  * gtk_print_unix_dialog_get_current_page:
2551  * @dialog: a #GtkPrintUnixDialog
2552  *
2553  * Gets the current page of the #GtkPrintDialog.
2554  *
2555  * Returns: the current page of @dialog
2556  *
2557  * Since: 2.10
2558  */
2559 gint
2560 gtk_print_unix_dialog_get_current_page (GtkPrintUnixDialog *dialog)
2561 {
2562   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), -1);
2563
2564   return dialog->priv->current_page;
2565 }
2566
2567 static gboolean
2568 set_active_printer (GtkPrintUnixDialog *dialog,
2569                     const gchar        *printer_name)
2570 {
2571   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2572   GtkTreeModel *model;
2573   GtkTreeIter iter, filter_iter;
2574   GtkTreeSelection *selection;
2575   GtkPrinter *printer;
2576
2577   model = GTK_TREE_MODEL (priv->printer_list);
2578
2579   if (gtk_tree_model_get_iter_first (model, &iter))
2580     {
2581       do
2582         {
2583           gtk_tree_model_get (GTK_TREE_MODEL (priv->printer_list), &iter,
2584                               PRINTER_LIST_COL_PRINTER_OBJ, &printer, -1);
2585           if (printer == NULL)
2586             continue;
2587
2588           if (strcmp (gtk_printer_get_name (printer), printer_name) == 0)
2589             {
2590               gtk_tree_model_filter_convert_child_iter_to_iter (priv->printer_list_filter,
2591                                                                 &filter_iter, &iter);
2592
2593               selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
2594               priv->internal_printer_change = TRUE;
2595               gtk_tree_selection_select_iter (selection, &filter_iter);
2596               priv->internal_printer_change = FALSE;
2597               g_free (priv->waiting_for_printer);
2598               priv->waiting_for_printer = NULL;
2599
2600               g_object_unref (printer);
2601               return TRUE;
2602             }
2603
2604           g_object_unref (printer);
2605
2606         } while (gtk_tree_model_iter_next (model, &iter));
2607     }
2608
2609   return FALSE;
2610 }
2611
2612 /**
2613  * gtk_print_unix_dialog_set_settings:
2614  * @dialog: a #GtkPrintUnixDialog
2615  * @settings: a #GtkPrintSettings, or %NULL
2616  *
2617  * Sets the #GtkPrintSettings for the #GtkPrintUnixDialog. Typically,
2618  * this is used to restore saved print settings from a previous print
2619  * operation before the print dialog is shown.
2620  *
2621  * Since: 2.10
2622  **/
2623 void
2624 gtk_print_unix_dialog_set_settings (GtkPrintUnixDialog *dialog,
2625                                     GtkPrintSettings   *settings)
2626 {
2627   GtkPrintUnixDialogPrivate *priv;
2628   const gchar *printer;
2629   GtkPageRange *ranges;
2630   gint num_ranges;
2631
2632   g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
2633   g_return_if_fail (settings == NULL || GTK_IS_PRINT_SETTINGS (settings));
2634
2635   priv = dialog->priv;
2636
2637   if (settings != NULL)
2638     {
2639       dialog_set_collate (dialog, gtk_print_settings_get_collate (settings));
2640       dialog_set_reverse (dialog, gtk_print_settings_get_reverse (settings));
2641       dialog_set_n_copies (dialog, gtk_print_settings_get_n_copies (settings));
2642       dialog_set_scale (dialog, gtk_print_settings_get_scale (settings));
2643       dialog_set_page_set (dialog, gtk_print_settings_get_page_set (settings));
2644       dialog_set_print_pages (dialog, gtk_print_settings_get_print_pages (settings));
2645       ranges = gtk_print_settings_get_page_ranges (settings, &num_ranges);
2646       if (ranges)
2647         {
2648           dialog_set_page_ranges (dialog, ranges, num_ranges);
2649           g_free (ranges);
2650         }
2651
2652       priv->format_for_printer =
2653         g_strdup (gtk_print_settings_get (settings, "format-for-printer"));
2654     }
2655
2656   if (priv->initial_settings)
2657     g_object_unref (priv->initial_settings);
2658
2659   priv->initial_settings = settings;
2660
2661   g_free (priv->waiting_for_printer);
2662   priv->waiting_for_printer = NULL;
2663
2664   if (settings)
2665     {
2666       g_object_ref (settings);
2667
2668       printer = gtk_print_settings_get_printer (settings);
2669
2670       if (printer && !set_active_printer (dialog, printer))
2671         priv->waiting_for_printer = g_strdup (printer);
2672     }
2673
2674   g_object_notify (G_OBJECT (dialog), "print-settings");
2675 }
2676
2677 /**
2678  * gtk_print_unix_dialog_get_settings:
2679  * @dialog: a #GtkPrintUnixDialog
2680  *
2681  * Gets a new #GtkPrintSettings object that represents the
2682  * current values in the print dialog. Note that this creates a
2683  * <emphasis>new object</emphasis>, and you need to unref it
2684  * if don't want to keep it.
2685  *
2686  * Returns: a new #GtkPrintSettings object with the values from @dialog
2687  *
2688  * Since: 2.10
2689  */
2690 GtkPrintSettings *
2691 gtk_print_unix_dialog_get_settings (GtkPrintUnixDialog *dialog)
2692 {
2693   GtkPrintUnixDialogPrivate *priv;
2694   GtkPrintSettings *settings;
2695   GtkPrintPages print_pages;
2696   GtkPageRange *ranges;
2697   gint n_ranges;
2698
2699   g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
2700
2701   priv = dialog->priv;
2702   settings = gtk_print_settings_new ();
2703
2704   if (priv->current_printer)
2705     gtk_print_settings_set_printer (settings,
2706                                     gtk_printer_get_name (priv->current_printer));
2707   else
2708     gtk_print_settings_set_printer (settings, "default");
2709
2710   gtk_print_settings_set (settings, "format-for-printer",
2711                           priv->format_for_printer);
2712
2713
2714   gtk_print_settings_set_collate (settings,
2715                                   dialog_get_collate (dialog));
2716
2717   gtk_print_settings_set_reverse (settings,
2718                                   dialog_get_reverse (dialog));
2719
2720   gtk_print_settings_set_n_copies (settings,
2721                                    dialog_get_n_copies (dialog));
2722
2723   gtk_print_settings_set_scale (settings,
2724                                 dialog_get_scale (dialog));
2725
2726   gtk_print_settings_set_page_set (settings,
2727                                    dialog_get_page_set (dialog));
2728
2729   print_pages = dialog_get_print_pages (dialog);
2730   gtk_print_settings_set_print_pages (settings, print_pages);
2731
2732   ranges = dialog_get_page_ranges (dialog, &n_ranges);
2733   if (ranges)
2734     {
2735       gtk_print_settings_set_page_ranges  (settings, ranges, n_ranges);
2736       g_free (ranges);
2737     }
2738
2739   /* TODO: print when. How to handle? */
2740
2741   if (priv->current_printer)
2742     _gtk_printer_get_settings_from_options (priv->current_printer,
2743                                             priv->options,
2744                                             settings);
2745
2746   return settings;
2747 }
2748
2749 /**
2750  * gtk_print_unix_dialog_add_custom_tab:
2751  * @dialog: a #GtkPrintUnixDialog
2752  * @child: the widget to put in the custom tab
2753  * @tab_label: the widget to use as tab label
2754  *
2755  * Adds a custom tab to the print dialog.
2756  *
2757  * Since: 2.10
2758  */
2759 void
2760 gtk_print_unix_dialog_add_custom_tab (GtkPrintUnixDialog *dialog,
2761                                       GtkWidget          *child,
2762                                       GtkWidget          *tab_label)
2763 {
2764   gtk_notebook_insert_page (GTK_NOTEBOOK (dialog->priv->notebook),
2765                             child, tab_label, 2);
2766   gtk_widget_show (child);
2767   gtk_widget_show (tab_label);
2768 }
2769
2770 /**
2771  * gtk_print_unix_dialog_set_manual_capabilities:
2772  * @dialog: a #GtkPrintUnixDialog
2773  * @capabilities: the printing capabilities of your application
2774  *
2775  * This lets you specify the printing capabilities your application
2776  * supports. For instance, if you can handle scaling the output then
2777  * you pass #GTK_PRINT_CAPABILITY_SCALE. If you don't pass that, then
2778  * the dialog will only let you select the scale if the printing
2779  * system automatically handles scaling.
2780  *
2781  * Since: 2.10
2782  */
2783 void
2784 gtk_print_unix_dialog_set_manual_capabilities (GtkPrintUnixDialog   *dialog,
2785                                                GtkPrintCapabilities  capabilities)
2786 {
2787   GtkPrintUnixDialogPrivate *priv = dialog->priv;
2788
2789   priv->manual_capabilities = capabilities;
2790   update_dialog_from_capabilities (dialog);
2791
2792   if (priv->current_printer)
2793     {
2794       GtkTreeSelection *selection;
2795
2796       selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->printer_treeview));
2797
2798       g_object_unref (priv->current_printer);
2799       priv->current_printer = NULL;
2800       priv->internal_printer_change = TRUE;
2801       selected_printer_changed (selection, dialog);
2802       priv->internal_printer_change = FALSE;
2803    }
2804 }
2805
2806 #define __GTK_PRINT_UNIX_DIALOG_C__
2807 #include "gtkaliasdef.c"
2808