← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/rhythmbox/oneiric

« back to all changes in this revision

Viewing changes to shell/rb-shell-preferences.c

  • Committer: Bazaar Package Importer
  • Author(s): Rico Tzschichholz
  • Date: 2011-07-29 16:41:38 UTC
  • mto: This revision was merged to the branch mainline in revision 191.
  • Revision ID: james.westby@ubuntu.com-20110729164138-wwicy8nqalm18ck7
Tags: upstream-2.90.1~20110802
Import upstream version 2.90.1~20110802

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell/rb-shell-preferences.c
59
59
#include "rb-builder-helpers.h"
60
60
#include "rb-dialog.h"
61
61
#include "rb-debug.h"
62
 
#include "eel-gconf-extensions.h"
63
 
#include "rb-preferences.h"
64
62
#include "rb-shell.h"
 
63
#include "rb-util.h"
65
64
 
66
65
static void rb_shell_preferences_class_init (RBShellPreferencesClass *klass);
67
66
static void rb_shell_preferences_init (RBShellPreferences *shell_preferences);
68
 
static void rb_shell_preferences_finalize (GObject *object);
 
67
static void impl_finalize (GObject *object);
 
68
static void impl_dispose (GObject *object);
69
69
static gboolean rb_shell_preferences_window_delete_cb (GtkWidget *window,
70
70
                                                       GdkEventAny *event,
71
71
                                                       RBShellPreferences *shell_preferences);
72
72
static void rb_shell_preferences_response_cb (GtkDialog *dialog,
73
73
                                              int response_id,
74
74
                                              RBShellPreferences *shell_preferences);
75
 
static void rb_shell_preferences_ui_pref_changed (GConfClient *client,
76
 
                                                  guint cnxn_id,
77
 
                                                  GConfEntry *entry,
78
 
                                                  RBShellPreferences *shell_preferences);
79
 
static void rb_shell_preferences_sync (RBShellPreferences *shell_preferences);
80
75
 
81
76
void rb_shell_preferences_column_check_changed_cb (GtkCheckButton *butt,
82
77
                                                   RBShellPreferences *shell_preferences);
83
78
void rb_shell_preferences_browser_views_activated_cb (GtkWidget *widget,
84
79
                                                      RBShellPreferences *shell_preferences);
85
 
static void rb_shell_preferences_toolbar_style_cb (GtkComboBox *box,
86
 
                                                   RBShellPreferences *preferences);
87
 
static void rb_shell_preferences_player_backend_cb (GtkToggleButton *button,
88
 
                                                    RBShellPreferences *preferences);
89
 
static void rb_shell_preferences_transition_duration_cb (GtkRange *range,
90
 
                                                         RBShellPreferences *preferences);
91
 
static void rb_shell_preferences_network_buffer_size_cb (GtkRange *range,
92
 
                                                         RBShellPreferences *preferences);
93
 
static void update_playback_prefs_sensitivity (RBShellPreferences *preferences);
 
80
static gboolean toolbar_style_get_map (GValue *value, GVariant *variant, gpointer data);
 
81
static GVariant *toolbar_style_set_map (const GValue *value, const GVariantType *variant_type, gpointer data);
 
82
 
 
83
static void column_check_toggled_cb (GtkWidget *widget, RBShellPreferences *preferences);
 
84
 
 
85
static void player_settings_changed_cb (GSettings *settings, const char *key, RBShellPreferences *preferences);
 
86
static void source_settings_changed_cb (GSettings *settings, const char *key, RBShellPreferences *preferences);
 
87
static void transition_time_changed_cb (GtkRange *range, RBShellPreferences *preferences);
94
88
 
95
89
enum
96
90
{
97
91
        PROP_0,
98
92
};
99
93
 
100
 
const char *styles[] = { "desktop_default", "both", "both_horiz", "icon", "text" };
 
94
#define COLUMN_CHECK_PROP_NAME  "rb-column-prop-name"
 
95
 
 
96
struct {
 
97
        const char *widget;
 
98
        RhythmDBPropType prop;
 
99
} column_checks[] = {
 
100
        { "track_check",        RHYTHMDB_PROP_TRACK_NUMBER },
 
101
        { "artist_check",       RHYTHMDB_PROP_ARTIST },
 
102
        { "album_check",        RHYTHMDB_PROP_ALBUM },
 
103
        { "year_check",         RHYTHMDB_PROP_DATE },
 
104
        { "last_played_check",  RHYTHMDB_PROP_LAST_PLAYED },
 
105
        { "genre_check",        RHYTHMDB_PROP_GENRE },
 
106
        { "first_seen_check",   RHYTHMDB_PROP_FIRST_SEEN },
 
107
        { "play_count_check",   RHYTHMDB_PROP_PLAY_COUNT },
 
108
        { "comment_check",      RHYTHMDB_PROP_COMMENT },
 
109
        { "bpm_check",          RHYTHMDB_PROP_BPM },
 
110
        { "rating_check",       RHYTHMDB_PROP_RATING },
 
111
        { "duration_check",     RHYTHMDB_PROP_DURATION },
 
112
        { "location_check",     RHYTHMDB_PROP_LOCATION },
 
113
        { "quality_check",      RHYTHMDB_PROP_BITRATE }
 
114
};
 
