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