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

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