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