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