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