115
 
101
116
 
102
117
struct RBShellPreferencesPrivate
103
118
{
104
119
        GtkWidget *notebook;
105
120
 
106
 
        GtkWidget *config_widget;
107
 
        GtkWidget *artist_check;
108
 
        GtkWidget *album_check;
109
 
        GtkWidget *genre_check;
110
 
        GtkWidget *comment_check;
111
 
        GtkWidget *duration_check;
112
 
        GtkWidget *track_check;
113
 
        GtkWidget *rating_check;
114
 
        GtkWidget *play_count_check;
115
 
        GtkWidget *last_played_check;
116
 
        GtkWidget *first_seen_check;
117
 
        GtkWidget *bpm_check;
118
 
        GtkWidget *quality_check;
119
 
        GtkWidget *year_check;
120
 
        GtkWidget *location_check;
 
121
        GHashTable *column_checks;
121
122
        GtkWidget *general_prefs_plugin_box;
122
123
 
123
124
        GtkWidget *xfade_backend_check;
124
125
        GtkWidget *transition_duration;
125
 
        GtkWidget *network_buffer_size;
126
126
        GtkWidget *playback_prefs_plugin_box;
127
127
 
128
128
        GSList *browser_views_group;
129
129
 
130
130
        GtkWidget *toolbar_style_menu;
131
131
 
132
 
        gboolean loading;
 
132
        gboolean applying_settings;
 
133
 
 
134
        GSettings *main_settings;
 
135
        GSettings *source_settings;
 
136
        GSettings *player_settings;
133
137
};
134
138
 
135
 
#define RB_SHELL_PREFERENCES_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RB_TYPE_SHELL_PREFERENCES, RBShellPreferencesPrivate))
136
139
 
137
140
G_DEFINE_TYPE (RBShellPreferences, rb_shell_preferences, GTK_TYPE_DIALOG)
138
141
 
141
144
{
142
145
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
143
146
 
144
 
        object_class->finalize = rb_shell_preferences_finalize;
 
147
        object_class->finalize = impl_finalize;
 
148
        object_class->dispose = impl_dispose;
145
149
 
146
150
        g_type_class_add_private (klass, sizeof (RBShellPreferencesPrivate));
147
151
}
172
176
        GtkWidget *tmp;
173
177
        GtkWidget *content_area;
174
178
        GtkBuilder *builder;
 
179
        int i;
175
180
 
176
 
        shell_preferences->priv = RB_SHELL_PREFERENCES_GET_PRIVATE (shell_preferences);
 
181
        shell_preferences->priv = G_TYPE_INSTANCE_GET_PRIVATE (shell_preferences,
 
182
                                                               RB_TYPE_SHELL_PREFERENCES,
 
183
                                                               RBShellPreferencesPrivate);
177
184
 
