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