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

   1 /* GtkPrinterOptionWidget
   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 #include "config.h"
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <ctype.h>
  25
  26 #include "gtkintl.h"
  27 #include "gtkcheckbutton.h"
  28 #include "gtkcelllayout.h"
  29 #include "gtkcellrenderertext.h"
  30 #include "gtkcombobox.h"
  31 #include "gtkfilechooserbutton.h"
  32 #include "gtkimage.h"
  33 #include "gtklabel.h"
  34 #include "gtkliststore.h"
  35 #include "gtkradiobutton.h"
  36 #include "gtkstock.h"
  37 #include "gtktable.h"
  38 #include "gtktogglebutton.h"
  39 #include "gtkorientable.h"
  40 #include "gtkprivate.h"
  41
  42 #include "gtkprinteroptionwidget.h"
  43
  44 #define GTK_PRINTER_OPTION_WIDGET_GET_PRIVATE(o)  \
  45    (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINTER_OPTION_WIDGET, GtkPrinterOptionWidgetPrivate))
  46
  47 static void gtk_printer_option_widget_finalize (GObject *object);
  48
  49 static void deconstruct_widgets (GtkPrinterOptionWidget *widget);
  50 static void construct_widgets (GtkPrinterOptionWidget *widget);
  51 static void update_widgets (GtkPrinterOptionWidget *widget);
  52
  53 struct GtkPrinterOptionWidgetPrivate
  54 {
  55   GtkPrinterOption *source;
  56   gulong source_changed_handler;
  57
  58   GtkWidget *check;
  59   GtkWidget *combo;
  60   GtkWidget *entry;
  61   GtkWidget *image;
  62   GtkWidget *label;
  63   GtkWidget *filechooser;
  64   GtkWidget *box;
  65 };
  66
  67 enum {
  68   CHANGED,
  69   LAST_SIGNAL
  70 };
  71
  72 enum {
  73   PROP_0,
  74   PROP_SOURCE
  75 };
  76
  77 static guint signals[LAST_SIGNAL] = { 0 };
  78
  79 G_DEFINE_TYPE (GtkPrinterOptionWidget, gtk_printer_option_widget, GTK_TYPE_BOX)
  80
  81 static void gtk_printer_option_widget_set_property (GObject      *object,
  82                                                     guint         prop_id,
  83                                                     const GValue *value,
  84                                                     GParamSpec   *pspec);
  85 static void gtk_printer_option_widget_get_property (GObject      *object,
  86                                                     guint         prop_id,
  87                                                     GValue       *value,
  88                                                     GParamSpec   *pspec);
  89 static gboolean gtk_printer_option_widget_mnemonic_activate (GtkWidget *widget,
  90                                                               gboolean  group_cycling);
  91
  92 static void
  93 gtk_printer_option_widget_class_init (GtkPrinterOptionWidgetClass *class)
  94 {
  95   GObjectClass *object_class;
  96   GtkWidgetClass *widget_class;
  97
  98   object_class = (GObjectClass *) class;
  99   widget_class = (GtkWidgetClass *) class;
 100
 101   object_class->finalize = gtk_printer_option_widget_finalize;
 102   object_class->set_property = gtk_printer_option_widget_set_property;
 103   object_class->get_property = gtk_printer_option_widget_get_property;
 104
 105   widget_class->mnemonic_activate = gtk_printer_option_widget_mnemonic_activate;
 106
 107   g_type_class_add_private (class, sizeof (GtkPrinterOptionWidgetPrivate));
 108
 109   signals[CHANGED] =
 110     g_signal_new ("changed",
 111                   G_TYPE_FROM_CLASS (class),
 112                   G_SIGNAL_RUN_LAST,
 113                   G_STRUCT_OFFSET (GtkPrinterOptionWidgetClass, changed),
 114                   NULL, NULL,
 115                   g_cclosure_marshal_VOID__VOID,
 116                   G_TYPE_NONE, 0);
 117
 118   g_object_class_install_property (object_class,
 119                                    PROP_SOURCE,
 120                                    g_param_spec_object ("source",
 121                                                         P_("Source option"),
 122                                                         P_("The PrinterOption backing this widget"),
 123                                                         GTK_TYPE_PRINTER_OPTION,
 124                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 125
 126 }
 127
 128 static void
 129 gtk_printer_option_widget_init (GtkPrinterOptionWidget *widget)
 130 {
 131   widget->priv = GTK_PRINTER_OPTION_WIDGET_GET_PRIVATE (widget);
 132
 133   gtk_box_set_spacing (GTK_BOX (widget), 12);
 134 }
 135
 136 static void
 137 gtk_printer_option_widget_finalize (GObject *object)
 138 {
 139   GtkPrinterOptionWidget *widget = GTK_PRINTER_OPTION_WIDGET (object);
 140   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 141
 142   if (priv->source)
 143     {
 144       g_object_unref (priv->source);
 145       priv->source = NULL;
 146     }
 147
 148   G_OBJECT_CLASS (gtk_printer_option_widget_parent_class)->finalize (object);
 149 }
 150
 151 static void
 152 gtk_printer_option_widget_set_property (GObject         *object,
 153                                         guint            prop_id,
 154                                         const GValue    *value,
 155                                         GParamSpec      *pspec)
 156 {
 157   GtkPrinterOptionWidget *widget;
 158
 159   widget = GTK_PRINTER_OPTION_WIDGET (object);
 160
 161   switch (prop_id)
 162     {
 163     case PROP_SOURCE:
 164       gtk_printer_option_widget_set_source (widget, g_value_get_object (value));
 165       break;
 166     default:
 167       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 168       break;
 169     }
 170 }
 171
 172 static void
 173 gtk_printer_option_widget_get_property (GObject    *object,
 174                                         guint       prop_id,
 175                                         GValue     *value,
 176                                         GParamSpec *pspec)
 177 {
 178   GtkPrinterOptionWidget *widget = GTK_PRINTER_OPTION_WIDGET (object);
 179   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 180
 181   switch (prop_id)
 182     {
 183     case PROP_SOURCE:
 184       g_value_set_object (value, priv->source);
 185       break;
 186     default:
 187       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 188       break;
 189     }
 190 }
 191
 192 static gboolean
 193 gtk_printer_option_widget_mnemonic_activate (GtkWidget *widget,
 194                                              gboolean   group_cycling)
 195 {
 196   GtkPrinterOptionWidget *powidget = GTK_PRINTER_OPTION_WIDGET (widget);
 197   GtkPrinterOptionWidgetPrivate *priv = powidget->priv;
 198
 199   if (priv->check)
 200     return gtk_widget_mnemonic_activate (priv->check, group_cycling);
 201   if (priv->combo)
 202     return gtk_widget_mnemonic_activate (priv->combo, group_cycling);
 203   if (priv->entry)
 204     return gtk_widget_mnemonic_activate (priv->entry, group_cycling);
 205
 206   return FALSE;
 207 }
 208
 209 static void
 210 emit_changed (GtkPrinterOptionWidget *widget)
 211 {
 212   g_signal_emit (widget, signals[CHANGED], 0);
 213 }
 214
 215 GtkWidget *
 216 gtk_printer_option_widget_new (GtkPrinterOption *source)
 217 {
 218   return g_object_new (GTK_TYPE_PRINTER_OPTION_WIDGET, "source", source, NULL);
 219 }
 220
 221 static void
 222 source_changed_cb (GtkPrinterOption *source,
 223                    GtkPrinterOptionWidget  *widget)
 224 {
 225   update_widgets (widget);
 226   emit_changed (widget);
 227 }
 228
 229 void
 230 gtk_printer_option_widget_set_source (GtkPrinterOptionWidget *widget,
 231                                       GtkPrinterOption       *source)
 232 {
 233   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 234
 235   if (source)
 236     g_object_ref (source);
 237
 238   if (priv->source)
 239     {
 240       g_signal_handler_disconnect (priv->source,
 241                                    priv->source_changed_handler);
 242       g_object_unref (priv->source);
 243     }
 244
 245   priv->source = source;
 246
 247   if (source)
 248     priv->source_changed_handler =
 249       g_signal_connect (source, "changed", G_CALLBACK (source_changed_cb), widget);
 250
 251   construct_widgets (widget);
 252   update_widgets (widget);
 253
 254   g_object_notify (G_OBJECT (widget), "source");
 255 }
 256
 257 enum {
 258   NAME_COLUMN,
 259   VALUE_COLUMN,
 260   N_COLUMNS
 261 };
 262
 263 static void
 264 combo_box_set_model (GtkWidget *combo_box)
 265 {
 266   GtkListStore *store;
 267
 268   store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
 269   gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store));
 270   g_object_unref (store);
 271 }
 272
 273 static void
 274 combo_box_set_view (GtkWidget *combo_box)
 275 {
 276   GtkCellRenderer *cell;
 277
 278   cell = gtk_cell_renderer_text_new ();
 279   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE);
 280   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
 281                                   "text", NAME_COLUMN,
 282                                    NULL);
 283 }
 284
 285 static GtkWidget *
 286 combo_box_entry_new (void)
 287 {
 288   GtkWidget *combo_box;
 289   combo_box = g_object_new (GTK_TYPE_COMBO_BOX, "has-entry", TRUE, NULL);
 290
 291   combo_box_set_model (combo_box);
 292
 293   gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (combo_box), NAME_COLUMN);
 294
 295   return combo_box;
 296 }
 297
 298 static GtkWidget *
 299 combo_box_new (void)
 300 {
 301   GtkWidget *combo_box;
 302   combo_box = gtk_combo_box_new ();
 303
 304   combo_box_set_model (combo_box);
 305   combo_box_set_view (combo_box);
 306
 307   return combo_box;
 308 }
 309
 310 static void
 311 combo_box_append (GtkWidget   *combo,
 312                   const gchar *display_text,
 313                   const gchar *value)
 314 {
 315   GtkTreeModel *model;
 316   GtkListStore *store;
 317   GtkTreeIter iter;
 318
 319   model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
 320   store = GTK_LIST_STORE (model);
 321
 322   gtk_list_store_append (store, &iter);
 323   gtk_list_store_set (store, &iter,
 324                       NAME_COLUMN, display_text,
 325                       VALUE_COLUMN, value,
 326                       -1);
 327 }
 328
 329 struct ComboSet {
 330   GtkComboBox *combo;
 331   const gchar *value;
 332 };
 333
 334 static gboolean
 335 set_cb (GtkTreeModel *model,
 336         GtkTreePath  *path,
 337         GtkTreeIter  *iter,
 338         gpointer      data)
 339 {
 340   struct ComboSet *set_data = data;
 341   gboolean found;
 342   char *value;
 343
 344   gtk_tree_model_get (model, iter, VALUE_COLUMN, &value, -1);
 345   found = (strcmp (value, set_data->value) == 0);
 346   g_free (value);
 347
 348   if (found)
 349     gtk_combo_box_set_active_iter (set_data->combo, iter);
 350
 351   return found;
 352 }
 353
 354 static void
 355 combo_box_set (GtkWidget   *combo,
 356                const gchar *value)
 357 {
 358   GtkTreeModel *model;
 359   struct ComboSet set_data;
 360
 361   model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
 362
 363   set_data.combo = GTK_COMBO_BOX (combo);
 364   set_data.value = value;
 365   gtk_tree_model_foreach (model, set_cb, &set_data);
 366 }
 367
 368 static char *
 369 combo_box_get (GtkWidget *combo)
 370 {
 371   GtkTreeModel *model;
 372   gchar *value;
 373   GtkTreeIter iter;
 374
 375   model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
 376
 377   value = NULL;
 378   if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
 379      gtk_tree_model_get (model, &iter, VALUE_COLUMN, &value, -1);
 380
 381   return value;
 382 }
 383
 384
 385 static void
 386 deconstruct_widgets (GtkPrinterOptionWidget *widget)
 387 {
 388   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 389
 390   if (priv->check)
 391     {
 392       gtk_widget_destroy (priv->check);
 393       priv->check = NULL;
 394     }
 395
 396   if (priv->combo)
 397     {
 398       gtk_widget_destroy (priv->combo);
 399       priv->combo = NULL;
 400     }
 401
 402   if (priv->entry)
 403     {
 404       gtk_widget_destroy (priv->entry);
 405       priv->entry = NULL;
 406     }
 407
 408   /* make sure entry and combo are destroyed first */
 409   /* as we use the two of them to create the filechooser */
 410   if (priv->filechooser)
 411     {
 412       gtk_widget_destroy (priv->filechooser);
 413       priv->filechooser = NULL;
 414     }
 415
 416   if (priv->image)
 417     {
 418       gtk_widget_destroy (priv->image);
 419       priv->image = NULL;
 420     }
 421
 422   if (priv->label)
 423     {
 424       gtk_widget_destroy (priv->label);
 425       priv->label = NULL;
 426     }
 427 }
 428
 429 static void
 430 check_toggled_cb (GtkToggleButton        *toggle_button,
 431                   GtkPrinterOptionWidget *widget)
 432 {
 433   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 434
 435   g_signal_handler_block (priv->source, priv->source_changed_handler);
 436   gtk_printer_option_set_boolean (priv->source,
 437                                   gtk_toggle_button_get_active (toggle_button));
 438   g_signal_handler_unblock (priv->source, priv->source_changed_handler);
 439   emit_changed (widget);
 440 }
 441
 442 static void
 443 filesave_changed_cb (GtkWidget              *button,
 444                      GtkPrinterOptionWidget *widget)
 445 {
 446   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 447   gchar *uri, *file;
 448   gchar *directory;
 449
 450   file = g_filename_from_utf8 (gtk_entry_get_text (GTK_ENTRY (priv->entry)),
 451                                -1, NULL, NULL, NULL);
 452   if (file == NULL)
 453     return;
 454
 455   /* combine the value of the chooser with the value of the entry */
 456   g_signal_handler_block (priv->source, priv->source_changed_handler);
 457
 458   directory = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (priv->combo));
 459
 460   if ((g_uri_parse_scheme (file) == NULL) && (directory != NULL))
 461     {
 462       if (g_path_is_absolute (file))
 463         uri = g_filename_to_uri (file, NULL, NULL);
 464       else
 465         {
 466           gchar *path;
 467
 468 #ifdef G_OS_UNIX
 469           if (file[0] == '~' && file[1] == '/')
 470             {
 471               path = g_build_filename (g_get_home_dir (), file + 2, NULL);
 472             }
 473           else
 474 #endif
 475             {
 476               path = g_build_filename (directory, file, NULL);
 477             }
 478
 479           uri = g_filename_to_uri (path, NULL, NULL);
 480
 481           g_free (path);
 482         }
 483     }
 484   else
 485     {
 486       if (g_uri_parse_scheme (file) != NULL)
 487         uri = g_strdup (file);
 488       else
 489         uri = g_build_path ("/", gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (priv->combo)), file, NULL);
 490     }
 491
 492   if (uri)
 493     gtk_printer_option_set (priv->source, uri);
 494
 495   g_free (uri);
 496   g_free (file);
 497   g_free (directory);
 498
 499   g_signal_handler_unblock (priv->source, priv->source_changed_handler);
 500   emit_changed (widget);
 501 }
 502
 503 static gchar *
 504 filter_numeric (const gchar *val,
 505                 gboolean     allow_neg,
 506                 gboolean     allow_dec,
 507                 gboolean    *changed_out)
 508 {
 509   gchar *filtered_val;
 510   int i, j;
 511   int len = strlen (val);
 512   gboolean dec_set = FALSE;
 513
 514   filtered_val = g_malloc (len + 1);
 515
 516   for (i = 0, j = 0; i < len; i++)
 517     {
 518       if (isdigit (val[i]))
 519         {
 520           filtered_val[j] = val[i];
 521           j++;
 522         }
 523       else if (allow_dec && !dec_set &&
 524                (val[i] == '.' || val[i] == ','))
 525         {
 526           /* allow one period or comma
 527            * we should be checking locals
 528            * but this is good enough for now
 529            */
 530           filtered_val[j] = val[i];
 531           dec_set = TRUE;
 532           j++;
 533         }
 534       else if (allow_neg && i == 0 && val[0] == '-')
 535         {
 536           filtered_val[0] = val[0];
 537           j++;
 538         }
 539     }
 540
 541   filtered_val[j] = '\0';
 542   *changed_out = !(i == j);
 543
 544   return filtered_val;
 545 }
 546
 547 static void
 548 combo_changed_cb (GtkWidget              *combo,
 549                   GtkPrinterOptionWidget *widget)
 550 {
 551   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 552   gchar *value;
 553   gchar *filtered_val = NULL;
 554   gboolean changed;
 555
 556   g_signal_handler_block (priv->source, priv->source_changed_handler);
 557
 558   value = combo_box_get (combo);
 559
 560   /* handle some constraints */
 561   switch (priv->source->type)
 562     {
 563     case GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE:
 564       filtered_val = filter_numeric (value, FALSE, FALSE, &changed);
 565       break;
 566     case GTK_PRINTER_OPTION_TYPE_PICKONE_INT:
 567       filtered_val = filter_numeric (value, TRUE, FALSE, &changed);
 568       break;
 569     case GTK_PRINTER_OPTION_TYPE_PICKONE_REAL:
 570       filtered_val = filter_numeric (value, TRUE, TRUE, &changed);
 571       break;
 572     default:
 573       break;
 574     }
 575
 576   if (filtered_val)
 577     {
 578       g_free (value);
 579
 580       if (changed)
 581         {
 582           GtkEntry *entry;
 583
 584           entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo)));
 585
 586           gtk_entry_set_text (entry, filtered_val);
 587         }
 588       value = filtered_val;
 589     }
 590
 591   if (value)
 592     gtk_printer_option_set (priv->source, value);
 593   g_free (value);
 594   g_signal_handler_unblock (priv->source, priv->source_changed_handler);
 595   emit_changed (widget);
 596 }
 597
 598 static void
 599 entry_changed_cb (GtkWidget              *entry,
 600                   GtkPrinterOptionWidget *widget)
 601 {
 602   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 603   const gchar *value;
 604
 605   g_signal_handler_block (priv->source, priv->source_changed_handler);
 606   value = gtk_entry_get_text (GTK_ENTRY (entry));
 607   if (value)
 608     gtk_printer_option_set (priv->source, value);
 609   g_signal_handler_unblock (priv->source, priv->source_changed_handler);
 610   emit_changed (widget);
 611 }
 612
 613
 614 static void
 615 radio_changed_cb (GtkWidget              *button,
 616                   GtkPrinterOptionWidget *widget)
 617 {
 618   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 619   gchar *value;
 620
 621   g_signal_handler_block (priv->source, priv->source_changed_handler);
 622   value = g_object_get_data (G_OBJECT (button), "value");
 623   if (value)
 624     gtk_printer_option_set (priv->source, value);
 625   g_signal_handler_unblock (priv->source, priv->source_changed_handler);
 626   emit_changed (widget);
 627 }
 628
 629 static void
 630 select_maybe (GtkWidget   *widget,
 631               const gchar *value)
 632 {
 633   gchar *v = g_object_get_data (G_OBJECT (widget), "value");
 634
 635   if (strcmp (value, v) == 0)
 636     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
 637 }
 638
 639 static void
 640 alternative_set (GtkWidget   *box,
 641                  const gchar *value)
 642 {
 643   gtk_container_foreach (GTK_CONTAINER (box),
 644                          (GtkCallback) select_maybe,
 645                          (gpointer) value);
 646 }
 647
 648 static GSList *
 649 alternative_append (GtkWidget              *box,
 650                     const gchar            *label,
 651                     const gchar            *value,
 652                     GtkPrinterOptionWidget *widget,
 653                     GSList                 *group)
 654 {
 655   GtkWidget *button;
 656
 657   button = gtk_radio_button_new_with_label (group, label);
 658   gtk_widget_show (button);
 659   gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
 660
 661   g_object_set_data (G_OBJECT (button), "value", (gpointer)value);
 662   g_signal_connect (button, "toggled",
 663                     G_CALLBACK (radio_changed_cb), widget);
 664
 665   return gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
 666 }
 667
 668 static void
 669 construct_widgets (GtkPrinterOptionWidget *widget)
 670 {
 671   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 672   GtkPrinterOption *source;
 673   char *text;
 674   int i;
 675   GSList *group;
 676
 677   source = priv->source;
 678
 679   deconstruct_widgets (widget);
 680
 681   gtk_widget_set_sensitive (GTK_WIDGET (widget), TRUE);
 682
 683   if (source == NULL)
 684     {
 685       priv->combo = combo_box_new ();
 686       combo_box_append (priv->combo,_("Not available"), "None");
 687       gtk_combo_box_set_active (GTK_COMBO_BOX (priv->combo), 0);
 688       gtk_widget_set_sensitive (GTK_WIDGET (widget), FALSE);
 689       gtk_widget_show (priv->combo);
 690       gtk_box_pack_start (GTK_BOX (widget), priv->combo, TRUE, TRUE, 0);
 691     }
 692   else switch (source->type)
 693     {
 694     case GTK_PRINTER_OPTION_TYPE_BOOLEAN:
 695       priv->check = gtk_check_button_new_with_mnemonic (source->display_text);
 696       g_signal_connect (priv->check, "toggled", G_CALLBACK (check_toggled_cb), widget);
 697       gtk_widget_show (priv->check);
 698       gtk_box_pack_start (GTK_BOX (widget), priv->check, TRUE, TRUE, 0);
 699       break;
 700     case GTK_PRINTER_OPTION_TYPE_PICKONE:
 701     case GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD:
 702     case GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE:
 703     case GTK_PRINTER_OPTION_TYPE_PICKONE_REAL:
 704     case GTK_PRINTER_OPTION_TYPE_PICKONE_INT:
 705     case GTK_PRINTER_OPTION_TYPE_PICKONE_STRING:
 706       if (source->type == GTK_PRINTER_OPTION_TYPE_PICKONE)
 707         {
 708           priv->combo = combo_box_new ();
 709         }
 710       else
 711         {
 712           priv->combo = combo_box_entry_new ();
 713
 714           if (source->type == GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD ||
 715               source->type == GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE)
 716             {
 717               GtkEntry *entry;
 718
 719               entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (priv->combo)));
 720
 721               gtk_entry_set_visibility (entry, FALSE);
 722             }
 723         }
 724
 725
 726       for (i = 0; i < source->num_choices; i++)
 727           combo_box_append (priv->combo,
 728                             source->choices_display[i],
 729                             source->choices[i]);
 730       gtk_widget_show (priv->combo);
 731       gtk_box_pack_start (GTK_BOX (widget), priv->combo, TRUE, TRUE, 0);
 732       g_signal_connect (priv->combo, "changed", G_CALLBACK (combo_changed_cb), widget);
 733
 734       text = g_strdup_printf ("%s:", source->display_text);
 735       priv->label = gtk_label_new_with_mnemonic (text);
 736       g_free (text);
 737       gtk_widget_show (priv->label);
 738       break;
 739
 740     case GTK_PRINTER_OPTION_TYPE_ALTERNATIVE:
 741       group = NULL;
 742       priv->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
 743       gtk_widget_show (priv->box);
 744       gtk_box_pack_start (GTK_BOX (widget), priv->box, TRUE, TRUE, 0);
 745       for (i = 0; i < source->num_choices; i++)
 746         group = alternative_append (priv->box,
 747                                     source->choices_display[i],
 748                                     source->choices[i],
 749                                     widget,
 750                                     group);
 751
 752       if (source->display_text)
 753         {
 754           text = g_strdup_printf ("%s:", source->display_text);
 755           priv->label = gtk_label_new_with_mnemonic (text);
 756           g_free (text);
 757           gtk_widget_show (priv->label);
 758         }
 759       break;
 760
 761     case GTK_PRINTER_OPTION_TYPE_STRING:
 762       priv->entry = gtk_entry_new ();
 763       gtk_entry_set_activates_default (GTK_ENTRY (priv->entry),
 764                                        gtk_printer_option_get_activates_default (source));
 765       gtk_widget_show (priv->entry);
 766       gtk_box_pack_start (GTK_BOX (widget), priv->entry, TRUE, TRUE, 0);
 767       g_signal_connect (priv->entry, "changed", G_CALLBACK (entry_changed_cb), widget);
 768
 769       text = g_strdup_printf ("%s:", source->display_text);
 770       priv->label = gtk_label_new_with_mnemonic (text);
 771       g_free (text);
 772       gtk_widget_show (priv->label);
 773
 774       break;
 775
 776     case GTK_PRINTER_OPTION_TYPE_FILESAVE:
 777       {
 778         GtkWidget *label;
 779
 780         priv->filechooser = gtk_table_new (2, 2, FALSE);
 781         gtk_table_set_row_spacings (GTK_TABLE (priv->filechooser), 6);
 782         gtk_table_set_col_spacings (GTK_TABLE (priv->filechooser), 12);
 783
 784         /* TODO: make this a gtkfilechooserentry once we move to GTK */
 785         priv->entry = gtk_entry_new ();
 786         priv->combo = gtk_file_chooser_button_new (_("Select a folder"),
 787                                                    GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
 788
 789         g_object_set (priv->combo, "local-only", FALSE, NULL);
 790         gtk_entry_set_activates_default (GTK_ENTRY (priv->entry),
 791                                          gtk_printer_option_get_activates_default (source));
 792
 793         label = gtk_label_new_with_mnemonic (_("_Name:"));
 794         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 795         gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->entry);
 796
 797         gtk_table_attach (GTK_TABLE (priv->filechooser), label,
 798                           0, 1, 0, 1, GTK_FILL, 0,
 799                           0, 0);
 800
 801         gtk_table_attach (GTK_TABLE (priv->filechooser), priv->entry,
 802                           1, 2, 0, 1, GTK_FILL, 0,
 803                           0, 0);
 804
 805         label = gtk_label_new_with_mnemonic (_("_Save in folder:"));
 806         gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 807         gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->combo);
 808
 809         gtk_table_attach (GTK_TABLE (priv->filechooser), label,
 810                           0, 1, 1, 2, GTK_FILL, 0,
 811                           0, 0);
 812
 813         gtk_table_attach (GTK_TABLE (priv->filechooser), priv->combo,
 814                           1, 2, 1, 2, GTK_FILL, 0,
 815                           0, 0);
 816
 817         gtk_widget_show_all (priv->filechooser);
 818         gtk_box_pack_start (GTK_BOX (widget), priv->filechooser, TRUE, TRUE, 0);
 819
 820         g_signal_connect (priv->entry, "changed", G_CALLBACK (filesave_changed_cb), widget);
 821
 822         g_signal_connect (priv->combo, "selection-changed", G_CALLBACK (filesave_changed_cb), widget);
 823       }
 824       break;
 825     default:
 826       break;
 827     }
 828
 829   priv->image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU);
 830   gtk_box_pack_start (GTK_BOX (widget), priv->image, FALSE, FALSE, 0);
 831 }
 832
 833 static void
 834 update_widgets (GtkPrinterOptionWidget *widget)
 835 {
 836   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 837   GtkPrinterOption *source;
 838
 839   source = priv->source;
 840
 841   if (source == NULL)
 842     {
 843       gtk_widget_hide (priv->image);
 844       return;
 845     }
 846
 847   switch (source->type)
 848     {
 849     case GTK_PRINTER_OPTION_TYPE_BOOLEAN:
 850       if (g_ascii_strcasecmp (source->value, "True") == 0)
 851         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check), TRUE);
 852       else
 853         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check), FALSE);
 854       break;
 855     case GTK_PRINTER_OPTION_TYPE_PICKONE:
 856       combo_box_set (priv->combo, source->value);
 857       break;
 858     case GTK_PRINTER_OPTION_TYPE_ALTERNATIVE:
 859       alternative_set (priv->box, source->value);
 860       break;
 861     case GTK_PRINTER_OPTION_TYPE_STRING:
 862       gtk_entry_set_text (GTK_ENTRY (priv->entry), source->value);
 863       break;
 864     case GTK_PRINTER_OPTION_TYPE_FILESAVE:
 865       {
 866         gchar *filename = g_filename_from_uri (source->value, NULL, NULL);
 867         if (filename != NULL)
 868           {
 869             gchar *basename, *dirname, *text;
 870
 871             basename = g_path_get_basename (filename);
 872             dirname = g_path_get_dirname (filename);
 873             text = g_filename_to_utf8 (basename, -1, NULL, NULL, NULL);
 874
 875             if (text != NULL)
 876               gtk_entry_set_text (GTK_ENTRY (priv->entry), text);
 877             if (g_path_is_absolute (dirname))
 878               gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (priv->combo),
 879                                                    dirname);
 880             g_free (text);
 881             g_free (basename);
 882             g_free (dirname);
 883             g_free (filename);
 884           }
 885         else
 886           gtk_entry_set_text (GTK_ENTRY (priv->entry), source->value);
 887         break;
 888       }
 889     default:
 890       break;
 891     }
 892
 893   if (source->has_conflict)
 894     gtk_widget_show (priv->image);
 895   else
 896     gtk_widget_hide (priv->image);
 897 }
 898
 899 gboolean
 900 gtk_printer_option_widget_has_external_label (GtkPrinterOptionWidget *widget)
 901 {
 902   return widget->priv->label != NULL;
 903 }
 904
 905 GtkWidget *
 906 gtk_printer_option_widget_get_external_label (GtkPrinterOptionWidget  *widget)
 907 {
 908   return widget->priv->label;
 909 }
 910
 911 const gchar *
 912 gtk_printer_option_widget_get_value (GtkPrinterOptionWidget *widget)
 913 {
 914   GtkPrinterOptionWidgetPrivate *priv = widget->priv;
 915
 916   if (priv->source)
 917     return priv->source->value;
 918
 919   return "";
 920 }