178
185
        g_signal_connect_object (shell_preferences,
179
186
                                 "delete_event",
202
209
        gtk_container_set_border_width (GTK_CONTAINER (shell_preferences->priv->notebook), 5);
203
210
 
204
211
        content_area = gtk_dialog_get_content_area (GTK_DIALOG (shell_preferences));
205
 
 
206
212
        gtk_container_add (GTK_CONTAINER (content_area),
207
213
                           shell_preferences->priv->notebook);
208
214
 
209
215
        gtk_container_set_border_width (GTK_CONTAINER (shell_preferences), 5);
210
216
        gtk_box_set_spacing (GTK_BOX (content_area), 2);
211
217
 
 
218
        shell_preferences->priv->source_settings = g_settings_new ("org.gnome.rhythmbox.sources");
 
219
 
212
220
        builder = rb_builder_load ("general-prefs.ui", shell_preferences);
213
221
 
214
222
        rb_builder_boldify_label (builder, "visible_columns_label");
215
223
 
216
224
        /* Columns */
217
 
        shell_preferences->priv->artist_check =
218
 
                GTK_WIDGET (gtk_builder_get_object (builder, "artist_check"));
219
 
        shell_preferences->priv->album_check =
220
 
                GTK_WIDGET (gtk_builder_get_object (builder, "album_check"));
221
 
        shell_preferences->priv->genre_check =
222
 
                GTK_WIDGET (gtk_builder_get_object (builder, "genre_check"));
223
 
        shell_preferences->priv->comment_check =
224
 
                GTK_WIDGET (gtk_builder_get_object (builder, "comment_check"));
225
 
        shell_preferences->priv->duration_check =
226
 
                GTK_WIDGET (gtk_builder_get_object (builder, "duration_check"));
227
 
        shell_preferences->priv->track_check =
228
 
                GTK_WIDGET (gtk_builder_get_object (builder, "track_check"));
229
 
        shell_preferences->priv->rating_check =
230
 
                GTK_WIDGET (gtk_builder_get_object (builder, "rating_check"));
231
 
        shell_preferences->priv->play_count_check =
232
 
                GTK_WIDGET (gtk_builder_get_object (builder, "play_count_check"));
233
 
        shell_preferences->priv->last_played_check =
234
 
                GTK_WIDGET (gtk_builder_get_object (builder, "last_played_check"));
235
 
        shell_preferences->priv->quality_check =
236
 
                GTK_WIDGET (gtk_builder_get_object (builder, "quality_check"));
237
 
        shell_preferences->priv->bpm_check =
238
 
                GTK_WIDGET (gtk_builder_get_object (builder, "bpm_check"));
239
 
        shell_preferences->priv->year_check =
240
 
                GTK_WIDGET (gtk_builder_get_object (builder, "year_check"));
241
 
        shell_preferences->priv->first_seen_check =
242
 
                GTK_WIDGET (gtk_builder_get_object (builder, "first_seen_check"));
243
 
        shell_preferences->priv->location_check =
244
 
                GTK_WIDGET (gtk_builder_get_object (builder, "location_check"));
 
225
        shell_preferences->priv->column_checks = g_hash_table_new (g_str_hash, g_str_equal);
 
226
        for (i = 0; i < G_N_ELEMENTS (column_checks); i++) {
 
227
                GtkWidget *widget;
 
228
                const char *name;
 
229
 
 
230
                widget = GTK_WIDGET (gtk_builder_get_object (builder, column_checks[i].widget));
 
231
                /* XXX kind of nasty, we know rhythmdb_nice_elt_name_from_propid doesn't actually use the db */
 
232
                name = (const char *)rhythmdb_nice_elt_name_from_propid (NULL, column_checks[i].prop);
 
233
                g_assert (name != NULL);
 
234
 
 
235
                g_signal_connect_object (widget, "toggled", G_CALLBACK (column_check_toggled_cb), shell_preferences, 0);
 
236
                g_object_set_data (G_OBJECT (widget), COLUMN_CHECK_PROP_NAME, (gpointer)name);
 
237
 
 
238
                g_hash_table_insert (shell_preferences->priv->column_checks, (gpointer)name, widget);
 
239
        }
245
240
 
246
241
        /* browser options */
247
242
        rb_builder_boldify_label (builder, "browser_views_label");
255
250
                                  GTK_WIDGET (gtk_builder_get_object (builder, "general_vbox")),
256
251
                                  gtk_label_new (_("General")));
257
252
 
 
253
        g_signal_connect_object (shell_preferences->priv->source_settings,
 
254
                                 "changed",
 
255
                                 G_CALLBACK (source_settings_changed_cb),
 
256
                                 shell_preferences, 0);
 
257
        source_settings_changed_cb (shell_preferences->priv->source_settings,
 
258
                                    "visible-columns",
 
259
                                    shell_preferences);
 
260
        source_settings_changed_cb (shell_preferences->priv->source_settings,
 
261
                                    "browser-views",
 
262
                                    shell_preferences);
 
263
 
258
264
        /* toolbar button style */
259
265
        rb_builder_boldify_label (builder, "toolbar_style_label");
260
266
        shell_preferences->priv->toolbar_style_menu =
262
268
        gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (shell_preferences->priv->toolbar_style_menu),
263
269
                                              rb_combo_box_hyphen_separator_func,
264
270
                                              NULL, NULL);
265
 
        g_signal_connect_object (G_OBJECT (shell_preferences->priv->toolbar_style_menu),
266
 
                                 "changed", G_CALLBACK (rb_shell_preferences_toolbar_style_cb),
267
 
                                 shell_preferences, 0);
268
 
 
269
 
        eel_gconf_notification_add (CONF_UI_DIR,
270
 
                                    (GConfClientNotifyFunc) rb_shell_preferences_ui_pref_changed,
271
 
                                    shell_preferences);
 
271
 
 
272
        shell_preferences->priv->main_settings = g_settings_new ("org.gnome.rhythmbox");
 
273
 
 
274
        g_settings_bind_with_mapping (shell_preferences->priv->main_settings, "toolbar-style",
 
275
                                      shell_preferences->priv->toolbar_style_menu, "active",
 
276
                                      G_SETTINGS_BIND_DEFAULT,
 
277
                                      (GSettingsBindGetMapping) toolbar_style_get_map,
 
278
                                      (GSettingsBindSetMapping) toolbar_style_set_map,
 
279
                                      NULL, NULL);
272
280
 
273
281
        /* box for stuff added by plugins */
274
282
        shell_preferences->priv->general_prefs_plugin_box =
