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