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