275
283
                GTK_WIDGET (gtk_builder_get_object (builder, "plugin_box"));
276
284
 
277
285
        g_object_unref (builder);
 
286
        builder = rb_builder_load ("playback-prefs.ui", shell_preferences);
278
287
 
279
288
        /* playback preferences */
280
 
        builder = rb_builder_load ("playback-prefs.ui", shell_preferences);
281
 
 
282
289
        rb_builder_boldify_label (builder, "backend_label");
283
290
        rb_builder_boldify_label (builder, "duration_label");
284
 
        rb_builder_boldify_label (builder, "buffer_size_label");
285
291
 
286
292
        shell_preferences->priv->xfade_backend_check =
287
293
                GTK_WIDGET (gtk_builder_get_object (builder, "use_xfade_backend"));
288
294
        shell_preferences->priv->transition_duration =
289
295
                GTK_WIDGET (gtk_builder_get_object (builder, "duration"));
290
 
        shell_preferences->priv->network_buffer_size =
291
 
                GTK_WIDGET (gtk_builder_get_object (builder, "network_buffer_size"));
292
296
        shell_preferences->priv->playback_prefs_plugin_box =
293
297
                GTK_WIDGET (gtk_builder_get_object (builder, "plugin_box"));
294
298
 
295
 
        g_signal_connect_object (shell_preferences->priv->xfade_backend_check,
296
 
                                 "toggled",
297
 
                                 G_CALLBACK (rb_shell_preferences_player_backend_cb),
298
 
                                 shell_preferences, 0);
299
 
 
300
 
        g_signal_connect_object (shell_preferences->priv->transition_duration,
301
 
                                 "value-changed",
302
 
                                 G_CALLBACK (rb_shell_preferences_transition_duration_cb),
303
 
                                 shell_preferences, 0);
304
 
 
305
 
        g_signal_connect_object (shell_preferences->priv->network_buffer_size,
306
 
                                 "value-changed",
307
 
                                 G_CALLBACK (rb_shell_preferences_network_buffer_size_cb),
 
299
 
 
300
        shell_preferences->priv->player_settings = g_settings_new ("org.gnome.rhythmbox.player");
 
301
        g_signal_connect_object (shell_preferences->priv->player_settings,
 
302
                                 "changed",
 
303
                                 G_CALLBACK (player_settings_changed_cb),
 
304
                                 shell_preferences, 0);
 
305
        player_settings_changed_cb (shell_preferences->priv->player_settings,
 
306
                                    "transition-time",
 
307
                                    shell_preferences);
 
308
 
 
309
 
 
310
        g_settings_bind (shell_preferences->priv->player_settings,
 
311
                         "use-xfade-backend",
 
312
                         shell_preferences->priv->xfade_backend_check,
 
313
                         "active",
 
314
                         G_SETTINGS_BIND_DEFAULT);
 
315
 
 
316
        /* unfortunately the GtkRange value can't be bound to a GSettings key.. */
 
317
        g_settings_bind (shell_preferences->priv->player_settings,
 
318
                         "use-xfade-backend",
 
319
                         shell_preferences->priv->transition_duration,
 
320
                         "sensitive",
 
321
                         G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET | G_SETTINGS_BIND_NO_SENSITIVITY);
 
322
 
 
323
        g_signal_connect_object (gtk_builder_get_object (builder, "duration"),
 
324
                                 "value-changed",
 
325
                                 G_CALLBACK (transition_time_changed_cb),
308
326
                                 shell_preferences, 0);
309
327
 
310
328
        gtk_notebook_append_page (GTK_NOTEBOOK (shell_preferences->priv->notebook),
311
329
                                  GTK_WIDGET (gtk_builder_get_object (builder, "playback_prefs_box")),
312
330
                                  gtk_label_new (_("Playback")));
313
331
        g_object_unref (builder);
314
 
 
315
 
        eel_gconf_notification_add (CONF_PLAYER_DIR,
316
 
                                    (GConfClientNotifyFunc) rb_shell_preferences_ui_pref_changed,
317
 
                                    shell_preferences);
318
 
 
319
 
        rb_shell_preferences_sync (shell_preferences);
320
 
}
321
 
 
322
 
static void
323
 
rb_shell_preferences_finalize (GObject *object)
324
 
{
325
 
        RBShellPreferences *shell_preferences;
326
 
 
327
 
        g_return_if_fail (object != NULL);
328
 
        g_return_if_fail (RB_IS_SHELL_PREFERENCES (object));
329
 
 
330
 
        shell_preferences = RB_SHELL_PREFERENCES (object);
331
 
 
332
 
        g_return_if_fail (shell_preferences->priv != NULL);
 
332
}
 
333
 
 
334
static void
 
335
impl_dispose (GObject *object)
 
