← Back to branch summary

~bcurtiswx/ubuntu/precise/empathy/3.4.2.1-0ubuntu1

« back to all changes in this revision

Viewing changes to libempathy-gtk/gossip-preferences.c

  • Committer: Bazaar Package Importer
  • Author(s): Sjoerd Simons
  • Date: 2007-05-20 15:31:42 UTC
  • Revision ID: james.westby@ubuntu.com-20070520153142-r3auwguxdgxhktqb
Tags: upstream-0.4
Import upstream version 0.4

Show diffs side-by-side

added added

removed removed

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