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

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