336
{
 
337
        RBShellPreferences *shell_preferences = RB_SHELL_PREFERENCES (object);
 
338
 
 
339
        if (shell_preferences->priv->main_settings != NULL) {
 
340
                g_object_unref (shell_preferences->priv->main_settings);
 
341
                shell_preferences->priv->main_settings = NULL;
 
342
        }
 
343
 
 
344
        if (shell_preferences->priv->source_settings != NULL) {
 
345
                g_object_unref (shell_preferences->priv->source_settings);
 
346
                shell_preferences->priv->source_settings = NULL;
 
347
        }
 
348
 
 
349
        if (shell_preferences->priv->player_settings != NULL) {
 
350
                rb_settings_delayed_sync (shell_preferences->priv->player_settings, NULL, NULL, NULL);
 
351
                g_object_unref (shell_preferences->priv->player_settings);
 
352
                shell_preferences->priv->player_settings = NULL;
 
353
        }
 
354
 
 
355
        G_OBJECT_CLASS (rb_shell_preferences_parent_class)->dispose (object);
 
356
}
 
357
 
 
358
static void
 
359
impl_finalize (GObject *object)
 
360
{
 
361
        /*RBShellPreferences *shell_preferences = RB_SHELL_PREFERENCES (object);*/
 
362
 
 
363
        /* anything to do here? */
333
364
 
334
365
        G_OBJECT_CLASS (rb_shell_preferences_parent_class)->finalize (object);
335
366
}
430
461
}
431
462
 
432
463
static void
433
 
rb_shell_preferences_ui_pref_changed (GConfClient *client,
434
 
                                      guint cnxn_id,
435
 
                                      GConfEntry *entry,
436
 
                                      RBShellPreferences *shell_preferences)
437
 
{
438
 
        if (shell_preferences->priv->loading == TRUE)
439
 
                return;
440
 
 
441
 
        rb_shell_preferences_sync (shell_preferences);
442
 
}
443
 
 
444
 
/**
445
 
 * rb_shell_preferences_column_check_changed_cb:
446
 
 * @butt: the #GtkCheckButton that was changed
447
 
 * @shell_preferences: the #RBShellPreferences instance
448
 
 *
449
 
 * Signal handler used for the checkboxes used to configure the set of visible columns.
450
 
 * This updates the GConf key that contains the list of visible columns.
451
 
 */
452
 
void
453
 
rb_shell_preferences_column_check_changed_cb (GtkCheckButton *butt,
454
 
                                              RBShellPreferences *shell_preferences)
455
 
{
456
 
        GString *newcolumns = g_string_new ("");
457
 
        char *currentcols = eel_gconf_get_string (CONF_UI_COLUMNS_SETUP);
458
 
        char **colnames = currentcols ? g_strsplit (currentcols, ",", 0) : NULL;
459
 
        char *colname = NULL;
460
 
        int i;
461
 
 
462
 
        if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->artist_check))
463
 
                colname = "RHYTHMDB_PROP_ARTIST";
464
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->album_check))
465
 
                colname = "RHYTHMDB_PROP_ALBUM";
466
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->genre_check))
467
 
                colname = "RHYTHMDB_PROP_GENRE";
468
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->comment_check))
469
 
                colname = "RHYTHMDB_PROP_COMMENT";
470
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->duration_check))
471
 
                colname = "RHYTHMDB_PROP_DURATION";
472
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->track_check))
473
 
                colname = "RHYTHMDB_PROP_TRACK_NUMBER";
474
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->rating_check))
475
 
                colname = "RHYTHMDB_PROP_RATING";
476
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->play_count_check))
477
 
                colname = "RHYTHMDB_PROP_PLAY_COUNT";
478
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->last_played_check))
479
 
                colname = "RHYTHMDB_PROP_LAST_PLAYED";
480
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->year_check))
481
 
                colname = "RHYTHMDB_PROP_DATE";
482
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->bpm_check))
483
 
                colname = "RHYTHMDB_PROP_BPM";
484
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->quality_check))
485
 
                colname = "RHYTHMDB_PROP_BITRATE";
486
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->first_seen_check))
487
 
                colname = "RHYTHMDB_PROP_FIRST_SEEN";
488
 
        else if (butt == GTK_CHECK_BUTTON (shell_preferences->priv->location_check))
489
 
                colname = "RHYTHMDB_PROP_LOCATION";
490
 
        else
491
 
                g_assert_not_reached ();
492
 
 
493
 
        rb_debug ("\"%s\" changed, current cols are \"%s\"", colname, currentcols);
494
 
 
495
 
        /* Append this if we want it */
496
 
        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (butt))) {
497
 
                g_string_append (newcolumns, colname);
498
 
                g_string_append (newcolumns, ",");
499
 
        }
500
 
 
501
 
        /* Append everything else */
