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

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