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., 51 Franklin St, Fifth Floor,
  18  * Boston, MA  02110-1301  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 <glib/gi18n.h>
  31 #include <telepathy-glib/dbus.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 #ifdef HAVE_WEBKIT
  43 #include <libempathy-gtk/empathy-theme-adium.h>
  44 #endif
  45
  46 #include "empathy-preferences.h"
  47
  48 typedef struct {
  49         GtkWidget *dialog;
  50
  51         GtkWidget *notebook;
  52
  53         GtkWidget *checkbutton_show_smileys;
  54         GtkWidget *checkbutton_show_contacts_in_rooms;
  55         GtkWidget *combobox_chat_theme;
  56         GtkWidget *checkbutton_separate_chat_windows;
  57         GtkWidget *checkbutton_autoconnect;
  58
  59         GtkWidget *checkbutton_sounds_enabled;
  60         GtkWidget *checkbutton_sounds_disabled_away;
  61         GtkWidget *treeview_sounds;
  62
  63         GtkWidget *checkbutton_notifications_enabled;
  64         GtkWidget *checkbutton_notifications_disabled_away;
  65         GtkWidget *checkbutton_notifications_focus;
  66         GtkWidget *checkbutton_notifications_contact_signin;
  67         GtkWidget *checkbutton_notifications_contact_signout;
  68
  69         GtkWidget *treeview_spell_checker;
  70
  71         GtkWidget *checkbutton_location_publish;
  72         GtkWidget *checkbutton_location_reduce_accuracy;
  73         GtkWidget *checkbutton_location_resource_network;
  74         GtkWidget *checkbutton_location_resource_cell;
  75         GtkWidget *checkbutton_location_resource_gps;
  76
  77         GList     *notify_ids;
  78 } EmpathyPreferences;
  79
  80 static void     preferences_setup_widgets                (EmpathyPreferences      *preferences);
  81 static void     preferences_languages_setup              (EmpathyPreferences      *preferences);
  82 static void     preferences_languages_add                (EmpathyPreferences      *preferences);
  83 static void     preferences_languages_save               (EmpathyPreferences      *preferences);
  84 static gboolean preferences_languages_save_foreach       (GtkTreeModel           *model,
  85                                                           GtkTreePath            *path,
  86                                                           GtkTreeIter            *iter,
  87                                                           gchar                 **languages);
  88 static void     preferences_languages_load               (EmpathyPreferences      *preferences);
  89 static gboolean preferences_languages_load_foreach       (GtkTreeModel           *model,
  90                                                           GtkTreePath            *path,
  91                                                           GtkTreeIter            *iter,
  92                                                           gchar                 **languages);
  93 static void     preferences_languages_cell_toggled_cb    (GtkCellRendererToggle  *cell,
  94                                                           gchar                  *path_string,
  95                                                           EmpathyPreferences      *preferences);
  96 static void     preferences_widget_sync_bool             (const gchar            *key,
  97                                                           GtkWidget              *widget);
  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_sensitivity           (EmpathyPreferences      *preferences,
 108                                                           const gchar            *key,
 109                                                           GtkWidget              *widget);
 110 static void     preferences_toggle_button_toggled_cb     (GtkWidget              *button,
 111                                                           gpointer                user_data);
 112 static void     preferences_destroy_cb                   (GtkWidget              *widget,
 113                                                           EmpathyPreferences      *preferences);
 114 static void     preferences_response_cb                  (GtkWidget              *widget,
 115                                                           gint                    response,
 116                                                           EmpathyPreferences      *preferences);
 117
 118 enum {
 119         COL_LANG_ENABLED,
 120         COL_LANG_CODE,
 121         COL_LANG_NAME,
 122         COL_LANG_COUNT
 123 };
 124
 125 enum {
 126         COL_COMBO_IS_ADIUM,
 127         COL_COMBO_VISIBLE_NAME,
 128         COL_COMBO_NAME,
 129         COL_COMBO_PATH,
 130         COL_COMBO_COUNT
 131 };
 132
 133 enum {
 134         COL_SOUND_ENABLED,
 135         COL_SOUND_NAME,
 136         COL_SOUND_KEY,
 137         COL_SOUND_COUNT
 138 };
 139
 140 typedef struct {
 141         const char *name;
 142         const char *key;
 143 } SoundEventEntry;
 144
 145 /* TODO: add phone related sounds also? */
 146 static SoundEventEntry sound_entries [] = {
 147         { N_("Message received"), EMPATHY_PREFS_SOUNDS_INCOMING_MESSAGE },
 148         { N_("Message sent"), EMPATHY_PREFS_SOUNDS_OUTGOING_MESSAGE },
 149         { N_("New conversation"), EMPATHY_PREFS_SOUNDS_NEW_CONVERSATION },
 150         { N_("Contact goes online"), EMPATHY_PREFS_SOUNDS_CONTACT_LOGIN },
 151         { N_("Contact goes offline"), EMPATHY_PREFS_SOUNDS_CONTACT_LOGOUT },
 152         { N_("Account connected"), EMPATHY_PREFS_SOUNDS_SERVICE_LOGIN },
 153         { N_("Account disconnected"), EMPATHY_PREFS_SOUNDS_SERVICE_LOGOUT }
 154 };
 155
 156 static void
 157 preferences_add_id (EmpathyPreferences *preferences, guint id)
 158 {
 159         preferences->notify_ids = g_list_prepend (preferences->notify_ids,
 160                                                   GUINT_TO_POINTER (id));
 161 }
 162
 163 static void
 164 preferences_setup_widgets (EmpathyPreferences *preferences)
 165 {
 166         preferences_hookup_toggle_button (preferences,
 167                                           EMPATHY_PREFS_NOTIFICATIONS_ENABLED,
 168                                           preferences->checkbutton_notifications_enabled);
 169         preferences_hookup_toggle_button (preferences,
 170                                           EMPATHY_PREFS_NOTIFICATIONS_DISABLED_AWAY,
 171                                           preferences->checkbutton_notifications_disabled_away);
 172         preferences_hookup_toggle_button (preferences,
 173                                           EMPATHY_PREFS_NOTIFICATIONS_FOCUS,
 174                                           preferences->checkbutton_notifications_focus);
 175         preferences_hookup_toggle_button (preferences,
 176                                           EMPATHY_PREFS_NOTIFICATIONS_CONTACT_SIGNIN,
 177                                           preferences->checkbutton_notifications_contact_signin);
 178         preferences_hookup_toggle_button (preferences,
 179                                           EMPATHY_PREFS_NOTIFICATIONS_CONTACT_SIGNOUT,
 180                                           preferences->checkbutton_notifications_contact_signout);
 181
 182         preferences_hookup_sensitivity (preferences,
 183                                         EMPATHY_PREFS_NOTIFICATIONS_ENABLED,
 184                                         preferences->checkbutton_notifications_disabled_away);
 185         preferences_hookup_sensitivity (preferences,
 186                                         EMPATHY_PREFS_NOTIFICATIONS_ENABLED,
 187                                         preferences->checkbutton_notifications_focus);
 188         preferences_hookup_sensitivity (preferences,
 189                                         EMPATHY_PREFS_NOTIFICATIONS_ENABLED,
 190                                         preferences->checkbutton_notifications_contact_signin);
 191         preferences_hookup_sensitivity (preferences,
 192                                         EMPATHY_PREFS_NOTIFICATIONS_ENABLED,
 193                                         preferences->checkbutton_notifications_contact_signout);
 194
 195         preferences_hookup_toggle_button (preferences,
 196                                           EMPATHY_PREFS_SOUNDS_ENABLED,
 197                                           preferences->checkbutton_sounds_enabled);
 198         preferences_hookup_toggle_button (preferences,
 199                                           EMPATHY_PREFS_SOUNDS_DISABLED_AWAY,
 200                                           preferences->checkbutton_sounds_disabled_away);
 201
 202         preferences_hookup_sensitivity (preferences,
 203                                         EMPATHY_PREFS_SOUNDS_ENABLED,
 204                                         preferences->checkbutton_sounds_disabled_away);
 205         preferences_hookup_sensitivity (preferences,
 206                                         EMPATHY_PREFS_SOUNDS_ENABLED,
 207                                         preferences->treeview_sounds);
 208
 209         preferences_hookup_toggle_button (preferences,
 210                                           EMPATHY_PREFS_UI_SEPARATE_CHAT_WINDOWS,
 211                                           preferences->checkbutton_separate_chat_windows);
 212
 213         preferences_hookup_toggle_button (preferences,
 214                                           EMPATHY_PREFS_CHAT_SHOW_SMILEYS,
 215                                           preferences->checkbutton_show_smileys);
 216
 217         preferences_hookup_toggle_button (preferences,
 218                                           EMPATHY_PREFS_CHAT_SHOW_CONTACTS_IN_ROOMS,
 219                                           preferences->checkbutton_show_contacts_in_rooms);
 220
 221         preferences_hookup_toggle_button (preferences,
 222                                           EMPATHY_PREFS_AUTOCONNECT,
 223                                           preferences->checkbutton_autoconnect);
 224
 225         preferences_hookup_toggle_button (preferences,
 226                                           EMPATHY_PREFS_LOCATION_PUBLISH,
 227                                           preferences->checkbutton_location_publish);
 228
 229         preferences_hookup_toggle_button (preferences,
 230                                           EMPATHY_PREFS_LOCATION_RESOURCE_NETWORK,
 231                                           preferences->checkbutton_location_resource_network);
 232         preferences_hookup_sensitivity (preferences,
 233                                         EMPATHY_PREFS_LOCATION_PUBLISH,
 234                                         preferences->checkbutton_location_resource_network);
 235
 236         preferences_hookup_toggle_button (preferences,
 237                                           EMPATHY_PREFS_LOCATION_RESOURCE_CELL,
 238                                           preferences->checkbutton_location_resource_cell);
 239         preferences_hookup_sensitivity (preferences,
 240                                         EMPATHY_PREFS_LOCATION_PUBLISH,
 241                                         preferences->checkbutton_location_resource_cell);
 242
 243         preferences_hookup_toggle_button (preferences,
 244                                           EMPATHY_PREFS_LOCATION_RESOURCE_GPS,
 245                                           preferences->checkbutton_location_resource_gps);
 246         preferences_hookup_sensitivity (preferences,
 247                                         EMPATHY_PREFS_LOCATION_PUBLISH,
 248                                         preferences->checkbutton_location_resource_gps);
 249
 250         preferences_hookup_toggle_button (preferences,
 251                                           EMPATHY_PREFS_LOCATION_REDUCE_ACCURACY,
 252                                           preferences->checkbutton_location_reduce_accuracy);
 253         preferences_hookup_sensitivity (preferences,
 254                                         EMPATHY_PREFS_LOCATION_PUBLISH,
 255                                         preferences->checkbutton_location_reduce_accuracy);
 256 }
 257
 258 static void
 259 preferences_sound_cell_toggled_cb (GtkCellRendererToggle *toggle,
 260                                    char *path_string,
 261                                    EmpathyPreferences *preferences)
 262 {
 263         GtkTreePath *path;
 264         gboolean toggled, instore;
 265         GtkTreeIter iter;
 266         GtkTreeView *view;
 267         GtkTreeModel *model;
 268         char *key;
 269
 270         view = GTK_TREE_VIEW (preferences->treeview_sounds);
 271         model = gtk_tree_view_get_model (view);
 272
 273         path = gtk_tree_path_new_from_string (path_string);
 274         toggled = gtk_cell_renderer_toggle_get_active (toggle);
 275
 276         gtk_tree_model_get_iter (model, &iter, path);
 277         gtk_tree_model_get (model, &iter, COL_SOUND_KEY, &key,
 278                             COL_SOUND_ENABLED, &instore, -1);
 279
 280         instore ^= 1;
 281
 282         gtk_list_store_set (GTK_LIST_STORE (model), &iter,
 283                             COL_SOUND_ENABLED, instore, -1);
 284
 285         empathy_conf_set_bool (empathy_conf_get (), key, instore);
 286
 287         g_free (key);
 288         gtk_tree_path_free (path);
 289 }
 290
 291 static void
 292 preferences_sound_load (EmpathyPreferences *preferences)
 293 {
 294         int i;
 295         GtkTreeView *view;
 296         GtkListStore *store;
 297         GtkTreeIter iter;
 298         gboolean set;
 299         EmpathyConf *conf;
 300
 301         view = GTK_TREE_VIEW (preferences->treeview_sounds);
 302         store = GTK_LIST_STORE (gtk_tree_view_get_model (view));
 303         conf = empathy_conf_get ();
 304
 305         for (i = 0; i < G_N_ELEMENTS (sound_entries); i++) {
 306                 empathy_conf_get_bool (conf, sound_entries[i].key, &set);
 307
 308                 gtk_list_store_insert_with_values (store, &iter, i,
 309                                                    COL_SOUND_NAME, gettext (sound_entries[i].name),
 310                                                    COL_SOUND_KEY, sound_entries[i].key,
 311                                                    COL_SOUND_ENABLED, set, -1);
 312         }
 313 }
 314
 315 static void
 316 preferences_sound_setup (EmpathyPreferences *preferences)
 317 {
 318         GtkTreeView *view;
 319         GtkListStore *store;
 320         GtkCellRenderer *renderer;
 321         GtkTreeViewColumn *column;
 322
 323         view = GTK_TREE_VIEW (preferences->treeview_sounds);
 324
 325         store = gtk_list_store_new (COL_SOUND_COUNT,
 326                                     G_TYPE_BOOLEAN, /* enabled */
 327                                     G_TYPE_STRING,  /* name */
 328                                     G_TYPE_STRING); /* key */
 329
 330         gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
 331
 332         renderer = gtk_cell_renderer_toggle_new ();
 333         g_signal_connect (renderer, "toggled",
 334                           G_CALLBACK (preferences_sound_cell_toggled_cb),
 335                           preferences);
 336
 337         column = gtk_tree_view_column_new ();
 338         gtk_tree_view_column_pack_start (column, renderer, FALSE);
 339         gtk_tree_view_column_add_attribute (column, renderer,
 340                                             "active", COL_SOUND_ENABLED);
 341
 342         renderer = gtk_cell_renderer_text_new ();
 343         gtk_tree_view_column_pack_start (column, renderer, FALSE);
 344         gtk_tree_view_column_add_attribute (column, renderer,
 345                                             "text", COL_SOUND_NAME);
 346
 347         gtk_tree_view_append_column (view, column);
 348
 349         gtk_tree_view_column_set_resizable (column, FALSE);
 350         gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 351
 352         g_object_unref (store);
 353 }
 354
 355 static void
 356 preferences_languages_setup (EmpathyPreferences *preferences)
 357 {
 358         GtkTreeView       *view;
 359         GtkListStore      *store;
 360         GtkTreeSelection  *selection;
 361         GtkTreeModel      *model;
 362         GtkTreeViewColumn *column;
 363         GtkCellRenderer   *renderer;
 364         guint              col_offset;
 365
 366         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 367
 368         store = gtk_list_store_new (COL_LANG_COUNT,
 369                                     G_TYPE_BOOLEAN,  /* enabled */
 370                                     G_TYPE_STRING,   /* code */
 371                                     G_TYPE_STRING);  /* name */
 372
 373         gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
 374
 375         selection = gtk_tree_view_get_selection (view);
 376         gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
 377
 378         model = GTK_TREE_MODEL (store);
 379
 380         renderer = gtk_cell_renderer_toggle_new ();
 381         g_signal_connect (renderer, "toggled",
 382                           G_CALLBACK (preferences_languages_cell_toggled_cb),
 383                           preferences);
 384
 385         column = gtk_tree_view_column_new_with_attributes (NULL, renderer,
 386                                                            "active", COL_LANG_ENABLED,
 387                                                            NULL);
 388
 389         gtk_tree_view_append_column (view, column);
 390
 391         renderer = gtk_cell_renderer_text_new ();
 392         col_offset = gtk_tree_view_insert_column_with_attributes (view,
 393                                                                   -1, _("Language"),
 394                                                                   renderer,
 395                                                                   "text", COL_LANG_NAME,
 396                                                                   NULL);
 397
 398         g_object_set_data (G_OBJECT (renderer),
 399                            "column", GINT_TO_POINTER (COL_LANG_NAME));
 400
 401         column = gtk_tree_view_get_column (view, col_offset - 1);
 402         gtk_tree_view_column_set_sort_column_id (column, COL_LANG_NAME);
 403         gtk_tree_view_column_set_resizable (column, FALSE);
 404         gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 405
 406         g_object_unref (store);
 407 }
 408
 409 static void
 410 preferences_languages_add (EmpathyPreferences *preferences)
 411 {
 412         GtkTreeView  *view;
 413         GtkListStore *store;
 414         GList        *codes, *l;
 415
 416         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 417         store = GTK_LIST_STORE (gtk_tree_view_get_model (view));
 418
 419         codes = empathy_spell_get_language_codes ();
 420
 421         empathy_conf_set_bool (empathy_conf_get (),
 422                                EMPATHY_PREFS_CHAT_SPELL_CHECKER_ENABLED,
 423                                codes != NULL);
 424         if (!codes) {
 425                 gtk_widget_set_sensitive (preferences->treeview_spell_checker, FALSE);
 426         }
 427
 428         for (l = codes; l; l = l->next) {
 429                 GtkTreeIter  iter;
 430                 const gchar *code;
 431                 const gchar *name;
 432
 433                 code = l->data;
 434                 name = empathy_spell_get_language_name (code);
 435                 if (!name) {
 436                         continue;
 437                 }
 438
 439                 gtk_list_store_append (store, &iter);
 440                 gtk_list_store_set (store, &iter,
 441                                     COL_LANG_CODE, code,
 442                                     COL_LANG_NAME, name,
 443                                     -1);
 444         }
 445
 446         empathy_spell_free_language_codes (codes);
 447 }
 448
 449 static void
 450 preferences_languages_save (EmpathyPreferences *preferences)
 451 {
 452         GtkTreeView       *view;
 453         GtkTreeModel      *model;
 454
 455         gchar             *languages = NULL;
 456
 457         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 458         model = gtk_tree_view_get_model (view);
 459
 460         gtk_tree_model_foreach (model,
 461                                 (GtkTreeModelForeachFunc) preferences_languages_save_foreach,
 462                                 &languages);
 463
 464         /* if user selects no languages, we don't want spell check */
 465         empathy_conf_set_bool (empathy_conf_get (),
 466                                EMPATHY_PREFS_CHAT_SPELL_CHECKER_ENABLED,
 467                                languages != NULL);
 468
 469         empathy_conf_set_string (empathy_conf_get (),
 470                                  EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
 471                                  languages ? languages : "");
 472
 473         g_free (languages);
 474 }
 475
 476 static gboolean
 477 preferences_languages_save_foreach (GtkTreeModel  *model,
 478                                     GtkTreePath   *path,
 479                                     GtkTreeIter   *iter,
 480                                     gchar        **languages)
 481 {
 482         gboolean  enabled;
 483         gchar    *code;
 484
 485         if (!languages) {
 486                 return TRUE;
 487         }
 488
 489         gtk_tree_model_get (model, iter, COL_LANG_ENABLED, &enabled, -1);
 490         if (!enabled) {
 491                 return FALSE;
 492         }
 493
 494         gtk_tree_model_get (model, iter, COL_LANG_CODE, &code, -1);
 495         if (!code) {
 496                 return FALSE;
 497         }
 498
 499         if (!(*languages)) {
 500                 *languages = g_strdup (code);
 501         } else {
 502                 gchar *str = *languages;
 503                 *languages = g_strdup_printf ("%s,%s", str, code);
 504                 g_free (str);
 505         }
 506
 507         g_free (code);
 508
 509         return FALSE;
 510 }
 511
 512 static void
 513 preferences_languages_load (EmpathyPreferences *preferences)
 514 {
 515         GtkTreeView   *view;
 516         GtkTreeModel  *model;
 517         gchar         *value;
 518         gchar        **vlanguages;
 519
 520         if (!empathy_conf_get_string (empathy_conf_get (),
 521                                       EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
 522                                       &value) || !value) {
 523                 return;
 524         }
 525
 526         vlanguages = g_strsplit (value, ",", -1);
 527         g_free (value);
 528
 529         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 530         model = gtk_tree_view_get_model (view);
 531
 532         gtk_tree_model_foreach (model,
 533                                 (GtkTreeModelForeachFunc) preferences_languages_load_foreach,
 534                                 vlanguages);
 535
 536         g_strfreev (vlanguages);
 537 }
 538
 539 static gboolean
 540 preferences_languages_load_foreach (GtkTreeModel  *model,
 541                                     GtkTreePath   *path,
 542                                     GtkTreeIter   *iter,
 543                                     gchar        **languages)
 544 {
 545         gchar    *code;
 546         gchar    *lang;
 547         gint      i;
 548         gboolean  found = FALSE;
 549
 550         if (!languages) {
 551                 return TRUE;
 552         }
 553
 554         gtk_tree_model_get (model, iter, COL_LANG_CODE, &code, -1);
 555         if (!code) {
 556                 return FALSE;
 557         }
 558
 559         for (i = 0, lang = languages[i]; lang; lang = languages[++i]) {
 560                 if (strcmp (lang, code) == 0) {
 561                         found = TRUE;
 562                 }
 563         }
 564
 565         g_free (code);
 566         gtk_list_store_set (GTK_LIST_STORE (model), iter, COL_LANG_ENABLED, found, -1);
 567         return FALSE;
 568 }
 569
 570 static void
 571 preferences_languages_cell_toggled_cb (GtkCellRendererToggle *cell,
 572                                        gchar                 *path_string,
 573                                        EmpathyPreferences     *preferences)
 574 {
 575         GtkTreeView  *view;
 576         GtkTreeModel *model;
 577         GtkListStore *store;
 578         GtkTreePath  *path;
 579         GtkTreeIter   iter;
 580         gboolean      enabled;
 581
 582         view = GTK_TREE_VIEW (preferences->treeview_spell_checker);
 583         model = gtk_tree_view_get_model (view);
 584         store = GTK_LIST_STORE (model);
 585
 586         path = gtk_tree_path_new_from_string (path_string);
 587
 588         gtk_tree_model_get_iter (model, &iter, path);
 589         gtk_tree_model_get (model, &iter, COL_LANG_ENABLED, &enabled, -1);
 590
 591         enabled ^= 1;
 592
 593         gtk_list_store_set (store, &iter, COL_LANG_ENABLED, enabled, -1);
 594         gtk_tree_path_free (path);
 595
 596         preferences_languages_save (preferences);
 597 }
 598
 599 static void
 600 preferences_widget_sync_bool (const gchar *key, GtkWidget *widget)
 601 {
 602         gboolean value;
 603
 604         if (empathy_conf_get_bool (empathy_conf_get (), key, &value)) {
 605                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), value);
 606         }
 607 }
 608
 609 #if 0
 610 static void
 611 preferences_widget_sync_string (const gchar *key, GtkWidget *widget)
 612 {
 613         gchar *value;
 614
 615         if (empathy_conf_get_string (empathy_conf_get (), key, &value) && value) {
 616                 if (GTK_IS_ENTRY (widget)) {
 617                         gtk_entry_set_text (GTK_ENTRY (widget), value);
 618                 } else if (GTK_IS_RADIO_BUTTON (widget)) {
 619                         if (strcmp (key, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM) == 0) {
 620                                 GType        type;
 621                                 GEnumClass  *enum_class;
 622                                 GEnumValue  *enum_value;
 623                                 GSList      *list;
 624                                 GtkWidget   *toggle_widget;
 625
 626                                 /* Get index from new string */
 627                                 type = empathy_contact_list_store_sort_get_type ();
 628                                 enum_class = G_ENUM_CLASS (g_type_class_peek (type));
 629                                 enum_value = g_enum_get_value_by_nick (enum_class, value);
 630
 631                                 if (enum_value) {
 632                                         list = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
 633                                         toggle_widget = g_slist_nth_data (list, enum_value->value);
 634                                         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_widget), TRUE);
 635                                 }
 636                         } else {
 637                                 g_warning ("Unhandled key:'%s' just had string change", key);
 638                         }
 639                 }
 640
 641                 g_free (value);
 642         }
 643 }
 644
 645 static void
 646 preferences_notify_string_cb (EmpathyConf  *conf,
 647                               const gchar *key,
 648                               gpointer     user_data)
 649 {
 650         preferences_widget_sync_string (key, user_data);
 651 }
 652 #endif
 653
 654 static void
 655 preferences_notify_bool_cb (EmpathyConf  *conf,
 656                             const gchar *key,
 657                             gpointer     user_data)
 658 {
 659         preferences_widget_sync_bool (key, user_data);
 660 }
 661
 662 static void
 663 preferences_notify_sensitivity_cb (EmpathyConf  *conf,
 664                                    const gchar *key,
 665                                    gpointer     user_data)
 666 {
 667         gboolean value;
 668
 669         if (empathy_conf_get_bool (conf, key, &value)) {
 670                 gtk_widget_set_sensitive (GTK_WIDGET (user_data), value);
 671         }
 672 }
 673
 674 #if 0
 675 static void
 676 preferences_widget_sync_int (const gchar *key, GtkWidget *widget)
 677 {
 678         gint value;
 679
 680         if (empathy_conf_get_int (empathy_conf_get (), key, &value)) {
 681                 if (GTK_IS_SPIN_BUTTON (widget)) {
 682                         gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
 683                 }
 684         }
 685 }
 686
 687 static void
 688 preferences_notify_int_cb (EmpathyConf  *conf,
 689                            const gchar *key,
 690                            gpointer     user_data)
 691 {
 692         preferences_widget_sync_int (key, user_data);
 693 }
 694
 695 static void
 696 preferences_hookup_spin_button (EmpathyPreferences *preferences,
 697                                 const gchar       *key,
 698                                 GtkWidget         *widget)
 699 {
 700         guint id;
 701
 702         preferences_widget_sync_int (key, widget);
 703
 704         g_object_set_data_full (G_OBJECT (widget), "key",
 705                                 g_strdup (key), g_free);
 706
 707         g_signal_connect (widget,
 708                           "value_changed",
 709                           G_CALLBACK (preferences_spin_button_value_changed_cb),
 710                           NULL);
 711
 712         id = empathy_conf_notify_add (empathy_conf_get (),
 713                                       key,
 714                                       preferences_notify_int_cb,
 715                                       widget);
 716         if (id) {
 717                 preferences_add_id (preferences, id);
 718         }
 719 }
 720
 721 static void
 722 preferences_hookup_entry (EmpathyPreferences *preferences,
 723                           const gchar       *key,
 724                           GtkWidget         *widget)
 725 {
 726         guint id;
 727
 728         preferences_widget_sync_string (key, widget);
 729
 730         g_object_set_data_full (G_OBJECT (widget), "key",
 731                                 g_strdup (key), g_free);
 732
 733         g_signal_connect (widget,
 734                           "changed",
 735                           G_CALLBACK (preferences_entry_value_changed_cb),
 736                           NULL);
 737
 738         id = empathy_conf_notify_add (empathy_conf_get (),
 739                                       key,
 740                                       preferences_notify_string_cb,
 741                                       widget);
 742         if (id) {
 743                 preferences_add_id (preferences, id);
 744         }
 745 }
 746
 747 static void
 748 preferences_spin_button_value_changed_cb (GtkWidget *button,
 749                                           gpointer   user_data)
 750 {
 751         const gchar *key;
 752
 753         key = g_object_get_data (G_OBJECT (button), "key");
 754
 755         empathy_conf_set_int (empathy_conf_get (),
 756                               key,
 757                               gtk_spin_button_get_value (GTK_SPIN_BUTTON (button)));
 758 }
 759
 760 static void
 761 preferences_entry_value_changed_cb (GtkWidget *entry,
 762                                     gpointer   user_data)
 763 {
 764         const gchar *key;
 765
 766         key = g_object_get_data (G_OBJECT (entry), "key");
 767
 768         empathy_conf_set_string (empathy_conf_get (),
 769                                  key,
 770                                  gtk_entry_get_text (GTK_ENTRY (entry)));
 771 }
 772 #endif
 773
 774 static void
 775 preferences_hookup_toggle_button (EmpathyPreferences *preferences,
 776                                   const gchar       *key,
 777                                   GtkWidget         *widget)
 778 {
 779         guint id;
 780
 781         preferences_widget_sync_bool (key, widget);
 782
 783         g_object_set_data_full (G_OBJECT (widget), "key",
 784                                 g_strdup (key), g_free);
 785
 786         g_signal_connect (widget,
 787                           "toggled",
 788                           G_CALLBACK (preferences_toggle_button_toggled_cb),
 789                           NULL);
 790
 791         id = empathy_conf_notify_add (empathy_conf_get (),
 792                                      key,
 793                                      preferences_notify_bool_cb,
 794                                      widget);
 795         if (id) {
 796                 preferences_add_id (preferences, id);
 797         }
 798 }
 799
 800 #if 0
 801 static void
 802 preferences_hookup_radio_button (EmpathyPreferences *preferences,
 803                                  const gchar       *key,
 804                                  GtkWidget         *widget)
 805 {
 806         GSList *group, *l;
 807         guint   id;
 808
 809         preferences_widget_sync_string (key, widget);
 810
 811         group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
 812         for (l = group; l; l = l->next) {
 813                 g_signal_connect (l->data,
 814                                   "toggled",
 815                                   G_CALLBACK (preferences_radio_button_toggled_cb),
 816                                   NULL);
 817
 818                 g_object_set_data_full (G_OBJECT (l->data), "key",
 819                                         g_strdup (key), g_free);
 820         }
 821
 822         id = empathy_conf_notify_add (empathy_conf_get (),
 823                                      key,
 824                                      preferences_notify_string_cb,
 825                                      widget);
 826         if (id) {
 827                 preferences_add_id (preferences, id);
 828         }
 829 }
 830 #endif
 831
 832 static void
 833 preferences_hookup_sensitivity (EmpathyPreferences *preferences,
 834                                 const gchar       *key,
 835                                 GtkWidget         *widget)
 836 {
 837         gboolean value;
 838         guint    id;
 839
 840         if (empathy_conf_get_bool (empathy_conf_get (), key, &value)) {
 841                 gtk_widget_set_sensitive (widget, value);
 842         }
 843
 844         id = empathy_conf_notify_add (empathy_conf_get (),
 845                                       key,
 846                                       preferences_notify_sensitivity_cb,
 847                                       widget);
 848         if (id) {
 849                 preferences_add_id (preferences, id);
 850         }
 851 }
 852
 853 static void
 854 preferences_toggle_button_toggled_cb (GtkWidget *button,
 855                                       gpointer   user_data)
 856 {
 857         const gchar *key;
 858
 859         key = g_object_get_data (G_OBJECT (button), "key");
 860
 861         empathy_conf_set_bool (empathy_conf_get (),
 862                                key,
 863                                gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
 864 }
 865
 866 #if 0
 867 static void
 868 preferences_radio_button_toggled_cb (GtkWidget *button,
 869                                      gpointer   user_data)
 870 {
 871         const gchar *key;
 872         const gchar *value = NULL;
 873
 874         if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) {
 875                 return;
 876         }
 877
 878         key = g_object_get_data (G_OBJECT (button), "key");
 879
 880         if (key && strcmp (key, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM) == 0) {
 881                 GSList      *group;
 882                 GType        type;
 883                 GEnumClass  *enum_class;
 884                 GEnumValue  *enum_value;
 885
 886                 group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
 887
 888                 /* Get string from index */
 889                 type = empathy_contact_list_store_sort_get_type ();
 890                 enum_class = G_ENUM_CLASS (g_type_class_peek (type));
 891                 enum_value = g_enum_get_value (enum_class, g_slist_index (group, button));
 892
 893                 if (!enum_value) {
 894                         g_warning ("No GEnumValue for EmpathyContactListSort with GtkRadioButton index:%d",
 895                                    g_slist_index (group, button));
 896                         return;
 897                 }
 898
 899                 value = enum_value->value_nick;
 900         } else if (key && strcmp (key, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM) == 0) {
 901            return;
 902         }
 903
 904         empathy_conf_set_string (empathy_conf_get (), key, value);
 905 }
 906 #endif
 907
 908 static void
 909 preferences_theme_notify_cb (EmpathyConf *conf,
 910                              const gchar *key,
 911                              gpointer     user_data)
 912 {
 913         EmpathyPreferences *preferences = user_data;
 914         GtkComboBox        *combo;
 915         gchar              *conf_name;
 916         gchar              *conf_path;
 917         GtkTreeModel       *model;
 918         GtkTreeIter         iter;
 919         gboolean            found = FALSE;
 920
 921         if (!empathy_conf_get_string (conf, EMPATHY_PREFS_CHAT_THEME, &conf_name)) {
 922                 return;
 923         }
 924
 925         if (!empathy_conf_get_string (conf, EMPATHY_PREFS_CHAT_ADIUM_PATH, &conf_path)) {
 926                 g_free (conf_name);
 927                 return;
 928         }
 929
 930         combo = GTK_COMBO_BOX (preferences->combobox_chat_theme);
 931         model = gtk_combo_box_get_model (combo);
 932         if (gtk_tree_model_get_iter_first (model, &iter)) {
 933                 gboolean is_adium;
 934                 gchar *name;
 935                 gchar *path;
 936
 937                 do {
 938                         gtk_tree_model_get (model, &iter,
 939                                             COL_COMBO_IS_ADIUM, &is_adium,
 940                                             COL_COMBO_NAME, &name,
 941                                             COL_COMBO_PATH, &path,
 942                                             -1);
 943
 944                         if (strcmp (name, conf_name) == 0) {
 945                                 if (strcmp (name, "adium") != 0 ||
 946                                     strcmp (path, conf_path) == 0) {
 947                                         found = TRUE;
 948                                         gtk_combo_box_set_active_iter (combo, &iter);
 949                                         g_free (name);
 950                                         g_free (path);
 951                                         break;
 952                                 }
 953                         }
 954
 955                         g_free (name);
 956                         g_free (path);
 957                 } while (gtk_tree_model_iter_next (model, &iter));
 958         }
 959
 960         /* Fallback to the first one. */
 961         if (!found) {
 962                 if (gtk_tree_model_get_iter_first (model, &iter)) {
 963                         gtk_combo_box_set_active_iter (combo, &iter);
 964                 }
 965         }
 966
 967         g_free (conf_name);
 968         g_free (conf_path);
 969 }
 970
 971 static void
 972 preferences_theme_changed_cb (GtkComboBox        *combo,
 973                               EmpathyPreferences *preferences)
 974 {
 975         GtkTreeModel *model;
 976         GtkTreeIter   iter;
 977         gboolean      is_adium;
 978         gchar        *name;
 979         gchar        *path;
 980
 981         if (gtk_combo_box_get_active_iter (combo, &iter)) {
 982                 model = gtk_combo_box_get_model (combo);
 983
 984                 gtk_tree_model_get (model, &iter,
 985                                     COL_COMBO_IS_ADIUM, &is_adium,
 986                                     COL_COMBO_NAME, &name,
 987                                     COL_COMBO_PATH, &path,
 988                                     -1);
 989
 990                 empathy_conf_set_string (empathy_conf_get (),
 991                                          EMPATHY_PREFS_CHAT_THEME,
 992                                          name);
 993                 if (is_adium == TRUE)
 994                         empathy_conf_set_string (empathy_conf_get (),
 995                                                  EMPATHY_PREFS_CHAT_ADIUM_PATH,
 996                                                  path);
 997                 g_free (name);
 998                 g_free (path);
 999         }
1000 }
1001
1002 static void
1003 preferences_themes_setup (EmpathyPreferences *preferences)
1004 {
1005         GtkComboBox   *combo;
1006         GtkCellLayout *cell_layout;
1007         GtkCellRenderer *renderer;
1008         GtkListStore  *store;
1009         const gchar  **themes;
1010         GList         *adium_themes;
1011         gint           i;
1012         guint          id;
1013
1014         combo = GTK_COMBO_BOX (preferences->combobox_chat_theme);
1015         cell_layout = GTK_CELL_LAYOUT (combo);
1016
1017         /* Create the model */
1018         store = gtk_list_store_new (COL_COMBO_COUNT,
1019                                     G_TYPE_BOOLEAN, /* Is an Adium theme */
1020                                     G_TYPE_STRING,  /* Display name */
1021                                     G_TYPE_STRING,  /* Theme name */
1022                                     G_TYPE_STRING); /* Theme path */
1023         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
1024                 COL_COMBO_VISIBLE_NAME, GTK_SORT_ASCENDING);
1025
1026         /* Fill the model */
1027         themes = empathy_theme_manager_get_themes ();
1028         for (i = 0; themes[i]; i += 2) {
1029                 gtk_list_store_insert_with_values (store, NULL, -1,
1030                         COL_COMBO_IS_ADIUM, FALSE,
1031                         COL_COMBO_VISIBLE_NAME, _(themes[i + 1]),
1032                         COL_COMBO_NAME, themes[i],
1033                         COL_COMBO_PATH, NULL,
1034                         -1);
1035         }
1036
1037         adium_themes = empathy_theme_manager_get_adium_themes ();
1038         while (adium_themes != NULL) {
1039                 GHashTable *info;
1040                 const gchar *name;
1041                 const gchar *path;
1042
1043                 info = adium_themes->data;
1044                 name = tp_asv_get_string (info, "CFBundleName");
1045                 path = tp_asv_get_string (info, "path");
1046
1047                 if (name != NULL && path != NULL) {
1048                         gtk_list_store_insert_with_values (store, NULL, -1,
1049                                 COL_COMBO_IS_ADIUM, TRUE,
1050                                 COL_COMBO_VISIBLE_NAME, name,
1051                                 COL_COMBO_NAME, "adium",
1052                                 COL_COMBO_PATH, path,
1053                                 -1);
1054                 }
1055                 g_hash_table_unref (info);
1056                 adium_themes = g_list_delete_link (adium_themes, adium_themes);
1057         }
1058
1059         /* Add cell renderer */
1060         renderer = gtk_cell_renderer_text_new ();
1061         gtk_cell_layout_pack_start (cell_layout, renderer, TRUE);
1062         gtk_cell_layout_set_attributes (cell_layout, renderer,
1063                 "text", COL_COMBO_VISIBLE_NAME, NULL);
1064
1065         gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
1066         g_object_unref (store);
1067
1068         g_signal_connect (combo, "changed",
1069                           G_CALLBACK (preferences_theme_changed_cb),
1070                           preferences);
1071
1072         /* Select the theme from the gconf key and track changes */
1073         preferences_theme_notify_cb (empathy_conf_get (),
1074                                      EMPATHY_PREFS_CHAT_THEME,
1075                                      preferences);
1076         id = empathy_conf_notify_add (empathy_conf_get (),
1077                                       EMPATHY_PREFS_CHAT_THEME,
1078                                       preferences_theme_notify_cb,
1079                                       preferences);
1080         if (id) {
1081                 preferences_add_id (preferences, id);
1082         }
1083
1084         id = empathy_conf_notify_add (empathy_conf_get (),
1085                                       EMPATHY_PREFS_CHAT_ADIUM_PATH,
1086                                       preferences_theme_notify_cb,
1087                                       preferences);
1088         if (id) {
1089                 preferences_add_id (preferences, id);
1090         }
1091 }
1092
1093 static void
1094 preferences_response_cb (GtkWidget         *widget,
1095                          gint               response,
1096                          EmpathyPreferences *preferences)
1097 {
1098         gtk_widget_destroy (widget);
1099 }
1100
1101 static void
1102 preferences_destroy_cb (GtkWidget         *widget,
1103                         EmpathyPreferences *preferences)
1104 {
1105         GList *l;
1106
1107         for (l = preferences->notify_ids; l; l = l->next) {
1108                 guint id;
1109
1110                 id = GPOINTER_TO_UINT (l->data);
1111                 empathy_conf_notify_remove (empathy_conf_get (), id);
1112         }
1113
1114         g_list_free (preferences->notify_ids);
1115         g_free (preferences);
1116 }
1117
1118 GtkWidget *
1119 empathy_preferences_show (GtkWindow *parent)
1120 {
1121         static EmpathyPreferences *preferences;
1122         GtkBuilder                *gui;
1123         gchar                     *filename;
1124         GtkWidget                 *page;
1125
1126         if (preferences) {
1127                 gtk_window_present (GTK_WINDOW (preferences->dialog));
1128                 return preferences->dialog;
1129         }
1130
1131         preferences = g_new0 (EmpathyPreferences, 1);
1132
1133         filename = empathy_file_lookup ("empathy-preferences.ui", "src");
1134         gui = empathy_builder_get_file (filename,
1135                 "preferences_dialog", &preferences->dialog,
1136                 "notebook", &preferences->notebook,
1137                 "checkbutton_show_smileys", &preferences->checkbutton_show_smileys,
1138                 "checkbutton_show_contacts_in_rooms", &preferences->checkbutton_show_contacts_in_rooms,
1139                 "combobox_chat_theme", &preferences->combobox_chat_theme,
1140                 "checkbutton_separate_chat_windows", &preferences->checkbutton_separate_chat_windows,
1141                 "checkbutton_autoconnect", &preferences->checkbutton_autoconnect,
1142                 "checkbutton_notifications_enabled", &preferences->checkbutton_notifications_enabled,
1143                 "checkbutton_notifications_disabled_away", &preferences->checkbutton_notifications_disabled_away,
1144                 "checkbutton_notifications_focus", &preferences->checkbutton_notifications_focus,
1145                 "checkbutton_notifications_contact_signin", &preferences->checkbutton_notifications_contact_signin,
1146                 "checkbutton_notifications_contact_signout", &preferences->checkbutton_notifications_contact_signout,
1147                 "checkbutton_sounds_enabled", &preferences->checkbutton_sounds_enabled,
1148                 "checkbutton_sounds_disabled_away", &preferences->checkbutton_sounds_disabled_away,
1149                 "treeview_sounds", &preferences->treeview_sounds,
1150                 "treeview_spell_checker", &preferences->treeview_spell_checker,
1151                 "checkbutton_location_publish", &preferences->checkbutton_location_publish,
1152                 "checkbutton_location_reduce_accuracy", &preferences->checkbutton_location_reduce_accuracy,
1153                 "checkbutton_location_resource_network", &preferences->checkbutton_location_resource_network,
1154                 "checkbutton_location_resource_cell", &preferences->checkbutton_location_resource_cell,
1155                 "checkbutton_location_resource_gps", &preferences->checkbutton_location_resource_gps,
1156                 NULL);
1157         g_free (filename);
1158
1159         empathy_builder_connect (gui, preferences,
1160                               "preferences_dialog", "destroy", preferences_destroy_cb,
1161                               "preferences_dialog", "response", preferences_response_cb,
1162                               NULL);
1163
1164         g_object_unref (gui);
1165
1166         g_object_add_weak_pointer (G_OBJECT (preferences->dialog), (gpointer) &preferences);
1167
1168         preferences_themes_setup (preferences);
1169
1170         preferences_setup_widgets (preferences);
1171
1172         preferences_languages_setup (preferences);
1173         preferences_languages_add (preferences);
1174         preferences_languages_load (preferences);
1175
1176         preferences_sound_setup (preferences);
1177         preferences_sound_load (preferences);
1178
1179         if (empathy_spell_supported ()) {
1180                 GtkWidget *page;
1181
1182                 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (preferences->notebook), 2);
1183                 gtk_widget_show (page);
1184         }
1185
1186         page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (preferences->notebook), 3);
1187 #if HAVE_GEOCLUE
1188         gtk_widget_show (page);
1189 #else
1190         gtk_widget_hide (page);
1191 #endif
1192
1193
1194         if (parent) {
1195                 gtk_window_set_transient_for (GTK_WINDOW (preferences->dialog),
1196                                               GTK_WINDOW (parent));
1197         }
1198
1199         gtk_widget_show (preferences->dialog);
1200
1201         return preferences->dialog;
1202 }
1203