502
 
        for (i = 0; colnames != NULL && colnames[i] != NULL; i++) {
503
 
                if (strcmp (colnames[i], colname)) {
504
 
                        g_string_append (newcolumns, colnames[i]);
505
 
                        if (colnames[i+1] != NULL)
506
 
                                g_string_append (newcolumns, ",");
 
464
column_check_toggled_cb (GtkWidget *widget, RBShellPreferences *preferences)
 
465
{
 
466
        const char *prop_name;
 
467
        const char *column;
 
468
        GVariantBuilder *b;
 
469
        GVariantIter *iter;
 
470
        GVariant *v;
 
471
 
 
472
        prop_name = (const char *)g_object_get_data (G_OBJECT (widget), COLUMN_CHECK_PROP_NAME);
 
473
        g_assert (prop_name);
 
474
 
 
475
        v = g_settings_get_value (preferences->priv->source_settings, "visible-columns");
 
476
 
 
477
        /* remove from current column list */
 
478
        b = g_variant_builder_new (G_VARIANT_TYPE ("as"));
 
479
        iter = g_variant_iter_new (v);
 
480
        while (g_variant_iter_loop (iter, "s", &column)) {
 
481
                if (g_strcmp0 (column, prop_name) != 0) {
 
482
                        g_variant_builder_add (b, "s", column);
507
483
                }
508
484
        }
509
 
 
510
 
        eel_gconf_set_string (CONF_UI_COLUMNS_SETUP, newcolumns->str);
511
 
        g_string_free (newcolumns, TRUE);
512
 
}
513
 
 
514
 
static void
515
 
rb_shell_preferences_sync_column_button (RBShellPreferences *preferences,
516
 
                                         GtkWidget *button,
517
 
                                         const char *columns,
518
 
                                         const char *propid)
519
 
{
520
 
        g_signal_handlers_block_by_func (G_OBJECT (button),
521
 
                                         rb_shell_preferences_column_check_changed_cb,
522
 
                                         preferences);
523
 
 
524
 
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
525
 
                                      strstr (columns, propid) != NULL);
526
 
 
527
 
        g_signal_handlers_unblock_by_func (G_OBJECT (button),
528
 
                                           rb_shell_preferences_column_check_changed_cb,
529
 
                                           preferences);
530
 
}
531
 
 
532
 
static void
533
 
rb_shell_preferences_sync (RBShellPreferences *shell_preferences)
534
 
{
535
 
        char *columns;
536
 
        GSList  *l;
537
 
        gint view, i;
538
 
        gboolean b;
539
 
        float duration;
540
 
        int buffer_size;
541
 
 
542
 
        shell_preferences->priv->loading = TRUE;
543
 
 
544
 
        rb_debug ("syncing prefs");
545
 
 
546
 
        columns = eel_gconf_get_string (CONF_UI_COLUMNS_SETUP);
547
 
        if (columns != NULL)
548
 
        {
549
 
                rb_shell_preferences_sync_column_button (shell_preferences,
550
 
                                                         shell_preferences->priv->artist_check,
551
 
                                                         columns, "RHYTHMDB_PROP_ARTIST");
552
 
                rb_shell_preferences_sync_column_button (shell_preferences,
553
 
                                                         shell_preferences->priv->album_check,
554
 
                                                         columns, "RHYTHMDB_PROP_ALBUM");
555
 
                rb_shell_preferences_sync_column_button (shell_preferences,
556
 
                                                         shell_preferences->priv->genre_check,
557
 
                                                         columns, "RHYTHMDB_PROP_GENRE");
558
 
                rb_shell_preferences_sync_column_button (shell_preferences,
559
 
                                                         shell_preferences->priv->comment_check,
560
 
                                                         columns, "RHYTHMDB_PROP_COMMENT");
561
 
                rb_shell_preferences_sync_column_button (shell_preferences,
562
 
                                                         shell_preferences->priv->duration_check,
563
 
                                                         columns, "RHYTHMDB_PROP_DURATION");
564
 
                rb_shell_preferences_sync_column_button (shell_preferences,
565
 
                                                         shell_preferences->priv->track_check,
566
 
                                                         columns, "RHYTHMDB_PROP_TRACK_NUMBER");
567
 
                rb_shell_preferences_sync_column_button (shell_preferences,
568
 
                                                         shell_preferences->priv->rating_check,
569
 
                                                         columns, "RHYTHMDB_PROP_RATING");
570
 
                rb_shell_preferences_sync_column_button (shell_preferences,
571
 
                                                         shell_preferences->priv->play_count_check,
572
 
                                                         columns, "RHYTHMDB_PROP_PLAY_COUNT");
573
 
                rb_shell_preferences_sync_column_button (shell_preferences,
574
 
                                                         shell_preferences->priv->last_played_check,
575
 
                                                         columns, "RHYTHMDB_PROP_LAST_PLAYED");
576
 
                rb_shell_preferences_sync_column_button (shell_preferences,
577
 
                                                         shell_preferences->priv->year_check,
578
 
                                                         columns, "RHYTHMDB_PROP_DATE");
579
 
                rb_shell_preferences_sync_column_button (shell_preferences,
580
 
                                                         shell_preferences->priv->first_seen_check,
581
 
                                                         columns, "RHYTHMDB_PROP_FIRST_SEEN");
582
 
                rb_shell_preferences_sync_column_button (shell_preferences,
583
 
                                                         shell_preferences->priv->quality_check,
584
 
                                                         columns, "RHYTHMDB_PROP_BITRATE");
585
 
                rb_shell_preferences_sync_column_button (shell_preferences,
586
 
                                                         shell_preferences->priv->bpm_check,
587
 
                                                         columns, "RHYTHMDB_PROP_BPM");
588
 
                rb_shell_preferences_sync_column_button (shell_preferences,
589
 
                                                         shell_preferences->priv->location_check,
590
 
                                                         columns, "RHYTHMDB_PROP_LOCATION");
 
485
        g_variant_unref (v);
 
486
 
 
487
        /* if enabled, add it */
 
488
        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) {
 
489
                g_variant_builder_add (b, "s", prop_name);
591
490
        }
592
491
 
593
 
        g_free (columns);
594
 
 
595
 
        view = eel_gconf_get_integer (CONF_UI_BROWSER_VIEWS);
596
 
        for (l = shell_preferences->priv->browser_views_group, i = 0; l != NULL; l = g_slist_next (l), i++)
597
 
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l->data), (i == view));
598
 
 
599
 
        /* toolbar style */
