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