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

   1 /* GtkPageSetupUnixDialog
   2  * Copyright (C) 2006 Alexander Larsson <alexl@redhat.com>
   3  * Copyright © 2006, 2007, 2008 Christian Persch
   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
  22 #include "config.h"
  23 #include <string.h>
  24 #include <locale.h>
  25
  26 #ifdef HAVE__NL_MEASUREMENT_MEASUREMENT
  27 #include <langinfo.h>
  28 #endif
  29
  30 #include "gtkintl.h"
  31 #include "gtkprivate.h"
  32
  33 #include "gtkliststore.h"
  34 #include "gtkstock.h"
  35 #include "gtktreeviewcolumn.h"
  36 #include "gtktreeselection.h"
  37 #include "gtktreemodel.h"
  38 #include "gtkbutton.h"
  39 #include "gtkscrolledwindow.h"
  40 #include "gtkvbox.h"
  41 #include "gtkhbox.h"
  42 #include "gtkframe.h"
  43 #include "gtkeventbox.h"
  44 #include "gtkcombobox.h"
  45 #include "gtktogglebutton.h"
  46 #include "gtkradiobutton.h"
  47 #include "gtklabel.h"
  48 #include "gtktable.h"
  49 #include "gtkcelllayout.h"
  50 #include "gtkcellrenderertext.h"
  51 #include "gtkalignment.h"
  52 #include "gtkspinbutton.h"
  53 #include "gtkbbox.h"
  54 #include "gtkhbbox.h"
  55
  56 #include "gtkpagesetupunixdialog.h"
  57 #include "gtkprintbackend.h"
  58 #include "gtkprinter-private.h"
  59 #include "gtkpapersize.h"
  60 #include "gtkprintutils.h"
  61 #include "gtkalias.h"
  62
  63 #define CUSTOM_PAPER_FILENAME ".gtk-custom-papers"
  64
  65
  66 struct GtkPageSetupUnixDialogPrivate
  67 {
  68   GtkListStore *printer_list;
  69   GtkListStore *page_setup_list;
  70   GtkListStore *custom_paper_list;
  71
  72   GList *print_backends;
  73
  74   GtkWidget *printer_combo;
  75   GtkWidget *paper_size_combo;
  76   GtkWidget *paper_size_label;
  77
  78   GtkWidget *portrait_radio;
  79   GtkWidget *reverse_portrait_radio;
  80   GtkWidget *landscape_radio;
  81   GtkWidget *reverse_landscape_radio;
  82
  83   guint request_details_tag;
  84   GtkPrinter *request_details_printer;
  85
  86   GtkPrintSettings *print_settings;
  87
  88   /* Save last setup so we can re-set it after selecting manage custom sizes */
  89   GtkPageSetup *last_setup;
  90
  91   gchar *waiting_for_printer;
  92 };
  93
  94 enum {
  95   PRINTER_LIST_COL_NAME,
  96   PRINTER_LIST_COL_PRINTER,
  97   PRINTER_LIST_N_COLS
  98 };
  99
 100 enum {
 101   PAGE_SETUP_LIST_COL_PAGE_SETUP,
 102   PAGE_SETUP_LIST_COL_IS_SEPARATOR,
 103   PAGE_SETUP_LIST_N_COLS
 104 };
 105
 106 G_DEFINE_TYPE (GtkPageSetupUnixDialog, gtk_page_setup_unix_dialog, GTK_TYPE_DIALOG)
 107
 108 #define GTK_PAGE_SETUP_UNIX_DIALOG_GET_PRIVATE(o)  \
 109    (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PAGE_SETUP_UNIX_DIALOG, GtkPageSetupUnixDialogPrivate))
 110
 111 static void gtk_page_setup_unix_dialog_finalize  (GObject                *object);
 112 static void populate_dialog                      (GtkPageSetupUnixDialog *dialog);
 113 static void fill_paper_sizes_from_printer        (GtkPageSetupUnixDialog *dialog,
 114                                                   GtkPrinter             *printer);
 115 static void show_custom_paper_dialog             (GtkPageSetupUnixDialog *dialog);
 116 static void printer_added_cb                     (GtkPrintBackend        *backend,
 117                                                   GtkPrinter             *printer,
 118                                                   GtkPageSetupUnixDialog *dialog);
 119 static void printer_removed_cb                   (GtkPrintBackend        *backend,
 120                                                   GtkPrinter             *printer,
 121                                                   GtkPageSetupUnixDialog *dialog);
 122 static void printer_status_cb                    (GtkPrintBackend        *backend,
 123                                                   GtkPrinter             *printer,
 124                                                   GtkPageSetupUnixDialog *dialog);
 125
 126
 127
 128 static const gchar const common_paper_sizes[][16] = {
 129   "na_letter",
 130   "na_legal",
 131   "iso_a4",
 132   "iso_a5",
 133   "roc_16k",
 134   "iso_b5",
 135   "jis_b5",
 136   "na_number-10",
 137   "iso_dl",
 138   "jpn_chou3",
 139   "na_ledger",
 140   "iso_a3",
 141 };
 142
 143 static GtkUnit
 144 get_default_user_units (void)
 145 {
 146   /* Translate to the default units to use for presenting
 147    * lengths to the user. Translate to default:inch if you
 148    * want inches, otherwise translate to default:mm.
 149    * Do *not* translate it to "predefinito:mm", if it
 150    * it isn't default:mm or default:inch it will not work
 151    */
 152   gchar *e = _("default:mm");
 153
 154 #ifdef HAVE__NL_MEASUREMENT_MEASUREMENT
 155   gchar *imperial = NULL;
 156
 157   imperial = nl_langinfo (_NL_MEASUREMENT_MEASUREMENT);
 158   if (imperial && imperial[0] == 2 )
 159     return GTK_UNIT_INCH;  /* imperial */
 160   if (imperial && imperial[0] == 1 )
 161     return GTK_UNIT_MM;  /* metric */
 162 #endif
 163
 164   if (strcmp (e, "default:inch")==0)
 165     return GTK_UNIT_INCH;
 166   else if (strcmp (e, "default:mm"))
 167     g_warning ("Whoever translated default:mm did so wrongly.\n");
 168   return GTK_UNIT_MM;
 169 }
 170
 171 static char *
 172 custom_paper_get_filename (void)
 173 {
 174   gchar *filename;
 175
 176   filename = g_build_filename (g_get_home_dir (),
 177                                CUSTOM_PAPER_FILENAME, NULL);
 178   g_assert (filename != NULL);
 179   return filename;
 180 }
 181
 182 GList *
 183 _gtk_load_custom_papers (void)
 184 {
 185   GKeyFile *keyfile;
 186   gchar *filename;
 187   gchar **groups;
 188   gsize n_groups, i;
 189   gboolean load_ok;
 190   GList *result = NULL;
 191
 192   filename = custom_paper_get_filename ();
 193
 194   keyfile = g_key_file_new ();
 195   load_ok = g_key_file_load_from_file (keyfile, filename, 0, NULL);
 196   g_free (filename);
 197   if (!load_ok)
 198     {
 199       g_key_file_free (keyfile);
 200       return NULL;
 201     }
 202
 203   groups = g_key_file_get_groups (keyfile, &n_groups);
 204   for (i = 0; i < n_groups; ++i)
 205     {
 206       GtkPageSetup *page_setup;
 207
 208       page_setup = gtk_page_setup_new_from_key_file (keyfile, groups[i], NULL);
 209       if (!page_setup)
 210         continue;
 211
 212       result = g_list_prepend (result, page_setup);
 213     }
 214
 215   g_strfreev (groups);
 216   g_key_file_free (keyfile);
 217
 218   return g_list_reverse (result);
 219 }
 220
 221 static void
 222 load_custom_papers (GtkListStore *store)
 223 {
 224   GtkTreeIter iter;
 225   GList *papers, *p;
 226   GtkPageSetup *page_setup;
 227
 228   papers = _gtk_load_custom_papers ();
 229   for (p = papers; p; p = p->next)
 230     {
 231       page_setup = p->data;
 232       gtk_list_store_append (store, &iter);
 233       gtk_list_store_set (store, &iter,
 234                           0, page_setup,
 235                           -1);
 236       g_object_unref (page_setup);
 237     }
 238
 239   g_list_free (papers);
 240 }
 241
 242 static void
 243 save_custom_papers (GtkListStore *store)
 244 {
 245   GtkTreeModel *model = GTK_TREE_MODEL (store);
 246   GtkTreeIter iter;
 247   GKeyFile *keyfile;
 248   gchar *filename, *data;
 249   gsize len;
 250   gint i = 0;
 251
 252   keyfile = g_key_file_new ();
 253
 254   if (gtk_tree_model_get_iter_first (model, &iter))
 255     {
 256       do
 257         {
 258           GtkPageSetup *page_setup;
 259           gchar group[32];
 260
 261           g_snprintf (group, sizeof (group), "Paper%u", i);
 262
 263           gtk_tree_model_get (model, &iter, 0, &page_setup, -1);
 264
 265           gtk_page_setup_to_key_file (page_setup, keyfile, group);
 266
 267           ++i;
 268         } while (gtk_tree_model_iter_next (model, &iter));
 269     }
 270
 271   filename = custom_paper_get_filename ();
 272   data = g_key_file_to_data (keyfile, &len, NULL);
 273   g_file_set_contents (filename, data, len, NULL);
 274   g_free (data);
 275   g_free (filename);
 276 }
 277
 278 static void
 279 gtk_page_setup_unix_dialog_class_init (GtkPageSetupUnixDialogClass *class)
 280 {
 281   GObjectClass *object_class;
 282   GtkWidgetClass *widget_class;
 283
 284   object_class = (GObjectClass *) class;
 285   widget_class = (GtkWidgetClass *) class;
 286
 287   object_class->finalize = gtk_page_setup_unix_dialog_finalize;
 288
 289   g_type_class_add_private (class, sizeof (GtkPageSetupUnixDialogPrivate));
 290 }
 291
 292 static void
 293 gtk_page_setup_unix_dialog_init (GtkPageSetupUnixDialog *dialog)
 294 {
 295   GtkPageSetupUnixDialogPrivate *priv;
 296   GtkTreeIter iter;
 297
 298   priv = dialog->priv = GTK_PAGE_SETUP_UNIX_DIALOG_GET_PRIVATE (dialog);
 299
 300   priv->print_backends = NULL;
 301
 302   priv->printer_list = gtk_list_store_new (PRINTER_LIST_N_COLS,
 303                                                    G_TYPE_STRING,
 304                                                    G_TYPE_OBJECT);
 305
 306   gtk_list_store_append (priv->printer_list, &iter);
 307   gtk_list_store_set (priv->printer_list, &iter,
 308                       PRINTER_LIST_COL_NAME, _("<b>Any Printer</b>\nFor portable documents"),
 309                       PRINTER_LIST_COL_PRINTER, NULL,
 310                       -1);
 311
 312   priv->page_setup_list = gtk_list_store_new (PAGE_SETUP_LIST_N_COLS,
 313                                                       G_TYPE_OBJECT,
 314                                                       G_TYPE_BOOLEAN);
 315
 316   priv->custom_paper_list = gtk_list_store_new (1, G_TYPE_OBJECT);
 317   load_custom_papers (priv->custom_paper_list);
 318
 319   populate_dialog (dialog);
 320
 321   gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 322                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 323                           GTK_STOCK_APPLY, GTK_RESPONSE_OK,
 324                           NULL);
 325   gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 326                                            GTK_RESPONSE_OK,
 327                                            GTK_RESPONSE_CANCEL,
 328                                            -1);
 329
 330   gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 331 }
 332
 333 static void
 334 gtk_page_setup_unix_dialog_finalize (GObject *object)
 335 {
 336   GtkPageSetupUnixDialog *dialog = GTK_PAGE_SETUP_UNIX_DIALOG (object);
 337   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 338   GtkPrintBackend *backend;
 339   GList *node;
 340
 341   if (priv->request_details_tag)
 342     {
 343       g_signal_handler_disconnect (priv->request_details_printer,
 344                                    priv->request_details_tag);
 345       g_object_unref (priv->request_details_printer);
 346       priv->request_details_printer = NULL;
 347       priv->request_details_tag = 0;
 348     }
 349
 350   if (priv->printer_list)
 351     {
 352       g_object_unref (priv->printer_list);
 353       priv->printer_list = NULL;
 354     }
 355
 356   if (priv->page_setup_list)
 357     {
 358       g_object_unref (priv->page_setup_list);
 359       priv->page_setup_list = NULL;
 360     }
 361
 362   if (priv->custom_paper_list)
 363     {
 364       g_object_unref (priv->custom_paper_list);
 365       priv->custom_paper_list = NULL;
 366     }
 367
 368   if (priv->print_settings)
 369     {
 370       g_object_unref (priv->print_settings);
 371       priv->print_settings = NULL;
 372     }
 373
 374   g_free (priv->waiting_for_printer);
 375   priv->waiting_for_printer = NULL;
 376
 377   for (node = priv->print_backends; node != NULL; node = node->next)
 378     {
 379       backend = GTK_PRINT_BACKEND (node->data);
 380
 381       g_signal_handlers_disconnect_by_func (backend, printer_added_cb, dialog);
 382       g_signal_handlers_disconnect_by_func (backend, printer_removed_cb, dialog);
 383       g_signal_handlers_disconnect_by_func (backend, printer_status_cb, dialog);
 384
 385       gtk_print_backend_destroy (backend);
 386       g_object_unref (backend);
 387     }
 388
 389   g_list_free (priv->print_backends);
 390   priv->print_backends = NULL;
 391
 392   G_OBJECT_CLASS (gtk_page_setup_unix_dialog_parent_class)->finalize (object);
 393 }
 394
 395 static void
 396 printer_added_cb (GtkPrintBackend        *backend,
 397                   GtkPrinter             *printer,
 398                   GtkPageSetupUnixDialog *dialog)
 399 {
 400   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 401   GtkTreeIter iter;
 402   gchar *str;
 403   const gchar *location;;
 404
 405   if (gtk_printer_is_virtual (printer))
 406     return;
 407
 408   location = gtk_printer_get_location (printer);
 409   if (location == NULL)
 410     location = "";
 411   str = g_strdup_printf ("<b>%s</b>\n%s",
 412                          gtk_printer_get_name (printer),
 413                          location);
 414
 415   gtk_list_store_append (priv->printer_list, &iter);
 416   gtk_list_store_set (priv->printer_list, &iter,
 417                       PRINTER_LIST_COL_NAME, str,
 418                       PRINTER_LIST_COL_PRINTER, printer,
 419                       -1);
 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   g_free (str);
 427
 428   if (priv->waiting_for_printer != NULL &&
 429       strcmp (priv->waiting_for_printer,
 430               gtk_printer_get_name (printer)) == 0)
 431     {
 432       gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->printer_combo),
 433                                      &iter);
 434       priv->waiting_for_printer = NULL;
 435     }
 436 }
 437
 438 static void
 439 printer_removed_cb (GtkPrintBackend        *backend,
 440                     GtkPrinter             *printer,
 441                     GtkPageSetupUnixDialog *dialog)
 442 {
 443   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 444   GtkTreeIter *iter;
 445
 446   iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");
 447   gtk_list_store_remove (GTK_LIST_STORE (priv->printer_list), iter);
 448 }
 449
 450
 451 static void
 452 printer_status_cb (GtkPrintBackend        *backend,
 453                    GtkPrinter             *printer,
 454                    GtkPageSetupUnixDialog *dialog)
 455 {
 456   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 457   GtkTreeIter *iter;
 458   gchar *str;
 459   const gchar *location;;
 460
 461   iter = g_object_get_data (G_OBJECT (printer), "gtk-print-tree-iter");
 462
 463   location = gtk_printer_get_location (printer);
 464   if (location == NULL)
 465     location = "";
 466   str = g_strdup_printf ("<b>%s</b>\n%s",
 467                          gtk_printer_get_name (printer),
 468                          location);
 469   gtk_list_store_set (priv->printer_list, iter,
 470                       PRINTER_LIST_COL_NAME, str,
 471                       -1);
 472   g_free (str);
 473 }
 474
 475 static void
 476 printer_list_initialize (GtkPageSetupUnixDialog *dialog,
 477                          GtkPrintBackend        *print_backend)
 478 {
 479   GList *list, *node;
 480
 481   g_return_if_fail (print_backend != NULL);
 482
 483   g_signal_connect_object (print_backend,
 484                            "printer-added",
 485                            (GCallback) printer_added_cb,
 486                            G_OBJECT (dialog), 0);
 487
 488   g_signal_connect_object (print_backend,
 489                            "printer-removed",
 490                            (GCallback) printer_removed_cb,
 491                            G_OBJECT (dialog), 0);
 492
 493   g_signal_connect_object (print_backend,
 494                            "printer-status-changed",
 495                            (GCallback) printer_status_cb,
 496                            G_OBJECT (dialog), 0);
 497
 498   list = gtk_print_backend_get_printer_list (print_backend);
 499
 500   node = list;
 501   while (node != NULL)
 502     {
 503       printer_added_cb (print_backend, node->data, dialog);
 504       node = node->next;
 505     }
 506
 507   g_list_free (list);
 508
 509 }
 510
 511 static void
 512 load_print_backends (GtkPageSetupUnixDialog *dialog)
 513 {
 514   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 515   GList *node;
 516
 517   if (g_module_supported ())
 518     priv->print_backends = gtk_print_backend_load_modules ();
 519
 520   for (node = priv->print_backends; node != NULL; node = node->next)
 521     printer_list_initialize (dialog, GTK_PRINT_BACKEND (node->data));
 522 }
 523
 524 static gboolean
 525 paper_size_row_is_separator (GtkTreeModel *model,
 526                              GtkTreeIter  *iter,
 527                              gpointer      data)
 528 {
 529   gboolean separator;
 530
 531   gtk_tree_model_get (model, iter, PAGE_SETUP_LIST_COL_IS_SEPARATOR, &separator, -1);
 532   return separator;
 533 }
 534
 535 static GtkPageSetup *
 536 get_current_page_setup (GtkPageSetupUnixDialog *dialog)
 537 {
 538   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 539   GtkPageSetup *current_page_setup;
 540   GtkComboBox *combo_box;
 541   GtkTreeIter iter;
 542
 543   current_page_setup = NULL;
 544
 545   combo_box = GTK_COMBO_BOX (priv->paper_size_combo);
 546   if (gtk_combo_box_get_active_iter (combo_box, &iter))
 547     gtk_tree_model_get (GTK_TREE_MODEL (priv->page_setup_list), &iter,
 548                         PAGE_SETUP_LIST_COL_PAGE_SETUP, &current_page_setup, -1);
 549
 550   if (current_page_setup)
 551     return current_page_setup;
 552
 553   /* No selected page size, return the default one.
 554    * This is used to set the first page setup when the dialog is created
 555    * as there is no selection on the first printer_changed.
 556    */
 557   return gtk_page_setup_new ();
 558 }
 559
 560 static gboolean
 561 page_setup_is_equal (GtkPageSetup *a,
 562                      GtkPageSetup *b)
 563 {
 564   return
 565     gtk_paper_size_is_equal (gtk_page_setup_get_paper_size (a),
 566                              gtk_page_setup_get_paper_size (b)) &&
 567     gtk_page_setup_get_top_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_top_margin (b, GTK_UNIT_MM) &&
 568     gtk_page_setup_get_bottom_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_bottom_margin (b, GTK_UNIT_MM) &&
 569     gtk_page_setup_get_left_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_left_margin (b, GTK_UNIT_MM) &&
 570     gtk_page_setup_get_right_margin (a, GTK_UNIT_MM) == gtk_page_setup_get_right_margin (b, GTK_UNIT_MM);
 571 }
 572
 573 static gboolean
 574 page_setup_is_same_size (GtkPageSetup *a,
 575                          GtkPageSetup *b)
 576 {
 577   return gtk_paper_size_is_equal (gtk_page_setup_get_paper_size (a),
 578                                   gtk_page_setup_get_paper_size (b));
 579 }
 580
 581 static gboolean
 582 set_paper_size (GtkPageSetupUnixDialog *dialog,
 583                 GtkPageSetup           *page_setup,
 584                 gboolean                size_only,
 585                 gboolean                add_item)
 586 {
 587   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 588   GtkTreeModel *model;
 589   GtkTreeIter iter;
 590   GtkPageSetup *list_page_setup;
 591
 592   model = GTK_TREE_MODEL (priv->page_setup_list);
 593
 594   if (gtk_tree_model_get_iter_first (model, &iter))
 595     {
 596       do
 597         {
 598           gtk_tree_model_get (GTK_TREE_MODEL (priv->page_setup_list), &iter,
 599                               PAGE_SETUP_LIST_COL_PAGE_SETUP, &list_page_setup, -1);
 600           if (list_page_setup == NULL)
 601             continue;
 602
 603           if ((size_only && page_setup_is_same_size (page_setup, list_page_setup)) ||
 604               (!size_only && page_setup_is_equal (page_setup, list_page_setup)))
 605             {
 606               gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->paper_size_combo),
 607                                              &iter);
 608               g_object_unref (list_page_setup);
 609               return TRUE;
 610             }
 611
 612           g_object_unref (list_page_setup);
 613
 614         } while (gtk_tree_model_iter_next (model, &iter));
 615     }
 616
 617   if (add_item)
 618     {
 619       gtk_list_store_append (priv->page_setup_list, &iter);
 620       gtk_list_store_set (priv->page_setup_list, &iter,
 621                           PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
 622                           -1);
 623       gtk_list_store_append (priv->page_setup_list, &iter);
 624       gtk_list_store_set (priv->page_setup_list, &iter,
 625                           PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
 626                           -1);
 627       gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->paper_size_combo),
 628                                      &iter);
 629       return TRUE;
 630     }
 631
 632   return FALSE;
 633 }
 634
 635 static void
 636 fill_custom_paper_sizes (GtkPageSetupUnixDialog *dialog)
 637 {
 638   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 639   GtkTreeIter iter, paper_iter;
 640   GtkTreeModel *model;
 641
 642   model = GTK_TREE_MODEL (priv->custom_paper_list);
 643   if (gtk_tree_model_get_iter_first (model, &iter))
 644     {
 645       gtk_list_store_append (priv->page_setup_list, &paper_iter);
 646       gtk_list_store_set (priv->page_setup_list, &paper_iter,
 647                           PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
 648                           -1);
 649       do
 650         {
 651           GtkPageSetup *page_setup;
 652           gtk_tree_model_get (model, &iter, 0, &page_setup, -1);
 653
 654           gtk_list_store_append (priv->page_setup_list, &paper_iter);
 655           gtk_list_store_set (priv->page_setup_list, &paper_iter,
 656                               PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
 657                               -1);
 658
 659           g_object_unref (page_setup);
 660         } while (gtk_tree_model_iter_next (model, &iter));
 661     }
 662
 663   gtk_list_store_append (priv->page_setup_list, &paper_iter);
 664   gtk_list_store_set (priv->page_setup_list, &paper_iter,
 665                       PAGE_SETUP_LIST_COL_IS_SEPARATOR, TRUE,
 666                       -1);
 667   gtk_list_store_append (priv->page_setup_list, &paper_iter);
 668   gtk_list_store_set (priv->page_setup_list, &paper_iter,
 669                       PAGE_SETUP_LIST_COL_PAGE_SETUP, NULL,
 670                       -1);
 671 }
 672
 673 static void
 674 fill_paper_sizes_from_printer (GtkPageSetupUnixDialog *dialog,
 675                                GtkPrinter             *printer)
 676 {
 677   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 678   GList *list, *l;
 679   GtkPageSetup *current_page_setup, *page_setup;
 680   GtkPaperSize *paper_size;
 681   GtkTreeIter iter;
 682   gint i;
 683
 684   gtk_list_store_clear (priv->page_setup_list);
 685
 686   if (printer == NULL)
 687     {
 688       for (i = 0; i < G_N_ELEMENTS (common_paper_sizes); i++)
 689         {
 690           page_setup = gtk_page_setup_new ();
 691           paper_size = gtk_paper_size_new (common_paper_sizes[i]);
 692           gtk_page_setup_set_paper_size_and_default_margins (page_setup, paper_size);
 693           gtk_paper_size_free (paper_size);
 694
 695           gtk_list_store_append (priv->page_setup_list, &iter);
 696           gtk_list_store_set (priv->page_setup_list, &iter,
 697                               PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
 698                               -1);
 699           g_object_unref (page_setup);
 700         }
 701     }
 702   else
 703     {
 704       list = gtk_printer_list_papers (printer);
 705       /* TODO: We should really sort this list so interesting size
 706          are at the top */
 707       for (l = list; l != NULL; l = l->next)
 708         {
 709           page_setup = l->data;
 710           gtk_list_store_append (priv->page_setup_list, &iter);
 711           gtk_list_store_set (priv->page_setup_list, &iter,
 712                               PAGE_SETUP_LIST_COL_PAGE_SETUP, page_setup,
 713                               -1);
 714           g_object_unref (page_setup);
 715         }
 716       g_list_free (list);
 717     }
 718
 719   fill_custom_paper_sizes (dialog);
 720
 721   current_page_setup = NULL;
 722
 723   /* When selecting a different printer, select its default paper size */
 724   if (printer != NULL)
 725     current_page_setup = gtk_printer_get_default_page_size (printer);
 726
 727   if (current_page_setup == NULL)
 728     current_page_setup = get_current_page_setup (dialog);
 729
 730   if (!set_paper_size (dialog, current_page_setup, FALSE, FALSE))
 731     set_paper_size (dialog, current_page_setup, TRUE, TRUE);
 732
 733   if (current_page_setup)
 734     g_object_unref (current_page_setup);
 735 }
 736
 737 static void
 738 printer_changed_finished_callback (GtkPrinter             *printer,
 739                                    gboolean                success,
 740                                    GtkPageSetupUnixDialog *dialog)
 741 {
 742   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 743
 744   g_signal_handler_disconnect (priv->request_details_printer,
 745                                priv->request_details_tag);
 746   g_object_unref (priv->request_details_printer);
 747   priv->request_details_tag = 0;
 748   priv->request_details_printer = NULL;
 749
 750   if (success)
 751     fill_paper_sizes_from_printer (dialog, printer);
 752
 753 }
 754
 755 static void
 756 printer_changed_callback (GtkComboBox            *combo_box,
 757                           GtkPageSetupUnixDialog *dialog)
 758 {
 759   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 760   GtkPrinter *printer;
 761   GtkTreeIter iter;
 762
 763   /* If we're waiting for a specific printer but the user changed
 764    * to another printer, cancel that wait.
 765    */
 766   if (priv->waiting_for_printer)
 767     {
 768       g_free (priv->waiting_for_printer);
 769       priv->waiting_for_printer = NULL;
 770     }
 771
 772   if (priv->request_details_tag)
 773     {
 774       g_signal_handler_disconnect (priv->request_details_printer,
 775                                    priv->request_details_tag);
 776       g_object_unref (priv->request_details_printer);
 777       priv->request_details_printer = NULL;
 778       priv->request_details_tag = 0;
 779     }
 780
 781   if (gtk_combo_box_get_active_iter (combo_box, &iter))
 782     {
 783       gtk_tree_model_get (gtk_combo_box_get_model (combo_box), &iter,
 784                           PRINTER_LIST_COL_PRINTER, &printer, -1);
 785
 786       if (printer == NULL || gtk_printer_has_details (printer))
 787         fill_paper_sizes_from_printer (dialog, printer);
 788       else
 789         {
 790           priv->request_details_printer = g_object_ref (printer);
 791           priv->request_details_tag =
 792             g_signal_connect (printer, "details-acquired",
 793                               G_CALLBACK (printer_changed_finished_callback), dialog);
 794           gtk_printer_request_details (printer);
 795
 796         }
 797
 798       if (printer)
 799         g_object_unref (printer);
 800
 801       if (priv->print_settings)
 802         {
 803           const char *name = NULL;
 804
 805           if (printer)
 806             name = gtk_printer_get_name (printer);
 807
 808           gtk_print_settings_set (priv->print_settings,
 809                                   "format-for-printer", name);
 810         }
 811     }
 812 }
 813
 814 /* We do this munging because we don't want to show zero digits
 815    after the decimal point, and not to many such digits if they
 816    are nonzero. I wish printf let you specify max precision for %f... */
 817 static gchar *
 818 double_to_string (gdouble d,
 819                   GtkUnit unit)
 820 {
 821   gchar *val, *p;
 822   struct lconv *locale_data;
 823   const gchar *decimal_point;
 824   gint decimal_point_len;
 825
 826   locale_data = localeconv ();
 827   decimal_point = locale_data->decimal_point;
 828   decimal_point_len = strlen (decimal_point);
 829
 830   /* Max two decimal digits for inch, max one for mm */
 831   if (unit == GTK_UNIT_INCH)
 832     val = g_strdup_printf ("%.2f", d);
 833   else
 834     val = g_strdup_printf ("%.1f", d);
 835
 836   if (strstr (val, decimal_point))
 837     {
 838       p = val + strlen (val) - 1;
 839       while (*p == '0')
 840         p--;
 841       if (p - val + 1 >= decimal_point_len &&
 842           strncmp (p - (decimal_point_len - 1), decimal_point, decimal_point_len) == 0)
 843         p -= decimal_point_len;
 844       p[1] = '\0';
 845     }
 846
 847   return val;
 848 }
 849
 850 static void
 851 paper_size_changed (GtkComboBox            *combo_box,
 852                     GtkPageSetupUnixDialog *dialog)
 853 {
 854   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
 855   GtkTreeIter iter;
 856   GtkPageSetup *page_setup, *last_page_setup;
 857   GtkUnit unit;
 858   gchar *str, *w, *h;
 859   gchar *top, *bottom, *left, *right;
 860   GtkLabel *label;
 861   const gchar *unit_str;
 862
 863   label = GTK_LABEL (priv->paper_size_label);
 864
 865   if (gtk_combo_box_get_active_iter (combo_box, &iter))
 866     {
 867       gtk_tree_model_get (gtk_combo_box_get_model (combo_box),
 868                           &iter, PAGE_SETUP_LIST_COL_PAGE_SETUP, &page_setup, -1);
 869
 870       if (page_setup == NULL)
 871         {
 872           /* Change from "manage" menu item to last value */
 873           if (priv->last_setup)
 874             last_page_setup = g_object_ref (priv->last_setup);
 875           else
 876             last_page_setup = gtk_page_setup_new (); /* "good" default */
 877           set_paper_size (dialog, last_page_setup, FALSE, TRUE);
 878           g_object_unref (last_page_setup);
 879
 880           /* And show the custom paper dialog */
 881           show_custom_paper_dialog (dialog);
 882
 883           return;
 884         }
 885
 886       if (priv->last_setup)
 887         g_object_unref (priv->last_setup);
 888
 889       priv->last_setup = g_object_ref (page_setup);
 890
 891       unit = get_default_user_units ();
 892
 893       if (unit == GTK_UNIT_MM)
 894         unit_str = _("mm");
 895       else
 896         unit_str = _("inch");
 897
 898
 899       w = double_to_string (gtk_page_setup_get_paper_width (page_setup, unit),
 900                             unit);
 901       h = double_to_string (gtk_page_setup_get_paper_height (page_setup, unit),
 902                             unit);
 903       str = g_strdup_printf ("%s x %s %s", w, h, unit_str);
 904       g_free (w);
 905       g_free (h);
 906
 907       gtk_label_set_text (label, str);
 908       g_free (str);
 909
 910       top = double_to_string (gtk_page_setup_get_top_margin (page_setup, unit), unit);
 911       bottom = double_to_string (gtk_page_setup_get_bottom_margin (page_setup, unit), unit);
 912       left = double_to_string (gtk_page_setup_get_left_margin (page_setup, unit), unit);
 913       right = double_to_string (gtk_page_setup_get_right_margin (page_setup, unit), unit);
 914
 915       str = g_strdup_printf (_("Margins:\n"
 916                                " Left: %s %s\n"
 917                                " Right: %s %s\n"
 918                                " Top: %s %s\n"
 919                                " Bottom: %s %s"
 920                                ),
 921                              left, unit_str,
 922                              right, unit_str,
 923                              top, unit_str,
 924                              bottom, unit_str);
 925       g_free (top);
 926       g_free (bottom);
 927       g_free (left);
 928       g_free (right);
 929
 930       gtk_widget_set_tooltip_text (priv->paper_size_label, str);
 931       g_free (str);
 932
 933       g_object_unref (page_setup);
 934     }
 935   else
 936     {
 937       gtk_label_set_text (label, "");
 938       gtk_widget_set_tooltip_text (priv->paper_size_label, NULL);
 939       if (priv->last_setup)
 940         g_object_unref (priv->last_setup);
 941       priv->last_setup = NULL;
 942     }
 943 }
 944
 945 static void
 946 page_name_func (GtkCellLayout   *cell_layout,
 947                 GtkCellRenderer *cell,
 948                 GtkTreeModel    *tree_model,
 949                 GtkTreeIter     *iter,
 950                 gpointer         data)
 951 {
 952   GtkPageSetup *page_setup;
 953   GtkPaperSize *paper_size;
 954
 955   gtk_tree_model_get (tree_model, iter,
 956                       PAGE_SETUP_LIST_COL_PAGE_SETUP, &page_setup, -1);
 957   if (page_setup)
 958     {
 959       paper_size = gtk_page_setup_get_paper_size (page_setup);
 960       g_object_set (cell, "text",  gtk_paper_size_get_display_name (paper_size), NULL);
 961       g_object_unref (page_setup);
 962     }
 963   else
 964     g_object_set (cell, "text",  _("Manage Custom Sizes..."), NULL);
 965
 966 }
 967
 968 static GtkWidget *
 969 create_radio_button (GSList      *group,
 970                      const gchar *stock_id)
 971 {
 972   GtkWidget *radio_button, *image, *label, *hbox;
 973   GtkStockItem item;
 974
 975   radio_button = gtk_radio_button_new (group);
 976   image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_LARGE_TOOLBAR);
 977   gtk_stock_lookup (stock_id, &item);
 978   label = gtk_label_new (item.label);
 979   hbox = gtk_hbox_new (0, 6);
 980   gtk_container_add (GTK_CONTAINER (radio_button), hbox);
 981   gtk_container_add (GTK_CONTAINER (hbox), image);
 982   gtk_container_add (GTK_CONTAINER (hbox), label);
 983
 984   gtk_widget_show_all (radio_button);
 985
 986   return radio_button;
 987 }
 988
 989 static void
 990 populate_dialog (GtkPageSetupUnixDialog *ps_dialog)
 991 {
 992   GtkPageSetupUnixDialogPrivate *priv = ps_dialog->priv;
 993   GtkDialog *dialog = GTK_DIALOG (ps_dialog);
 994   GtkWidget *table, *label, *combo, *radio_button;
 995   GtkCellRenderer *cell;
 996
 997   gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
 998
 999   gtk_dialog_set_has_separator (dialog, FALSE);
1000   gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
1001   gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
1002   gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
1003   gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
1004
1005   table = gtk_table_new (5, 4, FALSE);
1006   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1007   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1008   gtk_container_set_border_width (GTK_CONTAINER (table), 5);
1009   gtk_box_pack_start (GTK_BOX (dialog->vbox), table, TRUE, TRUE, 0);
1010   gtk_widget_show (table);
1011
1012   label = gtk_label_new_with_mnemonic (_("_Format for:"));
1013   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1014   gtk_table_attach (GTK_TABLE (table), label,
1015                     0, 1, 0, 1,
1016                     GTK_FILL, 0, 0, 0);
1017   gtk_widget_show (label);
1018
1019   combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->printer_list));
1020   priv->printer_combo = combo;
1021
1022   cell = gtk_cell_renderer_text_new ();
1023   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
1024   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell,
1025                                   "markup", PRINTER_LIST_COL_NAME,
1026                                   NULL);
1027
1028   gtk_table_attach (GTK_TABLE (table), combo,
1029                     1, 4, 0, 1,
1030                     GTK_FILL | GTK_EXPAND, 0, 0, 0);
1031   gtk_widget_show (combo);
1032   gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
1033
1034   label = gtk_label_new_with_mnemonic (_("_Paper size:"));
1035   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1036   gtk_table_attach (GTK_TABLE (table), label,
1037                     0, 1, 1, 2,
1038                     GTK_FILL, 0, 0, 0);
1039   gtk_widget_show (label);
1040
1041   combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->page_setup_list));
1042   priv->paper_size_combo = combo;
1043   gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo),
1044                                         paper_size_row_is_separator, NULL, NULL);
1045
1046   cell = gtk_cell_renderer_text_new ();
1047   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
1048   gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell,
1049                                       page_name_func, NULL, NULL);
1050
1051   gtk_table_attach (GTK_TABLE (table), combo,
1052                     1, 4, 1, 2,
1053                     GTK_FILL | GTK_EXPAND, 0, 0, 0);
1054   gtk_widget_show (combo);
1055   gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
1056
1057   label = gtk_label_new (NULL);
1058   priv->paper_size_label = label;
1059   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1060   gtk_table_attach (GTK_TABLE (table), label,
1061                     1, 4, 2, 3,
1062                     GTK_FILL, 0, 0, 0);
1063   gtk_widget_show (label);
1064
1065   label = gtk_label_new_with_mnemonic (_("_Orientation:"));
1066   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1067   gtk_table_attach (GTK_TABLE (table), label,
1068                     0, 1, 3, 4,
1069                     GTK_FILL, 0, 0, 0);
1070   gtk_widget_show (label);
1071
1072   radio_button = create_radio_button (NULL, GTK_STOCK_ORIENTATION_PORTRAIT);
1073   priv->portrait_radio = radio_button;
1074   gtk_table_attach (GTK_TABLE (table), radio_button,
1075                     1, 2, 3, 4,
1076                     GTK_EXPAND|GTK_FILL, 0, 0, 0);
1077   gtk_label_set_mnemonic_widget (GTK_LABEL (label), radio_button);
1078
1079   radio_button = create_radio_button (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_button)),
1080                                       GTK_STOCK_ORIENTATION_REVERSE_PORTRAIT);
1081   priv->reverse_portrait_radio = radio_button;
1082   gtk_table_attach (GTK_TABLE (table), radio_button,
1083                     2, 3, 3, 4,
1084                     GTK_EXPAND|GTK_FILL, 0, 0, 0);
1085
1086   radio_button = create_radio_button (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_button)),
1087                                       GTK_STOCK_ORIENTATION_LANDSCAPE);
1088   priv->landscape_radio = radio_button;
1089   gtk_table_attach (GTK_TABLE (table), radio_button,
1090                     1, 2, 4, 5,
1091                     GTK_EXPAND|GTK_FILL, 0, 0, 0);
1092   gtk_widget_show (radio_button);
1093
1094   gtk_table_set_row_spacing (GTK_TABLE (table), 3, 0);
1095
1096   radio_button = create_radio_button (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_button)),
1097                                       GTK_STOCK_ORIENTATION_REVERSE_LANDSCAPE);
1098   priv->reverse_landscape_radio = radio_button;
1099   gtk_table_attach (GTK_TABLE (table), radio_button,
1100                     2, 3, 4, 5,
1101                     GTK_EXPAND|GTK_FILL, 0, 0, 0);
1102
1103
1104   g_signal_connect (priv->paper_size_combo, "changed", G_CALLBACK (paper_size_changed), ps_dialog);
1105   g_signal_connect (priv->printer_combo, "changed", G_CALLBACK (printer_changed_callback), ps_dialog);
1106   gtk_combo_box_set_active (GTK_COMBO_BOX (priv->printer_combo), 0);
1107
1108   load_print_backends (ps_dialog);
1109 }
1110
1111 /**
1112  * gtk_page_setup_unix_dialog_new:
1113  * @title: the title of the dialog, or %NULL
1114  * @parent: transient parent of the dialog, or %NULL
1115  *
1116  * Creates a new page setup dialog.
1117  *
1118  * Returns: the new #GtkPageSetupUnixDialog
1119  *
1120  * Since: 2.10
1121  */
1122 GtkWidget *
1123 gtk_page_setup_unix_dialog_new (const gchar *title,
1124                                 GtkWindow   *parent)
1125 {
1126   GtkWidget *result;
1127
1128   if (title == NULL)
1129     title = _("Page Setup");
1130
1131   result = g_object_new (GTK_TYPE_PAGE_SETUP_UNIX_DIALOG,
1132                          "title", title,
1133                          NULL);
1134
1135   if (parent)
1136     gtk_window_set_transient_for (GTK_WINDOW (result), parent);
1137
1138   return result;
1139 }
1140
1141 static GtkPageOrientation
1142 get_orientation (GtkPageSetupUnixDialog *dialog)
1143 {
1144   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
1145
1146   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->portrait_radio)))
1147     return GTK_PAGE_ORIENTATION_PORTRAIT;
1148   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->landscape_radio)))
1149     return GTK_PAGE_ORIENTATION_LANDSCAPE;
1150   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->reverse_landscape_radio)))
1151     return GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE;
1152   return GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT;
1153 }
1154
1155 static void
1156 set_orientation (GtkPageSetupUnixDialog *dialog,
1157                  GtkPageOrientation      orientation)
1158 {
1159   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
1160
1161   switch (orientation)
1162     {
1163     case GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT:
1164       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->reverse_portrait_radio), TRUE);
1165       break;
1166     case GTK_PAGE_ORIENTATION_PORTRAIT:
1167       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->portrait_radio), TRUE);
1168       break;
1169     case GTK_PAGE_ORIENTATION_LANDSCAPE:
1170       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->landscape_radio), TRUE);
1171       break;
1172     case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
1173       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->reverse_landscape_radio), TRUE);
1174       break;
1175     }
1176 }
1177
1178 /**
1179  * gtk_page_setup_unix_dialog_set_page_setup:
1180  * @dialog: a #GtkPageSetupUnixDialog
1181  * @page_setup: a #GtkPageSetup
1182  *
1183  * Sets the #GtkPageSetup from which the page setup
1184  * dialog takes its values.
1185  *
1186  * Since: 2.10
1187  **/
1188 void
1189 gtk_page_setup_unix_dialog_set_page_setup (GtkPageSetupUnixDialog *dialog,
1190                                            GtkPageSetup           *page_setup)
1191 {
1192   if (page_setup)
1193     {
1194       set_paper_size (dialog, page_setup, FALSE, TRUE);
1195       set_orientation (dialog, gtk_page_setup_get_orientation (page_setup));
1196     }
1197 }
1198
1199 /**
1200  * gtk_page_setup_unix_dialog_get_page_setup:
1201  * @dialog: a #GtkPageSetupUnixDialog
1202  *
1203  * Gets the currently selected page setup from the dialog.
1204  *
1205  * Returns: the current page setup
1206  *
1207  * Since: 2.10
1208  **/
1209 GtkPageSetup *
1210 gtk_page_setup_unix_dialog_get_page_setup (GtkPageSetupUnixDialog *dialog)
1211 {
1212   GtkPageSetup *page_setup;
1213
1214   page_setup = get_current_page_setup (dialog);
1215
1216   gtk_page_setup_set_orientation (page_setup, get_orientation (dialog));
1217
1218   return page_setup;
1219 }
1220
1221 static gboolean
1222 set_active_printer (GtkPageSetupUnixDialog *dialog,
1223                     const gchar            *printer_name)
1224 {
1225   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
1226   GtkTreeModel *model;
1227   GtkTreeIter iter;
1228   GtkPrinter *printer;
1229
1230   model = GTK_TREE_MODEL (priv->printer_list);
1231
1232   if (gtk_tree_model_get_iter_first (model, &iter))
1233     {
1234       do
1235         {
1236           gtk_tree_model_get (GTK_TREE_MODEL (priv->printer_list), &iter,
1237                               PRINTER_LIST_COL_PRINTER, &printer, -1);
1238           if (printer == NULL)
1239             continue;
1240
1241           if (strcmp (gtk_printer_get_name (printer), printer_name) == 0)
1242             {
1243               gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->printer_combo),
1244                                              &iter);
1245               g_object_unref (printer);
1246               return TRUE;
1247             }
1248
1249           g_object_unref (printer);
1250
1251         } while (gtk_tree_model_iter_next (model, &iter));
1252     }
1253
1254   return FALSE;
1255 }
1256
1257 /**
1258  * gtk_page_setup_unix_dialog_set_print_settings:
1259  * @dialog: a #GtkPageSetupUnixDialog
1260  * @print_settings: a #GtkPrintSettings
1261  *
1262  * Sets the #GtkPrintSettings from which the page setup dialog
1263  * takes its values.
1264  *
1265  * Since: 2.10
1266  **/
1267 void
1268 gtk_page_setup_unix_dialog_set_print_settings (GtkPageSetupUnixDialog *dialog,
1269                                                GtkPrintSettings       *print_settings)
1270 {
1271   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
1272   const gchar *format_for_printer;
1273
1274   if (priv->print_settings == print_settings) return;
1275
1276   if (priv->print_settings)
1277     g_object_unref (priv->print_settings);
1278
1279   priv->print_settings = print_settings;
1280
1281   if (print_settings)
1282     {
1283       g_object_ref (print_settings);
1284
1285       format_for_printer = gtk_print_settings_get (print_settings, "format-for-printer");
1286
1287       /* Set printer if in list, otherwise set when
1288        * that printer is added
1289        */
1290       if (format_for_printer &&
1291           !set_active_printer (dialog, format_for_printer))
1292         priv->waiting_for_printer = g_strdup (format_for_printer);
1293     }
1294 }
1295
1296 /**
1297  * gtk_page_setup_unix_dialog_get_print_settings:
1298  * @dialog: a #GtkPageSetupUnixDialog
1299  *
1300  * Gets the current print settings from the dialog.
1301  *
1302  * Returns: the current print settings
1303  *
1304  * Since: 2.10
1305  **/
1306 GtkPrintSettings *
1307 gtk_page_setup_unix_dialog_get_print_settings (GtkPageSetupUnixDialog *dialog)
1308 {
1309   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
1310
1311   return priv->print_settings;
1312 }
1313
1314 static GtkWidget *
1315 wrap_in_frame (const gchar *label,
1316                GtkWidget   *child)
1317 {
1318   GtkWidget *frame, *alignment, *label_widget;
1319   gchar *bold_text;
1320
1321   label_widget = gtk_label_new (NULL);
1322   gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
1323   gtk_widget_show (label_widget);
1324
1325   bold_text = g_markup_printf_escaped ("<b>%s</b>", label);
1326   gtk_label_set_markup (GTK_LABEL (label_widget), bold_text);
1327   g_free (bold_text);
1328
1329   frame = gtk_vbox_new (FALSE, 6);
1330   gtk_box_pack_start (GTK_BOX (frame), label_widget, FALSE, FALSE, 0);
1331
1332   alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
1333   gtk_alignment_set_padding (GTK_ALIGNMENT (alignment),
1334                              0, 0, 12, 0);
1335   gtk_box_pack_start (GTK_BOX (frame), alignment, FALSE, FALSE, 0);
1336
1337   gtk_container_add (GTK_CONTAINER (alignment), child);
1338
1339   gtk_widget_show (frame);
1340   gtk_widget_show (alignment);
1341
1342   return frame;
1343 }
1344
1345 typedef struct
1346 {
1347   GtkUnit display_unit;
1348   GtkWidget *spin_button;
1349 } UnitWidget;
1350
1351 typedef struct
1352 {
1353   GtkPageSetupUnixDialog *dialog;
1354   GtkWidget *treeview;
1355   GtkTreeViewColumn *text_column;
1356   GtkWidget *values_box;
1357   GtkWidget *printer_combo;
1358   GtkWidget *width_widget;
1359   GtkWidget *height_widget;
1360   GtkWidget *top_widget;
1361   GtkWidget *bottom_widget;
1362   GtkWidget *left_widget;
1363   GtkWidget *right_widget;
1364   gulong printer_inserted_tag;
1365   gulong printer_removed_tag;
1366   guint request_details_tag;
1367   GtkPrinter *request_details_printer;
1368   guint non_user_change : 1;
1369 } CustomPaperDialog;
1370
1371 static void unit_widget_changed (CustomPaperDialog *data);
1372
1373 static GtkWidget *
1374 new_unit_widget (CustomPaperDialog *dialog,
1375                  GtkUnit            unit,
1376                  GtkWidget         *mnemonic_label)
1377 {
1378   GtkWidget *hbox, *button, *label;
1379   UnitWidget *data;
1380
1381   data = g_new0 (UnitWidget, 1);
1382   data->display_unit = unit;
1383
1384   hbox = gtk_hbox_new (FALSE, 6);
1385
1386   button = gtk_spin_button_new_with_range (0.0, 9999.0, 1);
1387   if (unit == GTK_UNIT_INCH)
1388     gtk_spin_button_set_digits (GTK_SPIN_BUTTON (button), 2);
1389   else
1390     gtk_spin_button_set_digits (GTK_SPIN_BUTTON (button), 1);
1391
1392   gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
1393   gtk_widget_show (button);
1394
1395   data->spin_button = button;
1396
1397   g_signal_connect_swapped (button, "value-changed",
1398                             G_CALLBACK (unit_widget_changed), dialog);
1399
1400   if (unit == GTK_UNIT_INCH)
1401     label = gtk_label_new (_("inch"));
1402   else
1403     label = gtk_label_new (_("mm"));
1404
1405   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
1406   gtk_widget_show (label);
1407   gtk_label_set_mnemonic_widget (GTK_LABEL (mnemonic_label), button);
1408
1409   g_object_set_data_full (G_OBJECT (hbox), "unit-data", data, g_free);
1410
1411   return hbox;
1412 }
1413
1414 static double
1415 unit_widget_get (GtkWidget *unit_widget)
1416 {
1417   UnitWidget *data = g_object_get_data (G_OBJECT (unit_widget), "unit-data");
1418   return _gtk_print_convert_to_mm (gtk_spin_button_get_value (GTK_SPIN_BUTTON (data->spin_button)),
1419                                    data->display_unit);
1420 }
1421
1422 static void
1423 unit_widget_set (GtkWidget *unit_widget,
1424                  gdouble    value)
1425 {
1426   UnitWidget *data;
1427
1428   data = g_object_get_data (G_OBJECT (unit_widget), "unit-data");
1429   gtk_spin_button_set_value (GTK_SPIN_BUTTON (data->spin_button),
1430                              _gtk_print_convert_from_mm (value, data->display_unit));
1431 }
1432
1433 static void
1434 custom_paper_printer_data_func (GtkCellLayout   *cell_layout,
1435                                 GtkCellRenderer *cell,
1436                                 GtkTreeModel    *tree_model,
1437                                 GtkTreeIter     *iter,
1438                                 gpointer         data)
1439 {
1440   GtkPrinter *printer;
1441
1442   gtk_tree_model_get (tree_model, iter,
1443                       PRINTER_LIST_COL_PRINTER, &printer, -1);
1444
1445   if (printer)
1446     g_object_set (cell, "text",  gtk_printer_get_name (printer), NULL);
1447   else
1448     g_object_set (cell, "text",  _("Margins from Printer..."), NULL);
1449
1450   if (printer)
1451     g_object_unref (printer);
1452 }
1453
1454 static void
1455 update_combo_sensitivity_from_printers (CustomPaperDialog *data)
1456 {
1457   GtkTreeIter iter;
1458   gboolean sensitive;
1459   GtkTreeSelection *selection;
1460   GtkTreeModel *model;
1461
1462   sensitive = FALSE;
1463   model = GTK_TREE_MODEL (data->dialog->priv->printer_list);
1464   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview));
1465   if (gtk_tree_model_get_iter_first (model, &iter) &&
1466       gtk_tree_model_iter_next (model, &iter) &&
1467       gtk_tree_selection_get_selected (selection, NULL, &iter))
1468     sensitive = TRUE;
1469
1470   gtk_widget_set_sensitive (data->printer_combo, sensitive);
1471 }
1472
1473 static void
1474 update_custom_widgets_from_list (CustomPaperDialog *data)
1475 {
1476   GtkTreeSelection *selection;
1477   GtkTreeModel *model;
1478   GtkTreeIter iter;
1479   GtkPageSetup *page_setup;
1480
1481   model = gtk_tree_view_get_model (GTK_TREE_VIEW (data->treeview));
1482   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview));
1483
1484   data->non_user_change = TRUE;
1485   if (gtk_tree_selection_get_selected (selection, NULL, &iter))
1486     {
1487       gtk_tree_model_get (model, &iter, 0, &page_setup, -1);
1488
1489       unit_widget_set (data->width_widget,
1490                        gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM));
1491       unit_widget_set (data->height_widget,
1492                        gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM));
1493       unit_widget_set (data->top_widget,
1494                        gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM));
1495       unit_widget_set (data->bottom_widget,
1496                        gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM));
1497       unit_widget_set (data->left_widget,
1498                        gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM));
1499       unit_widget_set (data->right_widget,
1500                        gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM));
1501
1502       gtk_widget_set_sensitive (data->values_box, TRUE);
1503     }
1504   else
1505     {
1506       gtk_widget_set_sensitive (data->values_box, FALSE);
1507     }
1508
1509   update_combo_sensitivity_from_printers (data);
1510   data->non_user_change = FALSE;
1511 }
1512
1513 static void
1514 selected_custom_paper_changed (GtkTreeSelection  *selection,
1515                                CustomPaperDialog *data)
1516 {
1517   update_custom_widgets_from_list (data);
1518 }
1519
1520 static void
1521 unit_widget_changed (CustomPaperDialog *data)
1522 {
1523   gdouble w, h, top, bottom, left, right;
1524   GtkTreeSelection *selection;
1525   GtkTreeIter iter;
1526   GtkPageSetup *page_setup;
1527   GtkPaperSize *paper_size;
1528
1529   if (data->non_user_change)
1530     return;
1531
1532   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview));
1533
1534   if (gtk_tree_selection_get_selected (selection, NULL, &iter))
1535     {
1536       gtk_tree_model_get (GTK_TREE_MODEL (data->dialog->priv->custom_paper_list), &iter, 0, &page_setup, -1);
1537
1538       w = unit_widget_get (data->width_widget);
1539       h = unit_widget_get (data->height_widget);
1540
1541       paper_size = gtk_page_setup_get_paper_size (page_setup);
1542       gtk_paper_size_set_size (paper_size, w, h, GTK_UNIT_MM);
1543
1544       top = unit_widget_get (data->top_widget);
1545       bottom = unit_widget_get (data->bottom_widget);
1546       left = unit_widget_get (data->left_widget);
1547       right = unit_widget_get (data->right_widget);
1548
1549       gtk_page_setup_set_top_margin (page_setup, top, GTK_UNIT_MM);
1550       gtk_page_setup_set_bottom_margin (page_setup, bottom, GTK_UNIT_MM);
1551       gtk_page_setup_set_left_margin (page_setup, left, GTK_UNIT_MM);
1552       gtk_page_setup_set_right_margin (page_setup, right, GTK_UNIT_MM);
1553
1554       g_object_unref (page_setup);
1555     }
1556 }
1557
1558 static gboolean
1559 custom_paper_name_used (CustomPaperDialog *data,
1560                         const gchar       *name)
1561 {
1562   GtkTreeModel *model;
1563   GtkTreeIter iter;
1564   GtkPageSetup *page_setup;
1565   GtkPaperSize *paper_size;
1566
1567   model = gtk_tree_view_get_model (GTK_TREE_VIEW (data->treeview));
1568
1569   if (gtk_tree_model_get_iter_first (model, &iter))
1570     {
1571       do
1572         {
1573           gtk_tree_model_get (model, &iter, 0, &page_setup, -1);
1574           paper_size = gtk_page_setup_get_paper_size (page_setup);
1575           if (strcmp (name,
1576                       gtk_paper_size_get_name (paper_size)) == 0)
1577             {
1578               g_object_unref (page_setup);
1579               return TRUE;
1580             }
1581           g_object_unref (page_setup);
1582         } while (gtk_tree_model_iter_next (model, &iter));
1583     }
1584
1585   return FALSE;
1586 }
1587
1588 static void
1589 add_custom_paper (CustomPaperDialog *data)
1590 {
1591   GtkListStore *store;
1592   GtkPageSetup *page_setup;
1593   GtkPaperSize *paper_size;
1594   GtkTreeSelection *selection;
1595   GtkTreePath *path;
1596   GtkTreeIter iter;
1597   gchar *name;
1598   gint i;
1599
1600   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview));
1601   store = data->dialog->priv->custom_paper_list;
1602
1603   i = 1;
1604   name = NULL;
1605   do
1606     {
1607       g_free (name);
1608       name = g_strdup_printf (_("Custom Size %d"), i);
1609       i++;
1610     } while (custom_paper_name_used (data, name));
1611
1612   page_setup = gtk_page_setup_new ();
1613   paper_size = gtk_paper_size_new_custom (name, name,
1614                                           gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM),
1615                                           gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM),
1616                                           GTK_UNIT_MM);
1617   gtk_page_setup_set_paper_size (page_setup, paper_size);
1618   gtk_paper_size_free (paper_size);
1619
1620   gtk_list_store_append (store, &iter);
1621   gtk_list_store_set (store, &iter, 0, page_setup, -1);
1622   g_object_unref (page_setup);
1623
1624   gtk_tree_selection_select_iter (selection, &iter);
1625   path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
1626   gtk_widget_grab_focus (data->treeview);
1627   gtk_tree_view_set_cursor (GTK_TREE_VIEW (data->treeview), path,
1628                             data->text_column, TRUE);
1629   gtk_tree_path_free (path);
1630   g_free (name);
1631 }
1632
1633 static void
1634 remove_custom_paper (CustomPaperDialog *data)
1635 {
1636   GtkTreeSelection *selection;
1637   GtkTreeIter iter;
1638   GtkListStore *store;
1639
1640   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview));
1641   store = data->dialog->priv->custom_paper_list;
1642
1643   if (gtk_tree_selection_get_selected (selection, NULL, &iter))
1644     {
1645       GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
1646       gtk_list_store_remove (store, &iter);
1647
1648       if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path))
1649         gtk_tree_selection_select_iter (selection, &iter);
1650       else if (gtk_tree_path_prev (path) && gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path))
1651         gtk_tree_selection_select_iter (selection, &iter);
1652
1653       gtk_tree_path_free (path);
1654     }
1655 }
1656
1657 static void
1658 set_margins_from_printer (CustomPaperDialog *data,
1659                           GtkPrinter        *printer)
1660 {
1661   gdouble top, bottom, left, right;
1662
1663   top = bottom = left = right = 0;
1664   _gtk_printer_get_hard_margins (printer, &top, &bottom, &left, &right);
1665
1666   data->non_user_change = TRUE;
1667   unit_widget_set (data->top_widget, _gtk_print_convert_to_mm (top, GTK_UNIT_POINTS));
1668   unit_widget_set (data->bottom_widget, _gtk_print_convert_to_mm (bottom, GTK_UNIT_POINTS));
1669   unit_widget_set (data->left_widget, _gtk_print_convert_to_mm (left, GTK_UNIT_POINTS));
1670   unit_widget_set (data->right_widget, _gtk_print_convert_to_mm (right, GTK_UNIT_POINTS));
1671   data->non_user_change = FALSE;
1672
1673   /* Only send one change */
1674   unit_widget_changed (data);
1675 }
1676
1677 static void
1678 get_margins_finished_callback (GtkPrinter        *printer,
1679                                gboolean           success,
1680                                CustomPaperDialog *data)
1681 {
1682   g_signal_handler_disconnect (data->request_details_printer,
1683                                data->request_details_tag);
1684   g_object_unref (data->request_details_printer);
1685   data->request_details_tag = 0;
1686   data->request_details_printer = NULL;
1687
1688   if (success)
1689     set_margins_from_printer (data, printer);
1690
1691   gtk_combo_box_set_active (GTK_COMBO_BOX (data->printer_combo), 0);
1692 }
1693
1694 static void
1695 margins_from_printer_changed (CustomPaperDialog *data)
1696 {
1697   GtkTreeIter iter;
1698   GtkComboBox *combo;
1699   GtkPrinter *printer;
1700
1701   combo = GTK_COMBO_BOX (data->printer_combo);
1702
1703   if (data->request_details_tag)
1704     {
1705       g_signal_handler_disconnect (data->request_details_printer,
1706                                    data->request_details_tag);
1707       g_object_unref (data->request_details_printer);
1708       data->request_details_printer = NULL;
1709       data->request_details_tag = 0;
1710     }
1711
1712   if (gtk_combo_box_get_active_iter  (combo, &iter))
1713     {
1714       gtk_tree_model_get (gtk_combo_box_get_model (combo), &iter,
1715                           PRINTER_LIST_COL_PRINTER, &printer, -1);
1716
1717       if (printer)
1718         {
1719           if (gtk_printer_has_details (printer))
1720             {
1721               set_margins_from_printer (data, printer);
1722               gtk_combo_box_set_active (combo, 0);
1723             }
1724           else
1725             {
1726               data->request_details_printer = g_object_ref (printer);
1727               data->request_details_tag =
1728                 g_signal_connect (printer, "details-acquired",
1729                                   G_CALLBACK (get_margins_finished_callback), data);
1730               gtk_printer_request_details (printer);
1731             }
1732
1733           g_object_unref (printer);
1734         }
1735     }
1736 }
1737
1738
1739 static void
1740 custom_paper_dialog_free (gpointer p)
1741 {
1742   CustomPaperDialog *data = p;
1743   GtkPageSetupUnixDialogPrivate *priv = data->dialog->priv;
1744
1745   g_signal_handler_disconnect (priv->printer_list, data->printer_inserted_tag);
1746   g_signal_handler_disconnect (priv->printer_list, data->printer_removed_tag);
1747
1748   if (data->request_details_tag)
1749     {
1750       g_signal_handler_disconnect (data->request_details_printer,
1751                                    data->request_details_tag);
1752       g_object_unref (data->request_details_printer);
1753       data->request_details_printer = NULL;
1754       data->request_details_tag = 0;
1755     }
1756
1757   g_free (data);
1758 }
1759
1760 static void
1761 custom_size_name_edited (GtkCellRenderer   *cell,
1762                          gchar             *path_string,
1763                          gchar             *new_text,
1764                          CustomPaperDialog *data)
1765 {
1766   GtkTreePath *path;
1767   GtkTreeIter iter;
1768   GtkListStore *store;
1769   GtkPageSetup *page_setup;
1770   GtkPaperSize *paper_size;
1771
1772   store = data->dialog->priv->custom_paper_list;
1773   path = gtk_tree_path_new_from_string (path_string);
1774   gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path);
1775   gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, 0, &page_setup, -1);
1776   gtk_tree_path_free (path);
1777
1778   paper_size = gtk_paper_size_new_custom (new_text, new_text,
1779                                           gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM),
1780                                           gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM),
1781                                           GTK_UNIT_MM);
1782   gtk_page_setup_set_paper_size (page_setup, paper_size);
1783   gtk_paper_size_free (paper_size);
1784
1785   g_object_unref (page_setup);
1786 }
1787
1788 static void
1789 custom_name_func (GtkTreeViewColumn *tree_column,
1790                   GtkCellRenderer   *cell,
1791                   GtkTreeModel      *tree_model,
1792                   GtkTreeIter       *iter,
1793                   gpointer           data)
1794 {
1795   GtkPageSetup *page_setup;
1796   GtkPaperSize *paper_size;
1797
1798   gtk_tree_model_get (tree_model, iter, 0, &page_setup, -1);
1799   if (page_setup)
1800     {
1801       paper_size = gtk_page_setup_get_paper_size (page_setup);
1802       g_object_set (cell, "text",  gtk_paper_size_get_display_name (paper_size), NULL);
1803       g_object_unref (page_setup);
1804     }
1805 }
1806
1807 static void
1808 custom_paper_dialog_response_cb (GtkWidget         *custom_dialog,
1809                                  gint               response,
1810                                  CustomPaperDialog *data)
1811 {
1812   GtkPageSetupUnixDialog *dialog = data->dialog;
1813   GtkPageSetupUnixDialogPrivate *priv = dialog->priv;
1814
1815   save_custom_papers (priv->custom_paper_list);
1816
1817   /* Update printer page list */
1818   printer_changed_callback (GTK_COMBO_BOX (priv->printer_combo), dialog);
1819
1820   gtk_widget_destroy (custom_dialog);
1821 }
1822
1823 static void
1824 show_custom_paper_dialog (GtkPageSetupUnixDialog *ps_dialog)
1825 {
1826   GtkPageSetupUnixDialogPrivate *priv = ps_dialog->priv;
1827   GtkWidget *custom_dialog, *image, *table, *label, *widget, *frame, *combo;
1828   GtkWidget *hbox, *vbox, *treeview, *scrolled, *button_box, *button;
1829   GtkDialog *dialog;
1830   GtkCellRenderer *cell;
1831   GtkTreeViewColumn *column;
1832   GtkTreeIter iter;
1833   GtkTreeSelection *selection;
1834   CustomPaperDialog *data;
1835   GtkUnit user_units;
1836
1837   custom_dialog = gtk_dialog_new_with_buttons (_("Manage Custom Sizes"),
1838                                                GTK_WINDOW (ps_dialog),
1839                                                GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
1840                                                GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
1841                                                NULL);
1842
1843   dialog = GTK_DIALOG (custom_dialog);
1844
1845   data = g_new0 (CustomPaperDialog, 1);
1846   data->dialog = ps_dialog;
1847   g_object_set_data_full (G_OBJECT (custom_dialog), "custom-dialog", data,
1848                           custom_paper_dialog_free);
1849   g_signal_connect (dialog, "response",
1850                     G_CALLBACK (custom_paper_dialog_response_cb), data);
1851
1852   gtk_dialog_set_has_separator (dialog, FALSE);
1853   gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
1854   gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
1855   gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
1856   gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
1857
1858   hbox = gtk_hbox_new (FALSE, 18);
1859   gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1860   gtk_box_pack_start (GTK_BOX (dialog->vbox), hbox, TRUE, TRUE, 0);
1861   gtk_widget_show (hbox);
1862
1863   vbox = gtk_vbox_new (FALSE, 6);
1864   gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1865   gtk_widget_show (vbox);
1866
1867   scrolled = gtk_scrolled_window_new (NULL, NULL);
1868   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
1869                                   GTK_POLICY_AUTOMATIC,
1870                                   GTK_POLICY_AUTOMATIC);
1871   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
1872                                        GTK_SHADOW_IN);
1873   gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
1874   gtk_widget_show (scrolled);
1875
1876   treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->custom_paper_list));
1877   data->treeview = treeview;
1878   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
1879   gtk_widget_set_size_request (treeview, 140, -1);
1880
1881   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
1882   gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
1883   g_signal_connect (selection, "changed", G_CALLBACK (selected_custom_paper_changed), data);
1884
1885   cell = gtk_cell_renderer_text_new ();
1886   g_object_set (cell, "editable", TRUE, NULL);
1887   g_signal_connect (cell, "edited",
1888                     G_CALLBACK (custom_size_name_edited), data);
1889   data->text_column = column =
1890     gtk_tree_view_column_new_with_attributes ("paper", cell,
1891                                               NULL);
1892   gtk_tree_view_column_set_cell_data_func  (column, cell, custom_name_func, NULL, NULL);
1893
1894   gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
1895
1896   gtk_container_add (GTK_CONTAINER (scrolled), treeview);
1897   gtk_widget_show (treeview);
1898
1899   button_box = gtk_hbox_new (FALSE, 6);
1900   gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 0);
1901   gtk_widget_show (button_box);
1902
1903   button = gtk_button_new ();
1904   image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON);
1905   gtk_widget_show (image);
1906   gtk_container_add (GTK_CONTAINER (button), image);
1907   gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 0);
1908   gtk_widget_show (button);
1909
1910   g_signal_connect_swapped (button, "clicked", G_CALLBACK (add_custom_paper), data);
1911
1912   button = gtk_button_new ();
1913   image = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON);
1914   gtk_widget_show (image);
1915   gtk_container_add (GTK_CONTAINER (button), image);
1916   gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 0);
1917   gtk_widget_show (button);
1918
1919   g_signal_connect_swapped (button, "clicked", G_CALLBACK (remove_custom_paper), data);
1920
1921   user_units = get_default_user_units ();
1922
1923   vbox = gtk_vbox_new (FALSE, 18);
1924   data->values_box = vbox;
1925   gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1926   gtk_widget_show (vbox);
1927
1928   table = gtk_table_new (2, 2, FALSE);
1929
1930   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1931   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1932
1933   label = gtk_label_new_with_mnemonic (_("_Width:"));
1934   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1935   gtk_widget_show (label);
1936   gtk_table_attach (GTK_TABLE (table), label,
1937                     0, 1, 0, 1, GTK_FILL, 0, 0, 0);
1938
1939   widget = new_unit_widget (data, user_units, label);
1940   data->width_widget = widget;
1941   gtk_table_attach (GTK_TABLE (table), widget,
1942                     1, 2, 0, 1, GTK_FILL, 0, 0, 0);
1943   gtk_widget_show (widget);
1944
1945   label = gtk_label_new_with_mnemonic (_("_Height:"));
1946   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1947   gtk_widget_show (label);
1948   gtk_table_attach (GTK_TABLE (table), label,
1949                     0, 1, 1, 2, GTK_FILL, 0, 0, 0);
1950
1951   widget = new_unit_widget (data, user_units, label);
1952   data->height_widget = widget;
1953   gtk_table_attach (GTK_TABLE (table), widget,
1954                     1, 2, 1, 2, GTK_FILL, 0, 0, 0);
1955   gtk_widget_show (widget);
1956
1957   frame = wrap_in_frame (_("Paper Size"), table);
1958   gtk_widget_show (table);
1959   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1960   gtk_widget_show (frame);
1961
1962
1963   table = gtk_table_new (5, 2, FALSE);
1964   gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1965   gtk_table_set_col_spacings (GTK_TABLE (table), 12);
1966
1967   label = gtk_label_new_with_mnemonic (_("_Top:"));
1968   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1969   gtk_table_attach (GTK_TABLE (table), label,
1970                     0, 1, 0, 1, GTK_FILL, 0, 0, 0);
1971   gtk_widget_show (label);
1972
1973   widget = new_unit_widget (data, user_units, label);
1974   data->top_widget = widget;
1975   gtk_table_attach (GTK_TABLE (table), widget,
1976                     1, 2, 0, 1, GTK_FILL, 0, 0, 0);
1977   gtk_widget_show (widget);
1978
1979   label = gtk_label_new_with_mnemonic (_("_Bottom:"));
1980   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1981   gtk_table_attach (GTK_TABLE (table), label,
1982                     0, 1 , 1, 2, GTK_FILL, 0, 0, 0);
1983   gtk_widget_show (label);
1984
1985   widget = new_unit_widget (data, user_units, label);
1986   data->bottom_widget = widget;
1987   gtk_table_attach (GTK_TABLE (table), widget,
1988                     1, 2, 1, 2, GTK_FILL, 0, 0, 0);
1989   gtk_widget_show (widget);
1990
1991   label = gtk_label_new_with_mnemonic (_("_Left:"));
1992   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1993   gtk_table_attach (GTK_TABLE (table), label,
1994                     0, 1, 2, 3, GTK_FILL, 0, 0, 0);
1995   gtk_widget_show (label);
1996
1997   widget = new_unit_widget (data, user_units, label);
1998   data->left_widget = widget;
1999   gtk_table_attach (GTK_TABLE (table), widget,
2000                     1, 2, 2, 3, GTK_FILL, 0, 0, 0);
2001   gtk_widget_show (widget);
2002
2003   label = gtk_label_new_with_mnemonic (_("_Right:"));
2004   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
2005   gtk_table_attach (GTK_TABLE (table), label,
2006                     0, 1, 3, 4, GTK_FILL, 0, 0, 0);
2007   gtk_widget_show (label);
2008
2009   widget = new_unit_widget (data, user_units, label);
2010   data->right_widget = widget;
2011   gtk_table_attach (GTK_TABLE (table), widget,
2012                     1, 2, 3, 4, GTK_FILL, 0, 0, 0);
2013   gtk_widget_show (widget);
2014
2015   hbox = gtk_hbox_new (FALSE, 0);
2016   gtk_table_attach (GTK_TABLE (table), hbox,
2017                     0, 2, 4, 5, GTK_FILL | GTK_EXPAND, 0, 0, 0);
2018   gtk_widget_show (hbox);
2019
2020   combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->printer_list));
2021   data->printer_combo = combo;
2022
2023   data->printer_inserted_tag =
2024     g_signal_connect_swapped (priv->printer_list, "row-inserted",
2025                               G_CALLBACK (update_combo_sensitivity_from_printers), data);
2026   data->printer_removed_tag =
2027     g_signal_connect_swapped (priv->printer_list, "row-deleted",
2028                               G_CALLBACK (update_combo_sensitivity_from_printers), data);
2029   update_combo_sensitivity_from_printers (data);
2030
2031   cell = gtk_cell_renderer_text_new ();
2032   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
2033   gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell,
2034                                       custom_paper_printer_data_func,
2035                                       NULL, NULL);
2036
2037   gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
2038   gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
2039   gtk_widget_show (combo);
2040
2041   g_signal_connect_swapped (combo, "changed",
2042                             G_CALLBACK (margins_from_printer_changed), data);
2043
2044   frame = wrap_in_frame (_("Paper Margins"), table);
2045   gtk_widget_show (table);
2046   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2047   gtk_widget_show (frame);
2048
2049   update_custom_widgets_from_list (data);
2050
2051   /* If no custom sizes, add one */
2052   if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->custom_paper_list),
2053                                       &iter))
2054     {
2055       /* Need to realize treeview so we can start the rename */
2056       gtk_widget_realize (treeview);
2057       add_custom_paper (data);
2058     }
2059
2060   gtk_window_present (GTK_WINDOW (dialog));
2061 }
2062
2063
2064 #define __GTK_PAGE_SETUP_UNIX_DIALOG_C__
2065 #include "gtkaliasdef.c"