600
 
        g_signal_handlers_block_by_func (G_OBJECT (shell_preferences->priv->toolbar_style_menu),
601
 
                                         G_CALLBACK (rb_shell_preferences_toolbar_style_cb),
602
 
                                         shell_preferences);
603
 
 
604
 
        view = eel_gconf_get_integer (CONF_UI_TOOLBAR_STYLE);
605
 
        /* skip the separator row */
606
 
        if (view >= 1)
607
 
                view++;
608
 
        gtk_combo_box_set_active (GTK_COMBO_BOX (shell_preferences->priv->toolbar_style_menu), view);
609
 
 
610
 
        g_signal_handlers_unblock_by_func (G_OBJECT (shell_preferences->priv->toolbar_style_menu),
611
 
                                           G_CALLBACK (rb_shell_preferences_toolbar_style_cb),
612
 
                                           shell_preferences);
613
 
 
614
 
        /* player preferences */
615
 
        b = eel_gconf_get_boolean (CONF_PLAYER_USE_XFADE_BACKEND);
616
 
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (shell_preferences->priv->xfade_backend_check), b);
617
 
 
618
 
        duration = eel_gconf_get_float (CONF_PLAYER_TRANSITION_TIME);
619
 
        gtk_range_set_value (GTK_RANGE (shell_preferences->priv->transition_duration), duration);
620
 
 
621
 
        buffer_size = eel_gconf_get_integer (CONF_PLAYER_NETWORK_BUFFER_SIZE);
622
 
        gtk_range_set_value (GTK_RANGE (shell_preferences->priv->network_buffer_size), buffer_size);
623
 
 
624
 
        update_playback_prefs_sensitivity (shell_preferences);
625
 
 
626
 
        shell_preferences->priv->loading = FALSE;
627
 
}
628
 
 
629
 
static void
630
 
rb_shell_preferences_toolbar_style_cb (GtkComboBox *box, RBShellPreferences *preferences)
631
 
{
632
 
        int selection;
633
 
 
634
 
        selection = gtk_combo_box_get_active (box);
635
 
 
636
 
        /* skip the separator row */
637
 
        if (selection >= 1)
638
 
                selection--;
639
 
 
640
 
        eel_gconf_set_integer (CONF_UI_TOOLBAR_STYLE, selection);
 
492
        v = g_variant_builder_end (b);
 
493
 
 
494
        g_settings_set_value (preferences->priv->source_settings, "visible-columns", v);
 
495
 
 
496
        g_variant_unref (v);
 
497
        g_variant_builder_unref (b);
 
498
}
 
499
 
 
500
static GVariant *
 
501
toolbar_style_set_map (const GValue *value,
 
502
                       const GVariantType *expected_type,
 
503
                       gpointer data)
 
504
{
 
505
        int index = g_value_get_int (value);
 
506
 
 
507
        /* ignore the separator row */
 
508
        if (index >= 1)
 
509
                index--;
 
510
 
 
511
        return g_variant_new_int32 (index);
 
512
}
 
513
 
 
514
static gboolean
 
515
toolbar_style_get_map (GValue *value, GVariant *variant, gpointer data)
 
516
{
 
517
        int index = g_variant_get_int32 (variant);
 
518
 
 
519
        /* skip the separator row */
 
520
        if (index >= 1)
 
521
                index++;
 
522
 
 
523
        g_value_set_int (value, index);
 
524
        return TRUE;
641
525
}
642
526
 
