libempathy-gtk/empathy-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 "empathy-conf.h"
  34 #include "empathy-preferences.h"
  35 #include "empathy-ui-utils.h"
  36 #include "empathy-theme-manager.h"
  37 #include "empathy-spell.h"
  38 #include "empathy-contact-list-store.h"
  39 #include "empathy-gtk-enum-types.h"
  40
  41 typedef struct {
  42         GtkWidget *dialog;
  43
  44         GtkWidget *notebook;
  45
  46         GtkWidget *checkbutton_show_avatars;
  47         GtkWidget *checkbutton_compact_contact_list;
  48         GtkWidget *checkbutton_show_smileys;
  49         GtkWidget *combobox_chat_theme;
  50         GtkWidget *checkbutton_theme_chat_room;
  51         GtkWidget *checkbutton_separate_chat_windows;
  52         GtkWidget *checkbutton_autoconnect;
  53         GtkWidget *radiobutton_contact_list_sort_by_name;
  54         GtkWidget *radiobutton_contact_list_sort_by_state;
  55
  56         GtkWidget *checkbutton_sounds_for_messages;
  57         GtkWidget *checkbutton_sounds_when_busy;
  58         GtkWidget *checkbutton_sounds_when_away;
  59         GtkWidget *checkbutton_popups_when_available;
  60
  61         GtkWidget *treeview_spell_checker;
  62
  63         GList     *notify_ids;
  64 } EmpathyPreferences;
  65
  66 static void     preferences_setup_widgets                (EmpathyPreferences      *preferences);
  67 static void     preferences_languages_setup              (EmpathyPreferences      *preferences);
  68 static void     preferences_languages_add                (EmpathyPreferences      *preferences);
  69 static void     preferences_languages_save               (EmpathyPreferences      *preferences);
  70 static gboolean preferences_languages_save_foreach       (GtkTreeModel           *model,
  71                                                           GtkTreePath            *path,
  72                                                           GtkTreeIter            *iter,
  73                                                           gchar                 **languages);
  74 static void     preferences_languages_load               (EmpathyPreferences      *preferences);
  75 static gboolean preferences_languages_load_foreach       (GtkTreeModel           *model,
  76                                                           GtkTreePath            *path,
  77                                                           GtkTreeIter            *iter,
  78                                                           gchar                 **languages);
  79 static void     preferences_languages_cell_toggled_cb    (GtkCellRendererToggle  *cell,
  80                                                           gchar                  *path_string,
  81                                                           EmpathyPreferences      *preferences);
  82 static void     preferences_themes_setup                 (EmpathyPreferences      *preferences);
  83 static void     preferences_widget_sync_bool             (const gchar            *key,
  84                                                           GtkWidget              *widget);
  85 static void     preferences_widget_sync_int              (const gchar            *key,
  86                                                           GtkWidget              *widget);
  87 static void     preferences_widget_sync_string           (const gchar            *key,
  88                                                           GtkWidget              *widget);
  89 static void     preferences_widget_sync_string_combo     (const gchar            *key,
  90                                                           GtkWidget              *widget);
  91 static void     preferences_notify_int_cb                (EmpathyConf             *conf,
  92                                                           const gchar            *key,
  93                                                           gpointer                user_data);
  94 static void     preferences_notify_string_cb             (EmpathyConf             *conf,
  95                                                           const gchar            *key,
  96                                                           gpointer                user_data);
  97 static void     preferences_notify_string_combo_cb       (EmpathyConf             *conf,
  98                                                           const gchar            *key,
  99                                                           gpointer                user_data);
 100 static void     preferences_notify_bool_cb               (EmpathyConf             *conf,
 101                                                           const gchar            *key,
 102                                                           gpointer                user_data);
 103 static void     preferences_notify_sensitivity_cb        (EmpathyConf             *conf,
 104                                                           const gchar            *key,
 105                                                           gpointer                user_data);
 106 static void     preferences_hookup_spin_button           (EmpathyPreferences      *preferences,
 107                                                           const gchar            *key,
 108                                                           GtkWidget              *widget);
 109 static void     preferences_hookup_entry                 (EmpathyPreferences      *preferences,
 110                                                           const gchar            *key,
 111                                                           GtkWidget              *widget);
 112 static void     preferences_hookup_toggle_button         (EmpathyPreferences      *preferences,
 113                                                           const gchar            *key,
 114                                                           GtkWidget              *widget);
 115 static void     preferences_hookup_radio_button          (EmpathyPreferences      *preferences,
 116                                                           const gchar            *key,
 117                                                           GtkWidget              *widget);
 118 static void     preferences_hookup_string_combo          (EmpathyPreferences      *preferences,
 119                                                           const gchar            *key,
 120                                                           GtkWidget              *widget);
 121 static void     preferences_hookup_sensitivity           (EmpathyPreferences      *preferences,
 122                                                           const gchar            *key,
 123                                                           GtkWidget              *widget);
 124 static void     preferences_spin_button_value_changed_cb (GtkWidget              *button,
 125                                                           gpointer                user_data);
 126 static void     preferences_entry_value_changed_cb       (GtkWidget              *entry,
 127                                                           gpointer                user_data);
 128 static void     preferences_toggle_button_toggled_cb     (GtkWidget              *button,
 129                                                           gpointer                user_data);
 130 static void     preferences_radio_button_toggled_cb      (GtkWidget              *button,
 131                                                           gpointer                user_data);
 132 static void     preferences_string_combo_changed_cb      (GtkWidget *button,
 133                                                           gpointer                user_data);
 134 static void     preferences_destroy_cb                   (GtkWidget              *widget,
 135                                                           EmpathyPreferences      *preferences);
 136 static void     preferences_response_cb                  (GtkWidget              *widget,
 137                                                           gint                    response,
 138                                                           EmpathyPreferences      *preferences);
 139
 140 enum {
 141         COL_LANG_ENABLED,
 142         COL_LANG_CODE,
 143         COL_LANG_NAME,
 144         COL_LANG_COUNT
 145 };
 146
 147 enum {
 148         COL_COMBO_VISIBLE_NAME,
 149         COL_COMBO_NAME,
 150         COL_COMBO_COUNT
 151 };
 152
 153 static void
 154 preferences_setup_widgets (EmpathyPreferences *preferences)
 155 {
 156         preferences_hookup_toggle_button (preferences,
 157                                           EMPATHY_PREFS_SOUNDS_FOR_MESSAGES,
 158                                           preferences->checkbutton_sounds_for_messages);
 159         preferences_hookup_toggle_button (preferences,
 160                                           EMPATHY_PREFS_SOUNDS_WHEN_AWAY,
 161                                           preferences->checkbutton_sounds_when_away);
 162         preferences_hookup_toggle_button (preferences,
 163                                           EMPATHY_PREFS_SOUNDS_WHEN_BUSY,
 164                                           preferences->checkbutton_sounds_when_busy);
 165         preferences_hookup_toggle_button (preferences,
 166                                           EMPATHY_PREFS_POPUPS_WHEN_AVAILABLE,
 167                                           preferences->checkbutton_popups_when_available);
 168
 169         preferences_hookup_sensitivity (preferences,
 170                                         EMPATHY_PREFS_SOUNDS_FOR_MESSAGES,
 171                                         preferences->checkbutton_sounds_when_away);
 172         preferences_hookup_sensitivity (preferences,
 173                                         EMPATHY_PREFS_SOUNDS_FOR_MESSAGES,
 174                                         preferences->checkbutton_sounds_when_busy);
 175
 176         preferences_hookup_toggle_button (preferences,
 177                                           EMPATHY_PREFS_UI_SEPARATE_CHAT_WINDOWS,
 178                                           preferences->checkbutton_separate_chat_windows);
 179
 180         preferences_hookup_toggle_button (preferences,
 181                                           EMPATHY_PREFS_UI_SHOW_AVATARS,
 182                                           preferences->checkbutton_show_avatars);
 183
 184         preferences_hookup_toggle_button (preferences,
 185                                           EMPATHY_PREFS_UI_COMPACT_CONTACT_LIST,
 186                                           preferences->checkbutton_compact_contact_list);
 187
 188         preferences_hookup_toggle_button (preferences,
 189                                           EMPATHY_PREFS_CHAT_SHOW_SMILEYS,
 190                                           preferences->checkbutton_show_smileys);
 191
 192         preferences_hookup_string_combo (preferences,
 193                                          EMPATHY_PREFS_CHAT_THEME,
 194                                          preferences->combobox_chat_theme);
 195
 196         preferences_hookup_toggle_button (preferences,
 197                                           EMPATHY_PREFS_CHAT_THEME_CHAT_ROOM,
 198                                           preferences->checkbutton_theme_chat_room);
 199
 200         preferences_hookup_radio_button (preferences,
 201                                          EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,
 202                                          preferences->radiobutton_contact_list_sort_by_name);
 203
 204         preferences_hookup_toggle_button (preferences,
 205                                           EMPATHY_PREFS_AUTOCONNECT,
 206                                           preferences->checkbutton_autoconnect);
 207 }
 208
 209 static void
 210 preferences_languages_setup (EmpathyPreferences *preferences)
 211 {
 212         GtkTreeView       *view;
 213         GtkListStore      *store;
 214         GtkTreeSelection  *selection;
 215         GtkTreeModel      *model;
 216         GtkTreeViewColumn *column;
 217         GtkCellRenderer   *renderer;
 218         guint              col_offset;
 219
 220         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 221
 222         store = gtk_list_store_new (COL_LANG_COUNT,
 223                                     G_TYPE_BOOLEAN,  /* enabled */
 224                                     G_TYPE_STRING,   /* code */
 225                                     G_TYPE_STRING);  /* name */
 226
 227         gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
 228
 229         selection = gtk_tree_view_get_selection (view);
 230         gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
 231
 232         model = GTK_TREE_MODEL (store);
 233
 234         renderer = gtk_cell_renderer_toggle_new ();
 235         g_signal_connect (renderer, "toggled",
 236                           G_CALLBACK (preferences_languages_cell_toggled_cb),
 237                           preferences);
 238
 239         column = gtk_tree_view_column_new_with_attributes (NULL, renderer,
 240                                                            "active", COL_LANG_ENABLED,
 241                                                            NULL);
 242
 243         gtk_tree_view_append_column (view, column);
 244
 245         renderer = gtk_cell_renderer_text_new ();
 246         col_offset = gtk_tree_view_insert_column_with_attributes (view,
 247                                                                   -1, _("Language"),
 248                                                                   renderer,
 249                                                                   "text", COL_LANG_NAME,
 250                                                                   NULL);
 251
 252         g_object_set_data (G_OBJECT (renderer),
 253                            "column", GINT_TO_POINTER (COL_LANG_NAME));
 254
 255         column = gtk_tree_view_get_column (view, col_offset - 1);
 256         gtk_tree_view_column_set_sort_column_id (column, COL_LANG_NAME);
 257         gtk_tree_view_column_set_resizable (column, FALSE);
 258         gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 259
 260         g_object_unref (store);
 261 }
 262
 263 static void
 264 preferences_languages_add (EmpathyPreferences *preferences)
 265 {
 266         GtkTreeView  *view;
 267         GtkListStore *store;
 268         GList        *codes, *l;
 269
 270         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 271         store = GTK_LIST_STORE (gtk_tree_view_get_model (view));
 272
 273         codes = empathy_spell_get_language_codes ();
 274
 275         empathy_conf_set_bool (empathy_conf_get(),
 276                                EMPATHY_PREFS_CHAT_SPELL_CHECKER_ENABLED,
 277                                codes != NULL);
 278         if (!codes) {
 279                 gtk_widget_set_sensitive (preferences->treeview_spell_checker, FALSE);
 280         }
 281
 282         for (l = codes; l; l = l->next) {
 283                 GtkTreeIter  iter;
 284                 const gchar *code;
 285                 const gchar *name;
 286
 287                 code = l->data;
 288                 name = empathy_spell_get_language_name (code);
 289                 if (!name) {
 290                         continue;
 291                 }
 292
 293                 gtk_list_store_append (store, &iter);
 294                 gtk_list_store_set (store, &iter,
 295                                     COL_LANG_CODE, code,
 296                                     COL_LANG_NAME, name,
 297                                     -1);
 298         }
 299
 300         empathy_spell_free_language_codes (codes);
 301 }
 302
 303 static void
 304 preferences_languages_save (EmpathyPreferences *preferences)
 305 {
 306         GtkTreeView       *view;
 307         GtkTreeModel      *model;
 308
 309         gchar             *languages = NULL;
 310
 311         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 312         model = gtk_tree_view_get_model (view);
 313
 314         gtk_tree_model_foreach (model,
 315                                 (GtkTreeModelForeachFunc) preferences_languages_save_foreach,
 316                                 &languages);
 317
 318         /* if user selects no languages, we don't want spell check */
 319         empathy_conf_set_bool (empathy_conf_get (),
 320                                EMPATHY_PREFS_CHAT_SPELL_CHECKER_ENABLED,
 321                                languages != NULL);
 322
 323         empathy_conf_set_string (empathy_conf_get (),
 324                                  EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
 325                                  languages ? languages : "");
 326
 327         g_free (languages);
 328 }
 329
 330 static gboolean
 331 preferences_languages_save_foreach (GtkTreeModel  *model,
 332                                     GtkTreePath   *path,
 333                                     GtkTreeIter   *iter,
 334                                     gchar        **languages)
 335 {
 336         gboolean  enabled;
 337         gchar    *code;
 338
 339         if (!languages) {
 340                 return TRUE;
 341         }
 342
 343         gtk_tree_model_get (model, iter, COL_LANG_ENABLED, &enabled, -1);
 344         if (!enabled) {
 345                 return FALSE;
 346         }
 347
 348         gtk_tree_model_get (model, iter, COL_LANG_CODE, &code, -1);
 349         if (!code) {
 350                 return FALSE;
 351         }
 352
 353         if (!(*languages)) {
 354                 *languages = g_strdup (code);
 355         } else {
 356                 gchar *str = *languages;
 357                 *languages = g_strdup_printf ("%s,%s", str, code);
 358                 g_free (str);
 359         }
 360
 361         g_free (code);
 362
 363         return FALSE;
 364 }
 365
 366 static void
 367 preferences_languages_load (EmpathyPreferences *preferences)
 368 {
 369         GtkTreeView   *view;
 370         GtkTreeModel  *model;
 371         gchar         *value;
 372         gchar        **vlanguages;
 373
 374         if (!empathy_conf_get_string (empathy_conf_get (),
 375                                       EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
 376                                       &value) || !value) {
 377                 return;
 378         }
 379
 380         vlanguages = g_strsplit (value, ",", -1);
 381         g_free (value);
 382
 383         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 384         model = gtk_tree_view_get_model (view);
 385
 386         gtk_tree_model_foreach (model,
 387                                 (GtkTreeModelForeachFunc) preferences_languages_load_foreach,
 388                                 vlanguages);
 389
 390         g_strfreev (vlanguages);
 391 }
 392
 393 static gboolean
 394 preferences_languages_load_foreach (GtkTreeModel  *model,
 395                                     GtkTreePath   *path,
 396                                     GtkTreeIter   *iter,
 397                                     gchar        **languages)
 398 {
 399         gchar    *code;
 400         gchar    *lang;
 401         gint      i;
 402         gboolean  found = FALSE;
 403
 404         if (!languages) {
 405                 return TRUE;
 406         }
 407
 408         gtk_tree_model_get (model, iter, COL_LANG_CODE, &code, -1);
 409         if (!code) {
 410                 return FALSE;
 411         }
 412
 413         for (i = 0, lang = languages[i]; lang; lang = languages[++i]) {
 414                 if (strcmp (lang, code) == 0) {
 415                         found = TRUE;
 416                 }
 417         }
 418
 419         gtk_list_store_set (GTK_LIST_STORE (model), iter, COL_LANG_ENABLED, found, -1);
 420         return FALSE;
 421 }
 422
 423 static void
 424 preferences_languages_cell_toggled_cb (GtkCellRendererToggle *cell,
 425                                        gchar                 *path_string,
 426                                        EmpathyPreferences     *preferences)
 427 {
 428         GtkTreeView  *view;
 429         GtkTreeModel *model;
 430         GtkListStore *store;
 431         GtkTreePath  *path;
 432         GtkTreeIter   iter;
 433         gboolean      enabled;
 434
 435         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 436         model = gtk_tree_view_get_model (view);
 437         store = GTK_LIST_STORE (model);
 438
 439         path = gtk_tree_path_new_from_string (path_string);
 440
 441         gtk_tree_model_get_iter (model, &iter, path);
 442         gtk_tree_model_get (model, &iter, COL_LANG_ENABLED, &enabled, -1);
 443
 444         enabled ^= 1;
 445
 446         gtk_list_store_set (store, &iter, COL_LANG_ENABLED, enabled, -1);
 447         gtk_tree_path_free (path);
 448
 449         preferences_languages_save (preferences);
 450 }
 451
 452 static void
 453 preferences_themes_setup (EmpathyPreferences *preferences)
 454 {
 455         GtkComboBox   *combo;
 456         GtkListStore  *model;
 457         GtkTreeIter    iter;
 458         const gchar  **themes;
 459         gint           i;
 460
 461         combo = GTK_COMBO_BOX (preferences->combobox_chat_theme);
 462
 463         model = gtk_list_store_new (COL_COMBO_COUNT,
 464                                     G_TYPE_STRING,
 465                                     G_TYPE_STRING);
 466
 467         themes = empathy_theme_manager_get_themes ();
 468         for (i = 0; themes[i]; i += 2) {
 469                 gtk_list_store_append (model, &iter);
 470                 gtk_list_store_set (model, &iter,
 471                                     COL_COMBO_VISIBLE_NAME, _(themes[i + 1]),
 472                                     COL_COMBO_NAME, themes[i],
 473                                     -1);
 474         }
 475
 476         gtk_combo_box_set_model (combo, GTK_TREE_MODEL (model));
 477         g_object_unref (model);
 478 }
 479
 480 static void
 481 preferences_widget_sync_bool (const gchar *key, GtkWidget *widget)
 482 {
 483         gboolean value;
 484
 485         if (empathy_conf_get_bool (empathy_conf_get (), key, &value)) {
 486                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value);
 487         }
 488 }
 489
 490 static void
 491 preferences_widget_sync_int (const gchar *key, GtkWidget *widget)
 492 {
 493         gint value;
 494
 495         if (empathy_conf_get_int (empathy_conf_get (), key, &value)) {
 496                 if (GTK_IS_SPIN_BUTTON (widget)) {
 497                         gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
 498                 }
 499         }
 500 }
 501
 502 static void
 503 preferences_widget_sync_string (const gchar *key, GtkWidget *widget)
 504 {
 505         gchar *value;
 506
 507         if (empathy_conf_get_string (empathy_conf_get (), key, &value) && value) {
 508                 if (GTK_IS_ENTRY (widget)) {
 509                         gtk_entry_set_text (GTK_ENTRY (widget), value);
 510                 } else if (GTK_IS_RADIO_BUTTON (widget)) {
 511                         if (strcmp (key, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM) == 0) {
 512                                 GType        type;
 513                                 GEnumClass  *enum_class;
 514                                 GEnumValue  *enum_value;
 515                                 GSList      *list;
 516                                 GtkWidget   *toggle_widget;
 517
 518                                 /* Get index from new string */
 519                                 type = empathy_contact_list_store_sort_get_type ();
 520                                 enum_class = G_ENUM_CLASS (g_type_class_peek (type));
 521                                 enum_value = g_enum_get_value_by_nick (enum_class, value);
 522
 523                                 if (enum_value) {
 524                                         list = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
 525                                         toggle_widget = g_slist_nth_data (list, enum_value->value);
 526                                         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_widget), TRUE);
 527                                 }
 528                         } else {
 529                                 g_warning ("Unhandled key:'%s' just had string change", key);
 530                         }
 531                 }
 532
 533                 g_free (value);
 534         }
 535 }
 536
 537 static void
 538 preferences_widget_sync_string_combo (const gchar *key, GtkWidget *widget)
 539 {
 540         gchar        *value;
 541         GtkTreeModel *model;
 542         GtkTreeIter   iter;
 543         gboolean      found;
 544
 545         if (!empathy_conf_get_string (empathy_conf_get (), key, &value)) {
 546                 return;
 547         }
 548
 549         model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget));
 550
 551         found = FALSE;
 552         if (value && gtk_tree_model_get_iter_first (model, &iter)) {
 553                 gchar *name;
 554
 555                 do {
 556                         gtk_tree_model_get (model, &iter,
 557                                             COL_COMBO_NAME, &name,
 558                                             -1);
 559
 560                         if (strcmp (name, value) == 0) {
 561                                 found = TRUE;
 562                                 gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
 563                                 break;
 564                         } else {
 565                                 found = FALSE;
 566                         }
 567
 568                         g_free (name);
 569                 } while (gtk_tree_model_iter_next (model, &iter));
 570         }
 571
 572         /* Fallback to the first one. */
 573         if (!found) {
 574                 if (gtk_tree_model_get_iter_first (model, &iter)) {
 575                         gtk_combo_box_set_active_iter (GTK_COMBO_BOX (widget), &iter);
 576                 }
 577         }
 578
 579         g_free (value);
 580 }
 581
 582 static void
 583 preferences_notify_int_cb (EmpathyConf  *conf,
 584                            const gchar *key,
 585                            gpointer     user_data)
 586 {
 587         preferences_widget_sync_int (key, user_data);
 588 }
 589
 590 static void
 591 preferences_notify_string_cb (EmpathyConf  *conf,
 592                               const gchar *key,
 593                               gpointer     user_data)
 594 {
 595         preferences_widget_sync_string (key, user_data);
 596 }
 597
 598 static void
 599 preferences_notify_string_combo_cb (EmpathyConf  *conf,
 600                                     const gchar *key,
 601                                     gpointer     user_data)
 602 {
 603         preferences_widget_sync_string_combo (key, user_data);
 604 }
 605
 606 static void
 607 preferences_notify_bool_cb (EmpathyConf  *conf,
 608                             const gchar *key,
 609                             gpointer     user_data)
 610 {
 611         preferences_widget_sync_bool (key, user_data);
 612 }
 613
 614 static void
 615 preferences_notify_sensitivity_cb (EmpathyConf  *conf,
 616                                    const gchar *key,
 617                                    gpointer     user_data)
 618 {
 619         gboolean value;
 620
 621         if (empathy_conf_get_bool (conf, key, &value)) {
 622                 gtk_widget_set_sensitive (GTK_WIDGET (user_data), value);
 623         }
 624 }
 625
 626 static void
 627 preferences_add_id (EmpathyPreferences *preferences, guint id)
 628 {
 629         preferences->notify_ids = g_list_prepend (preferences->notify_ids,
 630                                                   GUINT_TO_POINTER (id));
 631 }
 632
 633 static void
 634 preferences_hookup_spin_button (EmpathyPreferences *preferences,
 635                                 const gchar       *key,
 636                                 GtkWidget         *widget)
 637 {
 638         guint id;
 639
 640         /* Silence warning. */
 641         if (0) {
 642                 preferences_hookup_spin_button (preferences, key, widget);
 643         }
 644
 645         preferences_widget_sync_int (key, widget);
 646
 647         g_object_set_data_full (G_OBJECT (widget), "key",
 648                                 g_strdup (key), g_free);
 649
 650         g_signal_connect (widget,
 651                           "value_changed",
 652                           G_CALLBACK (preferences_spin_button_value_changed_cb),
 653                           NULL);
 654
 655         id = empathy_conf_notify_add (empathy_conf_get (),
 656                                       key,
 657                                       preferences_notify_int_cb,
 658                                       widget);
 659         if (id) {
 660                 preferences_add_id (preferences, id);
 661         }
 662 }
 663
 664 static void
 665 preferences_hookup_entry (EmpathyPreferences *preferences,
 666                           const gchar       *key,
 667                           GtkWidget         *widget)
 668 {
 669         guint id;
 670
 671         if (0) {  /* Silent warning before we use this function. */
 672                 preferences_hookup_entry (preferences, key, widget);
 673         }
 674
 675         preferences_widget_sync_string (key, widget);
 676
 677         g_object_set_data_full (G_OBJECT (widget), "key",
 678                                 g_strdup (key), g_free);
 679
 680         g_signal_connect (widget,
 681                           "changed",
 682                           G_CALLBACK (preferences_entry_value_changed_cb),
 683                           NULL);
 684
 685         id = empathy_conf_notify_add (empathy_conf_get (),
 686                                       key,
 687                                       preferences_notify_string_cb,
 688                                       widget);
 689         if (id) {
 690                 preferences_add_id (preferences, id);
 691         }
 692 }
 693
 694 static void
 695 preferences_hookup_toggle_button (EmpathyPreferences *preferences,
 696                                   const gchar       *key,
 697                                   GtkWidget         *widget)
 698 {
 699         guint id;
 700
 701         preferences_widget_sync_bool (key, widget);
 702
 703         g_object_set_data_full (G_OBJECT (widget), "key",
 704                                 g_strdup (key), g_free);
 705
 706         g_signal_connect (widget,
 707                           "toggled",
 708                           G_CALLBACK (preferences_toggle_button_toggled_cb),
 709                           NULL);
 710
 711         id = empathy_conf_notify_add (empathy_conf_get (),
 712                                      key,
 713                                      preferences_notify_bool_cb,
 714                                      widget);
 715         if (id) {
 716                 preferences_add_id (preferences, id);
 717         }
 718 }
 719
 720 static void
 721 preferences_hookup_radio_button (EmpathyPreferences *preferences,
 722                                  const gchar       *key,
 723                                  GtkWidget         *widget)
 724 {
 725         GSList *group, *l;
 726         guint   id;
 727
 728         preferences_widget_sync_string (key, widget);
 729
 730         group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
 731         for (l = group; l; l = l->next) {
 732                 g_signal_connect (l->data,
 733                                   "toggled",
 734                                   G_CALLBACK (preferences_radio_button_toggled_cb),
 735                                   NULL);
 736
 737                 g_object_set_data_full (G_OBJECT (l->data), "key",
 738                                         g_strdup (key), g_free);
 739         }
 740
 741         id = empathy_conf_notify_add (empathy_conf_get (),
 742                                      key,
 743                                      preferences_notify_string_cb,
 744                                      widget);
 745         if (id) {
 746                 preferences_add_id (preferences, id);
 747         }
 748 }
 749
 750 static void
 751 preferences_hookup_string_combo (EmpathyPreferences *preferences,
 752                                  const gchar       *key,
 753                                  GtkWidget         *widget)
 754 {
 755         guint id;
 756
 757         preferences_widget_sync_string_combo (key, widget);
 758
 759         g_object_set_data_full (G_OBJECT (widget), "key",
 760                                 g_strdup (key), g_free);
 761
 762         g_signal_connect (widget,
 763                           "changed",
 764                           G_CALLBACK (preferences_string_combo_changed_cb),
 765                           NULL);
 766
 767         id = empathy_conf_notify_add (empathy_conf_get (),
 768                                       key,
 769                                       preferences_notify_string_combo_cb,
 770                                       widget);
 771         if (id) {
 772                 preferences_add_id (preferences, id);
 773         }
 774 }
 775
 776 static void
 777 preferences_hookup_sensitivity (EmpathyPreferences *preferences,
 778                                 const gchar       *key,
 779                                 GtkWidget         *widget)
 780 {
 781         gboolean value;
 782         guint    id;
 783
 784         if (empathy_conf_get_bool (empathy_conf_get (), key, &value)) {
 785                 gtk_widget_set_sensitive (widget, value);
 786         }
 787
 788         id = empathy_conf_notify_add (empathy_conf_get (),
 789                                       key,
 790                                       preferences_notify_sensitivity_cb,
 791                                       widget);
 792         if (id) {
 793                 preferences_add_id (preferences, id);
 794         }
 795 }
 796
 797 static void
 798 preferences_spin_button_value_changed_cb (GtkWidget *button,
 799                                           gpointer   user_data)
 800 {
 801         const gchar *key;
 802
 803         key = g_object_get_data (G_OBJECT (button), "key");
 804
 805         empathy_conf_set_int (empathy_conf_get (),
 806                               key,
 807                               gtk_spin_button_get_value (GTK_SPIN_BUTTON (button)));
 808 }
 809
 810 static void
 811 preferences_entry_value_changed_cb (GtkWidget *entry,
 812                                     gpointer   user_data)
 813 {
 814         const gchar *key;
 815
 816         key = g_object_get_data (G_OBJECT (entry), "key");
 817
 818         empathy_conf_set_string (empathy_conf_get (),
 819                                  key,
 820                                  gtk_entry_get_text (GTK_ENTRY (entry)));
 821 }
 822
 823 static void
 824 preferences_toggle_button_toggled_cb (GtkWidget *button,
 825                                       gpointer   user_data)
 826 {
 827         const gchar *key;
 828
 829         key = g_object_get_data (G_OBJECT (button), "key");
 830
 831         empathy_conf_set_bool (empathy_conf_get (),
 832                                key,
 833                                gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
 834 }
 835
 836 static void
 837 preferences_radio_button_toggled_cb (GtkWidget *button,
 838                                      gpointer   user_data)
 839 {
 840         const gchar *key;
 841         const gchar *value = NULL;
 842
 843         if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) {
 844                 return;
 845         }
 846
 847         key = g_object_get_data (G_OBJECT (button), "key");
 848
 849         if (key && strcmp (key, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM) == 0) {
 850                 GSList      *group;
 851                 GType        type;
 852                 GEnumClass  *enum_class;
 853                 GEnumValue  *enum_value;
 854
 855                 group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
 856
 857                 /* Get string from index */
 858                 type = empathy_contact_list_store_sort_get_type ();
 859                 enum_class = G_ENUM_CLASS (g_type_class_peek (type));
 860                 enum_value = g_enum_get_value (enum_class, g_slist_index (group, button));
 861
 862                 if (!enum_value) {
 863                         g_warning ("No GEnumValue for EmpathyContactListSort with GtkRadioButton index:%d",
 864                                    g_slist_index (group, button));
 865                         return;
 866                 }
 867
 868                 value = enum_value->value_nick;
 869         }
 870
 871         empathy_conf_set_string (empathy_conf_get (), key, value);
 872 }
 873
 874 static void
 875 preferences_string_combo_changed_cb (GtkWidget *combo,
 876                                      gpointer   user_data)
 877 {
 878         const gchar  *key;
 879         GtkTreeModel *model;
 880         GtkTreeIter   iter;
 881         gchar        *name;
 882
 883         key = g_object_get_data (G_OBJECT (combo), "key");
 884
 885         if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter)) {
 886                 model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
 887
 888                 gtk_tree_model_get (model, &iter,
 889                                     COL_COMBO_NAME, &name,
 890                                     -1);
 891                 empathy_conf_set_string (empathy_conf_get (), key, name);
 892                 g_free (name);
 893         }
 894 }
 895
 896 static void
 897 preferences_response_cb (GtkWidget         *widget,
 898                          gint               response,
 899                          EmpathyPreferences *preferences)
 900 {
 901         gtk_widget_destroy (widget);
 902 }
 903
 904 static void
 905 preferences_destroy_cb (GtkWidget         *widget,
 906                         EmpathyPreferences *preferences)
 907 {
 908         GList *l;
 909
 910         for (l = preferences->notify_ids; l; l = l->next) {
 911                 guint id;
 912
 913                 id = GPOINTER_TO_UINT (l->data);
 914                 empathy_conf_notify_remove (empathy_conf_get (), id);
 915         }
 916
 917         g_list_free (preferences->notify_ids);
 918         g_free (preferences);
 919 }
 920
 921 GtkWidget *
 922 empathy_preferences_show (GtkWindow *parent)
 923 {
 924         static EmpathyPreferences *preferences;
 925         GladeXML                 *glade;
 926
 927         if (preferences) {
 928                 gtk_window_present (GTK_WINDOW (preferences->dialog));
 929                 return preferences->dialog;
 930         }
 931
 932         preferences = g_new0 (EmpathyPreferences, 1);
 933
 934         glade = empathy_glade_get_file (
 935                 "empathy-preferences.glade",
 936                 "preferences_dialog",
 937                 NULL,
 938                 "preferences_dialog", &preferences->dialog,
 939                 "notebook", &preferences->notebook,
 940                 "checkbutton_show_avatars", &preferences->checkbutton_show_avatars,
 941                 "checkbutton_compact_contact_list", &preferences->checkbutton_compact_contact_list,
 942                 "checkbutton_show_smileys", &preferences->checkbutton_show_smileys,
 943                 "combobox_chat_theme", &preferences->combobox_chat_theme,
 944                 "checkbutton_theme_chat_room", &preferences->checkbutton_theme_chat_room,
 945                 "checkbutton_separate_chat_windows", &preferences->checkbutton_separate_chat_windows,
 946                 "checkbutton_autoconnect", &preferences->checkbutton_autoconnect,
 947                 "radiobutton_contact_list_sort_by_name", &preferences->radiobutton_contact_list_sort_by_name,
 948                 "radiobutton_contact_list_sort_by_state", &preferences->radiobutton_contact_list_sort_by_state,
 949                 "checkbutton_sounds_for_messages", &preferences->checkbutton_sounds_for_messages,
 950                 "checkbutton_sounds_when_busy", &preferences->checkbutton_sounds_when_busy,
 951                 "checkbutton_sounds_when_away", &preferences->checkbutton_sounds_when_away,
 952                 "checkbutton_popups_when_available", &preferences->checkbutton_popups_when_available,
 953                 "treeview_spell_checker", &preferences->treeview_spell_checker,
 954                 NULL);
 955
 956         empathy_glade_connect (glade,
 957                               preferences,
 958                               "preferences_dialog", "destroy", preferences_destroy_cb,
 959                               "preferences_dialog", "response", preferences_response_cb,
 960                               NULL);
 961
 962         g_object_unref (glade);
 963
 964         g_object_add_weak_pointer (G_OBJECT (preferences->dialog), (gpointer) &preferences);
 965
 966         preferences_themes_setup (preferences);
 967
 968         preferences_setup_widgets (preferences);
 969
 970         preferences_languages_setup (preferences);
 971         preferences_languages_add (preferences);
 972         preferences_languages_load (preferences);
 973
 974         if (empathy_spell_supported ()) {
 975                 GtkWidget *page;
 976
 977                 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (preferences->notebook), 2);
 978                 gtk_widget_show (page);
 979         }
 980
 981         if (parent) {
 982                 gtk_window_set_transient_for (GTK_WINDOW (preferences->dialog),
 983                                               GTK_WINDOW (parent));
 984         }
 985
 986         gtk_widget_show (preferences->dialog);
 987
 988         return preferences->dialog;
 989 }
 990