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