643
527
/**
654
538
{
655
539
        int index;
656
540
 
657
 
        if (shell_preferences->priv->loading)
 
541
        if (shell_preferences->priv->applying_settings)
658
542
                return;
659
543
 
660
544
        index = g_slist_index (shell_preferences->priv->browser_views_group, widget);
661
545
 
662
 
        eel_gconf_set_integer (CONF_UI_BROWSER_VIEWS, index);
663
 
}
664
 
 
665
 
static void
666
 
update_playback_prefs_sensitivity (RBShellPreferences *preferences)
667
 
{
668
 
        gboolean backend;
669
 
 
670
 
        backend = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (preferences->priv->xfade_backend_check));
671
 
 
672
 
        gtk_widget_set_sensitive (preferences->priv->transition_duration, backend);
673
 
}
674
 
 
675
 
static void
676
 
rb_shell_preferences_player_backend_cb (GtkToggleButton *button,
677
 
                                        RBShellPreferences *preferences)
678
 
{
679
 
        update_playback_prefs_sensitivity (preferences);
680
 
 
681
 
        eel_gconf_set_boolean (CONF_PLAYER_USE_XFADE_BACKEND,
682
 
                               gtk_toggle_button_get_active (button));
683
 
}
684
 
 
685
 
static void
686
 
rb_shell_preferences_transition_duration_cb (GtkRange *range,
687
 
                                             RBShellPreferences *preferences)
688
 
{
689
 
        gdouble v;
690
 
 
691
 
        v = gtk_range_get_value (range);
692
 
        eel_gconf_set_float (CONF_PLAYER_TRANSITION_TIME, (float)v);
693
 
}
694
 
 
695
 
static void
696
 
rb_shell_preferences_network_buffer_size_cb (GtkRange *range,
697
 
                                             RBShellPreferences *preferences)
698
 
{
699
 
        gdouble v;
700
 
 
701
 
        v = gtk_range_get_value (range);
702
 
        eel_gconf_set_integer (CONF_PLAYER_NETWORK_BUFFER_SIZE, (int)v);
 
546
        g_settings_set_enum (shell_preferences->priv->source_settings, "browser-views", index);
 
547
}
 
548
 
 
549
static void
 
550
source_settings_changed_cb (GSettings *settings, const char *key, RBShellPreferences *preferences)
 
551
{
 
552
        if (g_strcmp0 (key, "browser-views") == 0) {
 
553
                int view;
 
554
                GtkWidget *widget;
 
555
 
 
556
                view = g_settings_get_enum (preferences->priv->source_settings, "browser-views");
 
557
                widget = GTK_WIDGET (g_slist_nth_data (preferences->priv->browser_views_group, view));
 
558
                preferences->priv->applying_settings = TRUE;
 
559
                gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
 
560
                preferences->priv->applying_settings = FALSE;
 
561
 
 
562
        } else if (g_strcmp0 (key, "visible-columns") == 0) {
 
563
                char **columns;
 
564
                GHashTableIter iter;
 
565
                gpointer name_ptr;
 
566
                gpointer widget_ptr;
 
567
 
 
568
                columns = g_settings_get_strv (preferences->priv->source_settings, "visible-columns");
 
569
 
 
570
                g_hash_table_iter_init (&iter, preferences->priv->column_checks);
 
571
                while (g_hash_table_iter_next (&iter, &name_ptr, &widget_ptr)) {
 
572
                        gboolean enabled;
 
573
 
 
574
                        enabled = rb_str_in_strv (name_ptr, (const char **)columns);
 
575
                        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget_ptr), enabled);
 
576
                }
 
577
 
 
578
                g_strfreev (columns);
 
579
        }
 
580
}
 
581
 
 
582
static void
 
583
player_settings_changed_cb (GSettings *settings, const char *key, RBShellPreferences *preferences)
 
584
{
 
585
        if (g_strcmp0 (key, "transition-time") == 0) {
 
586
                gtk_range_set_value (GTK_RANGE (preferences->priv->transition_duration),
 
587
                                     g_settings_get_double (settings, key));
 
588
        }
 
589
}
 
590
 
 
591
static void
 
592
sync_transition_time (GSettings *settings, GtkRange *range)
 
593
{
 
594
        g_settings_set_double (settings,
 
595
                               "transition-time",
 
596
                               gtk_range_get_value (range));
 
597
}
 
598
 
 
599
static void
 
600
transition_time_changed_cb (GtkRange *range, RBShellPreferences *preferences)
 
601
{
 
602
        rb_settings_delayed_sync (preferences->priv->player_settings,
 
603
                                  (RBDelayedSyncFunc) sync_transition_time,
 
604
                                  g_object_ref (range),
 
605
                                  g_object_unref);
703
606
}
704
607
 
705
608
static GtkWidget *