libempathy-gtk/gossip-preferences.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2003-2007 Imendio AB
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Authors: Mikael Hallendal <micke@imendio.com>
  21  *          Richard Hult <richard@imendio.com>
  22  *          Martyn Russell <martyn@imendio.com>
  23  */
  24
  25 #include "config.h"
  26
  27 #include <string.h>
  28
  29 #include <gtk/gtk.h>
  30 #include <glade/glade.h>
  31 #include <glib/gi18n.h>
  32
  33 #include <libempathy/gossip-conf.h>
  34
  35 #include "gossip-preferences.h"
  36 #include "gossip-ui-utils.h"
  37 #include "gossip-theme-manager.h"
  38 #include "gossip-spell.h"
  39
  40 typedef struct {
  41         GtkWidget *dialog;
  42
  43         GtkWidget *notebook;
  44
  45         GtkWidget *checkbutton_show_avatars;
  46         GtkWidget *checkbutton_compact_contact_list;
  47         GtkWidget *checkbutton_show_smileys;
  48         GtkWidget *combobox_chat_theme;
  49         GtkWidget *checkbutton_theme_chat_room;
  50         GtkWidget *checkbutton_separate_chat_windows;
  51
  52         GtkWidget *checkbutton_sounds_for_messages;
  53         GtkWidget *checkbutton_sounds_when_busy;
  54         GtkWidget *checkbutton_sounds_when_away;
  55         GtkWidget *checkbutton_popups_when_available;
  56
  57         GtkWidget *treeview_spell_checker;
  58         GtkWidget *checkbutton_spell_checker;
  59
  60         GList     *notify_ids;
  61 } GossipPreferences;
  62
  63 static void     preferences_setup_widgets                (GossipPreferences      *preferences);
  64 static void     preferences_languages_setup              (GossipPreferences      *preferences);
  65 static void     preferences_languages_add                (GossipPreferences      *preferences);
  66 static void     preferences_languages_save               (GossipPreferences      *preferences);
  67 static gboolean preferences_languages_save_foreach       (GtkTreeModel           *model,
  68                                                           GtkTreePath            *path,
  69                                                           GtkTreeIter            *iter,
  70                                                           gchar                 **languages);
  71 static void     preferences_languages_load               (GossipPreferences      *preferences);
  72 static gboolean preferences_languages_load_foreach       (GtkTreeModel           *model,
  73                                                           GtkTreePath            *path,
  74                                                           GtkTreeIter            *iter,
  75                                                           gchar                 **languages);
  76 static void     preferences_languages_cell_toggled_cb    (GtkCellRendererToggle  *cell,
  77                                                           gchar                  *path_string,
  78                                                           GossipPreferences      *preferences);
  79 static void     preferences_themes_setup                 (GossipPreferences      *preferences);
  80 static void     preferences_widget_sync_bool             (const gchar            *key,
  81                                                           GtkWidget              *widget);
  82 static void     preferences_widget_sync_int              (const gchar            *key,
  83                                                           GtkWidget              *widget);
  84 static void     preferences_widget_sync_string           (const gchar            *key,
  85                                                           GtkWidget              *widget);
  86 static void     preferences_widget_sync_string_combo     (const gchar            *key,
  87                                                           GtkWidget              *widget);
  88 static void     preferences_notify_int_cb                (GossipConf             *conf,
  89                                                           const gchar            *key,
  90                                                           gpointer                user_data);
  91 static void     preferences_notify_string_cb             (GossipConf             *conf,
  92                                                           const gchar            *key,
  93                                                           gpointer                user_data);
  94 static void     preferences_notify_string_combo_cb       (GossipConf             *conf,
  95                                                           const gchar            *key,
  96                                                           gpointer                user_data);
  97 static void     preferences_notify_bool_cb               (GossipConf             *conf,
  98                                                           const gchar            *key,
  99                                                           gpointer                user_data);
 100 static void     preferences_notify_sensitivity_cb        (GossipConf             *conf,
 101                                                           const gchar            *key,
 102                                                           gpointer                user_data);
 103 static void     preferences_hookup_spin_button           (GossipPreferences      *preferences,
 104                                                           const gchar            *key,
 105                                                           GtkWidget              *widget);
 106 static void     preferences_hookup_entry                 (GossipPreferences      *preferences,
 107                                                           const gchar            *key,
 108                                                           GtkWidget              *widget);
 109 static void     preferences_hookup_toggle_button         (GossipPreferences      *preferences,
 110                                                           const gchar            *key,
 111                                                           GtkWidget              *widget);
 112 static void     preferences_hookup_string_combo          (GossipPreferences      *preferences,
 113                                                           const gchar            *key,
 114                                                           GtkWidget              *widget);
 115 static void     preferences_hookup_sensitivity           (GossipPreferences      *preferences,
 116                                                           const gchar            *key,
 117                                                           GtkWidget              *widget);
 118 static void     preferences_spin_button_value_changed_cb (GtkWidget              *button,
 119                                                           gpointer                user_data);
 120 static void     preferences_entry_value_changed_cb       (GtkWidget              *entry,
 121                                                           gpointer                user_data);
 122 static void     preferences_toggle_button_toggled_cb     (GtkWidget              *button,
 123                                                           gpointer                user_data);
 124 static void     preferences_string_combo_changed_cb      (GtkWidget *button,
 125                                                           gpointer                user_data);
 126 static void     preferences_destroy_cb                   (GtkWidget              *widget,
 127                                                           GossipPreferences      *preferences);
 128 static void     preferences_response_cb                  (GtkWidget              *widget,
 129                                                           gint                    response,
 130                                                           GossipPreferences      *preferences);
 131
 132 enum {
 133         COL_LANG_ENABLED,
 134         COL_LANG_CODE,
 135         COL_LANG_NAME,
 136         COL_LANG_COUNT
 137 };
 138
 139 enum {
 140         COL_COMBO_VISIBLE_NAME,
 141         COL_COMBO_NAME,
 142         COL_COMBO_COUNT
 143 };
 144
 145 static void
 146 preferences_setup_widgets (GossipPreferences *preferences)
 147 {
 148         preferences_hookup_toggle_button (preferences,
 149                                           GOSSIP_PREFS_SOUNDS_FOR_MESSAGES,
 150                                           preferences->checkbutton_sounds_for_messages);
 151         preferences_hookup_toggle_button (preferences,
 152                                           GOSSIP_PREFS_SOUNDS_WHEN_AWAY,
 153                                           preferences->checkbutton_sounds_when_away);
 154         preferences_hookup_toggle_button (preferences,
 155                                           GOSSIP_PREFS_SOUNDS_WHEN_BUSY,
 156                                           preferences->checkbutton_sounds_when_busy);
 157         preferences_hookup_toggle_button (preferences,
 158                                           GOSSIP_PREFS_POPUPS_WHEN_AVAILABLE,
 159                                           preferences->checkbutton_popups_when_available);
 160
 161         preferences_hookup_sensitivity (preferences,
 162                                         GOSSIP_PREFS_SOUNDS_FOR_MESSAGES,
 163                                         preferences->checkbutton_sounds_when_away);
 164         preferences_hookup_sensitivity (preferences,
 165                                         GOSSIP_PREFS_SOUNDS_FOR_MESSAGES,
 166                                         preferences->checkbutton_sounds_when_busy);
 167
 168         preferences_hookup_toggle_button (preferences,
 169                                           GOSSIP_PREFS_UI_SEPARATE_CHAT_WINDOWS,
 170                                           preferences->checkbutton_separate_chat_windows);
 171
 172         preferences_hookup_toggle_button (preferences,
 173                                           GOSSIP_PREFS_UI_SHOW_AVATARS,
 174                                           preferences->checkbutton_show_avatars);
 175
 176         preferences_hookup_toggle_button (preferences,
 177                                           GOSSIP_PREFS_UI_COMPACT_CONTACT_LIST,
 178                                           preferences->checkbutton_compact_contact_list);
 179
 180         preferences_hookup_toggle_button (preferences,
 181                                           GOSSIP_PREFS_CHAT_SHOW_SMILEYS,
 182                                           preferences->checkbutton_show_smileys);
 183
 184         preferences_hookup_string_combo (preferences,
 185                                          GOSSIP_PREFS_CHAT_THEME,
 186                                          preferences->combobox_chat_theme);
 187
 188         preferences_hookup_toggle_button (preferences,
 189                                           GOSSIP_PREFS_CHAT_THEME_CHAT_ROOM,
 190                                           preferences->checkbutton_theme_chat_room);
 191
 192         preferences_hookup_toggle_button (preferences,
 193                                           GOSSIP_PREFS_CHAT_SPELL_CHECKER_ENABLED,
 194                                           preferences->checkbutton_spell_checker);
 195         preferences_hookup_sensitivity (preferences,
 196                                         GOSSIP_PREFS_CHAT_SPELL_CHECKER_ENABLED,
 197                                         preferences->treeview_spell_checker);
 198 }
 199
 200 static void
 201 preferences_languages_setup (GossipPreferences *preferences)
 202 {
 203         GtkTreeView       *view;
 204         GtkListStore      *store;
 205         GtkTreeSelection  *selection;
 206         GtkTreeModel      *model;
 207         GtkTreeViewColumn *column;
 208         GtkCellRenderer   *renderer;
 209         guint              col_offset;
 210
 211         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 212
 213         store = gtk_list_store_new (COL_LANG_COUNT,
 214                                     G_TYPE_BOOLEAN,  /* enabled */
 215                                     G_TYPE_STRING,   /* code */
 216                                     G_TYPE_STRING);  /* name */
 217
 218         gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
 219
 220         selection = gtk_tree_view_get_selection (view);
 221         gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
 222
 223         model = GTK_TREE_MODEL (store);
 224
 225         renderer = gtk_cell_renderer_toggle_new ();
 226         g_signal_connect (renderer, "toggled",
 227                           G_CALLBACK (preferences_languages_cell_toggled_cb),
 228                           preferences);
 229
 230         column = gtk_tree_view_column_new_with_attributes (NULL, renderer,
 231                                                            "active", COL_LANG_ENABLED,
 232                                                            NULL);
 233
 234         gtk_tree_view_append_column (view, column);
 235
 236         renderer = gtk_cell_renderer_text_new ();
 237         col_offset = gtk_tree_view_insert_column_with_attributes (view,
 238                                                                   -1, _("Language"),
 239                                                                   renderer,
 240                                                                   "text", COL_LANG_NAME,
 241                                                                   NULL);
 242
 243         g_object_set_data (G_OBJECT (renderer),
 244                            "column", GINT_TO_POINTER (COL_LANG_NAME));
 245
 246         column = gtk_tree_view_get_column (view, col_offset - 1);
 247         gtk_tree_view_column_set_sort_column_id (column, COL_LANG_NAME);
 248         gtk_tree_view_column_set_resizable (column, FALSE);
 249         gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 250
 251         g_object_unref (store);
 252 }
 253
 254 static void
 255 preferences_languages_add (GossipPreferences *preferences)
 256 {
 257         GtkTreeView  *view;
 258         GtkListStore *store;
 259         GList        *codes, *l;
 260
 261         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 262         store = GTK_LIST_STORE (gtk_tree_view_get_model (view));
 263
 264         codes = gossip_spell_get_language_codes ();
 265         for (l = codes; l; l = l->next) {
 266                 GtkTreeIter  iter;
 267                 const gchar *code;
 268                 const gchar *name;
 269
 270                 code = l->data;
 271                 name = gossip_spell_get_language_name (code);
 272                 if (!name) {
 273                         continue;
 274                 }
 275
 276                 gtk_list_store_append (store, &iter);
 277                 gtk_list_store_set (store, &iter,
 278                                     COL_LANG_CODE, code,
 279                                     COL_LANG_NAME, name,
 280                                     -1);
 281         }
 282
 283         gossip_spell_free_language_codes (codes);
 284 }
 285
 286 static void
 287 preferences_languages_save (GossipPreferences *preferences)
 288 {
 289         GtkTreeView       *view;
 290         GtkTreeModel      *model;
 291
 292         gchar             *languages = NULL;
 293
 294         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 295         model = gtk_tree_view_get_model (view);
 296
 297         gtk_tree_model_foreach (model,
 298                                 (GtkTreeModelForeachFunc) preferences_languages_save_foreach,
 299                                 &languages);
 300
 301         if (!languages) {
 302                 /* Default to english */
 303                 languages = g_strdup ("en");
 304         }
 305
 306         gossip_conf_set_string (gossip_conf_get (),
 307                                  GOSSIP_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
 308                                  languages);
 309
 310         g_free (languages);
 311 }
 312
 313 static gboolean
 314 preferences_languages_save_foreach (GtkTreeModel  *model,
 315                                     GtkTreePath   *path,
 316                                     GtkTreeIter   *iter,
 317                                     gchar        **languages)
 318 {
 319         gboolean  enabled;
 320         gchar    *code;
 321
 322         if (!languages) {
 323                 return TRUE;
 324         }
 325
 326         gtk_tree_model_get (model, iter, COL_LANG_ENABLED, &enabled, -1);
 327         if (!enabled) {
 328                 return FALSE;
 329         }
 330
 331         gtk_tree_model_get (model, iter, COL_LANG_CODE, &code, -1);
 332         if (!code) {
 333                 return FALSE;
 334         }
 335
 336         if (!(*languages)) {
 337                 *languages = g_strdup (code);
 338         } else {
 339                 gchar *str = *languages;
 340                 *languages = g_strdup_printf ("%s,%s", str, code);
 341                 g_free (str);
 342         }
 343
 344         g_free (code);
 345
 346         return FALSE;
 347 }
 348
 349 static void
 350 preferences_languages_load (GossipPreferences *preferences)
 351 {
 352         GtkTreeView   *view;
 353         GtkTreeModel  *model;
 354         gchar         *value;
 355         gchar        **vlanguages;
 356
 357         if (!gossip_conf_get_string (gossip_conf_get (),
 358                                       GOSSIP_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
 359                                       &value) || !value) {
 360                 return;
 361         }
 362
 363         vlanguages = g_strsplit (value, ",", -1);
 364         g_free (value);
 365
 366         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 367         model = gtk_tree_view_get_model (view);
 368
 369         gtk_tree_model_foreach (model,
 370                                 (GtkTreeModelForeachFunc) preferences_languages_load_foreach,
 371                                 vlanguages);
 372
 373         g_strfreev (vlanguages);
 374 }
 375
 376 static gboolean
 377 preferences_languages_load_foreach (GtkTreeModel  *model,
 378                                     GtkTreePath   *path,
 379                                     GtkTreeIter   *iter,
 380                                     gchar        **languages)
 381 {
 382         gchar    *code;
 383         gchar    *lang;
 384         gint      i;
 385         gboolean  found = FALSE;
 386
 387         if (!languages) {
 388                 return TRUE;
 389         }
 390
 391         gtk_tree_model_get (model, iter, COL_LANG_CODE, &code, -1);
 392         if (!code) {
 393                 return FALSE;
 394         }
 395
 396         for (i = 0, lang = languages[i]; lang; lang = languages[++i]) {
 397                 if (strcmp (lang, code) == 0) {
 398                         found = TRUE;
 399                 }
 400         }
 401
 402         gtk_list_store_set (GTK_LIST_STORE (model), iter, COL_LANG_ENABLED, found, -1);
 403         return FALSE;
 404 }
 405
 406 static void
 407 preferences_languages_cell_toggled_cb (GtkCellRendererToggle *cell,
 408                                        gchar                 *path_string,
 409                                        GossipPreferences     *preferences)
 410 {
 411         GtkTreeView  *view;
 412         GtkTreeModel *model;
 413         GtkListStore *store;
 414         GtkTreePath  *path;
 415         GtkTreeIter   iter;
 416         gboolean      enabled;
 417
 418         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 419         model = gtk_tree_view_get_model (view);
 420         store = GTK_LIST_STORE (model);
 421
 422         path = gtk_tree_path_new_from_string (path_string);
 423
 424         gtk_tree_model_get_iter (model, &iter, path);
 425         gtk_tree_model_get (model, &iter, COL_LANG_ENABLED, &enabled, -1);
 426
 427         enabled ^= 1;
 428
 429         gtk_list_store_set (store, &iter, COL_LANG_ENABLED, enabled, -1);
 430         gtk_tree_path_free (path);
 431
 432         preferences_languages_save (preferences);
 433 }
 434
 435 static void
 436 preferences_themes_setup (GossipPreferences *preferences)
 437 {
 438         GtkComboBox   *combo;
 439         GtkListStore  *model;
 440         GtkTreeIter    iter;
 441         const gchar  **themes;
 442         gint           i;
 443
 444         combo = GTK_COMBO_BOX (preferences->combobox_chat_theme);
 445
 446         model = gtk_list_store_new (COL_COMBO_COUNT,
 447                                     G_TYPE_STRING,
 448                                     G_TYPE_STRING);
 449
 450         themes = gossip_theme_manager_get_themes ();
 451         for (i = 0; themes[i]; i += 2) {
 452                 gtk_list_store_append (model, &iter);
 453                 gtk_list_store_set (model, &iter,
 454                                     COL_COMBO_VISIBLE_NAME, _(themes[i + 1]),
 455                                     COL_COMBO_NAME, themes[i],
 456                                     -1);
 457         }
 458
 459         gtk_combo_box_set_model (combo, GTK_TREE_MODEL (model));
 460         g_object_unref (model);
 461 }
 462
 463 static void
 464 preferences_widget_sync_bool (const gchar *key, GtkWidget *widget)
 465 {
 466         gboolean value;
 467
 468         if (gossip_conf_get_bool (gossip_conf_get (), key, &value)) {
 469                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value);
 470         }
 471 }
 472
 473 static void
 474 preferences_widget_sync_int (const gchar *key, GtkWidget *widget)
 475 {
 476         gint value;
 477
 478         if (gossip_conf_get_int (gossip_conf_get (), key, &value)) {
 479                 gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
 480         }
 481 }
 482
 483 static void
 484 preferences_widget_sync_string (const gchar *key, GtkWidget *widget)
 485 {
 486         gchar *value;
 487
 488         if (gossip_conf_get_string (gossip_conf_get (), key, &value) && value) {
 489                 gtk_entry_set_text (GTK_ENTRY (widget), value);
 490                 g_free (value);
 491         }
 492 }
 493
 494 static void
 495 preferences_widget_sync_string_combo (const gchar *key, GtkWidget *widget)
 496 {
 497         gchar        *value;
 498         GtkTreeModel *model;
 499         GtkTreeIter   iter;
 500         gboolean      found;
 501
 502         if (!gossip_conf_get_string (gossip_conf_get (), key, &value)) {
 503                 return;
 504         }
 505
 506         model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
 507
 508         found = FALSE;
 509         if (value && gtk_tree_model_get_iter_first (model, &iter)) {
 510                 gchar *name;
 511
 512                 do {
 513                         gtk_tree_model_get (model, &iter,
 514                                             COL_COMBO_NAME, &name,
 515                                             -1);
 516
 517                         if (strcmp (name, value) == 0) {
 518                                 found = TRUE;
 519                                 gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
 520                                 break;
 521                         } else {
 522                                 found = FALSE;
 523                         }
 524
 525                         g_free (name);
 526                 } while (gtk_tree_model_iter_next (model, &iter));
 527         }
 528
 529         /* Fallback to the first one. */
 530         if (!found) {
 531                 if (gtk_tree_model_get_iter_first (model, &iter)) {
 532                         gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
 533                 }
 534         }
 535
 536         g_free (value);
 537 }
 538
 539 static void
 540 preferences_notify_int_cb (GossipConf  *conf,
 541                            const gchar *key,
 542                            gpointer     user_data)
 543 {
 544         gint value;
 545
 546         if (gossip_conf_get_int (conf, key, &value)) {
 547                 gtk_spin_button_set_value (GTK_SPIN_BUTTON (user_data), value);
 548         }
 549 }
 550
 551 static void
 552 preferences_notify_string_cb (GossipConf  *conf,
 553                               const gchar *key,
 554                               gpointer     user_data)
 555 {
 556         gchar *value;
 557
 558         if (gossip_conf_get_string (conf, key, &value) && value) {
 559                 gtk_entry_set_text (GTK_ENTRY (user_data), value);
 560                 g_free (value);
 561         }
 562 }
 563
 564 static void
 565 preferences_notify_string_combo_cb (GossipConf  *conf,
 566                                     const gchar *key,
 567                                     gpointer     user_data)
 568 {
 569         preferences_widget_sync_string_combo (key, user_data);
 570 }
 571
 572 static void
 573 preferences_notify_bool_cb (GossipConf  *conf,
 574                             const gchar *key,
 575                             gpointer     user_data)
 576 {
 577         preferences_widget_sync_bool (key, user_data);
 578 /*
 579         if (gossip_conf_get_bool (conf, key, &value)) {
 580                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_data),
 581                                               gconf_value_get_bool (value));
 582                                               }
 583 */
 584 }
 585
 586 static void
 587 preferences_notify_sensitivity_cb (GossipConf  *conf,
 588                                    const gchar *key,
 589                                    gpointer     user_data)
 590 {
 591         gboolean value;
 592
 593         if (gossip_conf_get_bool (conf, key, &value)) {
 594                 gtk_widget_set_sensitive (GTK_WIDGET (user_data), value);
 595         }
 596 }
 597
 598 static void
 599 preferences_add_id (GossipPreferences *preferences, guint id)
 600 {
 601         preferences->notify_ids = g_list_prepend (preferences->notify_ids,
 602                                                   GUINT_TO_POINTER (id));
 603 }
 604
 605 static void
 606 preferences_hookup_spin_button (GossipPreferences *preferences,
 607                                 const gchar       *key,
 608                                 GtkWidget         *widget)
 609 {
 610         guint id;
 611
 612         /* Silence warning. */
 613         if (0) {
 614                 preferences_hookup_spin_button (preferences, key, widget);
 615         }
 616
 617         preferences_widget_sync_int (key, widget);
 618
 619         g_object_set_data_full (G_OBJECT (widget), "key",
 620                                 g_strdup (key), g_free);
 621
 622         g_signal_connect (widget,
 623                           "value_changed",
 624                           G_CALLBACK (preferences_spin_button_value_changed_cb),
 625                           NULL);
 626
 627         id = gossip_conf_notify_add (gossip_conf_get (),
 628                                       key,
 629                                       preferences_notify_int_cb,
 630                                       widget);
 631         if (id) {
 632                 preferences_add_id (preferences, id);
 633         }
 634 }
 635
 636 static void
 637 preferences_hookup_entry (GossipPreferences *preferences,
 638                           const gchar       *key,
 639                           GtkWidget         *widget)
 640 {
 641         guint id;
 642
 643         if (0) {  /* Silent warning before we use this function. */
 644                 preferences_hookup_entry (preferences, key, widget);
 645         }
 646
 647         preferences_widget_sync_string (key, widget);
 648
 649         g_object_set_data_full (G_OBJECT (widget), "key",
 650                                 g_strdup (key), g_free);
 651
 652         g_signal_connect (widget,
 653                           "changed",
 654                           G_CALLBACK (preferences_entry_value_changed_cb),
 655                           NULL);
 656
 657         id = gossip_conf_notify_add (gossip_conf_get (),
 658                                       key,
 659                                       preferences_notify_string_cb,
 660                                       widget);
 661         if (id) {
 662                 preferences_add_id (preferences, id);
 663         }
 664 }
 665
 666 static void
 667 preferences_hookup_toggle_button (GossipPreferences *preferences,
 668                                   const gchar       *key,
 669                                   GtkWidget         *widget)
 670 {
 671         guint id;
 672
 673         preferences_widget_sync_bool (key, widget);
 674
 675         g_object_set_data_full (G_OBJECT (widget), "key",
 676                                 g_strdup (key), g_free);
 677
 678         g_signal_connect (widget,
 679                           "toggled",
 680                           G_CALLBACK (preferences_toggle_button_toggled_cb),
 681                           NULL);
 682
 683         id = gossip_conf_notify_add (gossip_conf_get (),
 684                                       key,
 685                                       preferences_notify_bool_cb,
 686                                       widget);
 687         if (id) {
 688                 preferences_add_id (preferences, id);
 689         }
 690 }
 691
 692 static void
 693 preferences_hookup_string_combo (GossipPreferences *preferences,
 694                                  const gchar       *key,
 695                                  GtkWidget         *widget)
 696 {
 697         guint id;
 698
 699         preferences_widget_sync_string_combo (key, widget);
 700
 701         g_object_set_data_full (G_OBJECT (widget), "key",
 702                                 g_strdup (key), g_free);
 703
 704         g_signal_connect (widget,
 705                           "changed",
 706                           G_CALLBACK (preferences_string_combo_changed_cb),
 707                           NULL);
 708
 709         id = gossip_conf_notify_add (gossip_conf_get (),
 710                                       key,
 711                                       preferences_notify_string_combo_cb,
 712                                       widget);
 713         if (id) {
 714                 preferences_add_id (preferences, id);
 715         }
 716 }
 717
 718 static void
 719 preferences_hookup_sensitivity (GossipPreferences *preferences,
 720                                 const gchar       *key,
 721                                 GtkWidget         *widget)
 722 {
 723         gboolean value;
 724         guint    id;
 725
 726         if (gossip_conf_get_bool (gossip_conf_get (), key, &value)) {
 727                 gtk_widget_set_sensitive (widget, value);
 728         }
 729
 730         id = gossip_conf_notify_add (gossip_conf_get (),
 731                                       key,
 732                                       preferences_notify_sensitivity_cb,
 733                                       widget);
 734         if (id) {
 735                 preferences_add_id (preferences, id);
 736         }
 737 }
 738
 739 static void
 740 preferences_spin_button_value_changed_cb (GtkWidget *button,
 741                                           gpointer   user_data)
 742 {
 743         const gchar *key;
 744
 745         key = g_object_get_data (G_OBJECT (button), "key");
 746
 747         gossip_conf_set_int (gossip_conf_get (),
 748                               key,
 749                               gtk_spin_button_get_value (GTK_SPIN_BUTTON (button)));
 750 }
 751
 752 static void
 753 preferences_entry_value_changed_cb (GtkWidget *entry,
 754                                     gpointer   user_data)
 755 {
 756         const gchar *key;
 757
 758         key = g_object_get_data (G_OBJECT (entry), "key");
 759
 760         gossip_conf_set_string (gossip_conf_get (),
 761                                  key,
 762                                  gtk_entry_get_text (GTK_ENTRY (entry)));
 763 }
 764
 765 static void
 766 preferences_toggle_button_toggled_cb (GtkWidget *button,
 767                                       gpointer   user_data)
 768 {
 769         const gchar *key;
 770
 771         key = g_object_get_data (G_OBJECT (button), "key");
 772
 773         gossip_conf_set_bool (gossip_conf_get (),
 774                                key,
 775                                gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
 776 }
 777
 778 static void
 779 preferences_string_combo_changed_cb (GtkWidget *combo,
 780                                      gpointer   user_data)
 781 {
 782         const gchar  *key;
 783         GtkTreeModel *model;
 784         GtkTreeIter   iter;
 785         gchar        *name;
 786
 787         key = g_object_get_data (G_OBJECT (combo), "key");
 788
 789         if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter)) {
 790                 model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
 791
 792                 gtk_tree_model_get (model, &iter,
 793                                     COL_COMBO_NAME, &name,
 794                                     -1);
 795                 gossip_conf_set_string (gossip_conf_get (), key, name);
 796                 g_free (name);
 797         }
 798 }
 799
 800 static void
 801 preferences_response_cb (GtkWidget         *widget,
 802                          gint               response,
 803                          GossipPreferences *preferences)
 804 {
 805         gtk_widget_destroy (widget);
 806 }
 807
 808 static void
 809 preferences_destroy_cb (GtkWidget         *widget,
 810                         GossipPreferences *preferences)
 811 {
 812         GList *l;
 813
 814         for (l = preferences->notify_ids; l; l = l->next) {
 815                 guint id;
 816
 817                 id = GPOINTER_TO_UINT (l->data);
 818                 gossip_conf_notify_remove (gossip_conf_get (), id);
 819         }
 820
 821         g_list_free (preferences->notify_ids);
 822         g_free (preferences);
 823 }
 824
 825 GtkWidget *
 826 gossip_preferences_show (void)
 827 {
 828         static GossipPreferences *preferences;
 829         GladeXML                 *glade;
 830
 831         if (preferences) {
 832                 gtk_window_present (GTK_WINDOW (preferences->dialog));
 833                 return preferences->dialog;
 834         }
 835
 836         preferences = g_new0 (GossipPreferences, 1);
 837
 838         glade = gossip_glade_get_file (
 839                 "gossip-preferences.glade",
 840                 "preferences_dialog",
 841                 NULL,
 842                 "preferences_dialog", &preferences->dialog,
 843                 "notebook", &preferences->notebook,
 844                 "checkbutton_show_avatars", &preferences->checkbutton_show_avatars,
 845                 "checkbutton_compact_contact_list", &preferences->checkbutton_compact_contact_list,
 846                 "checkbutton_show_smileys", &preferences->checkbutton_show_smileys,
 847                 "combobox_chat_theme", &preferences->combobox_chat_theme,
 848                 "checkbutton_theme_chat_room", &preferences->checkbutton_theme_chat_room,
 849                 "checkbutton_separate_chat_windows", &preferences->checkbutton_separate_chat_windows,
 850                 "checkbutton_sounds_for_messages", &preferences->checkbutton_sounds_for_messages,
 851                 "checkbutton_sounds_when_busy", &preferences->checkbutton_sounds_when_busy,
 852                 "checkbutton_sounds_when_away", &preferences->checkbutton_sounds_when_away,
 853                 "checkbutton_popups_when_available", &preferences->checkbutton_popups_when_available,
 854                 "treeview_spell_checker", &preferences->treeview_spell_checker,
 855                 "checkbutton_spell_checker", &preferences->checkbutton_spell_checker,
 856                 NULL);
 857
 858         gossip_glade_connect (glade,
 859                               preferences,
 860                               "preferences_dialog", "destroy", preferences_destroy_cb,
 861                               "preferences_dialog", "response", preferences_response_cb,
 862                               NULL);
 863
 864         g_object_unref (glade);
 865
 866         g_object_add_weak_pointer (G_OBJECT (preferences->dialog), (gpointer) &preferences);
 867
 868         preferences_themes_setup (preferences);
 869
 870         preferences_setup_widgets (preferences);
 871
 872         preferences_languages_setup (preferences);
 873         preferences_languages_add (preferences);
 874         preferences_languages_load (preferences);
 875
 876         if (gossip_spell_supported ()) {
 877                 GtkWidget *page;
 878
 879                 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (preferences->notebook), 2);
 880                 gtk_widget_show (page);
 881         }
 882
 883         gtk_widget_show (preferences->dialog);
 884
 885         return preferences->dialog;
 886 }
 887