« back to all changes in this revision
Viewing changes to src/options.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Adam Cécile (Le_Vert)
- Date: 2007-03-10 16:07:32 UTC
- Revision ID: james.westby@ubuntu.com-20070310160732-6hkwtb2d1h9sx6nr
Tags: upstream-0.9~beta7.1
Import upstream version 0.9~beta7.1
- files added:
- doc
- skin
- skin/dark
- skin/default
- skin/metal
- skin/ocean
- skin/plain
- skin/woody
- src
- src/decoder
- src/encoder
- src/img
- src/po
added
removed
src/options.c
1
/* -*- linux-c -*-
2
Copyright (C) 2004 Tom Szilagyi
3
4
This program is free software; you can redistribute it and/or modify
5
it under the terms of the GNU General Public License as published by
6
the Free Software Foundation; either version 2 of the License, or
7
(at your option) any later version.
8
9
This program is distributed in the hope that it will be useful,
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
GNU General Public License for more details.
13
14
You should have received a copy of the GNU General Public License
15
along with this program; if not, write to the Free Software
16
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17
18
$Id: options.c 583 2007-02-10 16:36:41Z peterszilagyi $
19
*/
20
21
#include <config.h>
22
23
#include <gtk/gtk.h>
24
#include <gdk/gdkkeysyms.h>
25
#include <stdio.h>
26
#include <stdlib.h>
27
#include <string.h>
28
#include <unistd.h>
29
#include <sys/stat.h>
30
#include <libxml/xmlmemory.h>
31
#include <libxml/parser.h>
32
33
#ifdef HAVE_CDDA
34
#ifdef HAVE_CDDB
35
#define _TMP_HAVE_CDDB 1
36
#undef HAVE_CDDB
37
#endif /* HAVE_CDDB */
38
#include <cdio/cdio.h>
39
#include <cdio/paranoia.h>
40
#ifdef HAVE_CDDB
41
#undef HAVE_CDDB
42
#endif /* HAVE_CDDB */
43
#ifdef _TMP_HAVE_CDDB
44
#define HAVE_CDDB 1
45
#undef _TMP_HAVE_CDDB
46
#endif /* _TMP_HAVE_CDDB */
47
#endif /* HAVE_CDDA */
48
49
#ifdef HAVE_SRC
50
#include <samplerate.h>
51
#endif /* HAVE_SRC */
52
53
#include "common.h"
54
#include "gui_main.h"
55
#include "music_browser.h"
56
#include "search.h"
57
#include "playlist.h"
58
#include "i18n.h"
59
#include "options.h"
60
61
62
options_t options;
63
64
static int current_notebook_page = 0;
65
66
extern int src_type_parsed;
67
68
extern GtkWidget * main_window;
69
extern GtkWidget * playlist_window;
70
extern GtkWidget * play_button;
71
extern GtkTooltips * aqualung_tooltips;
72
73
extern PangoFontDescription *fd_playlist;
74
extern PangoFontDescription *fd_browser;
75
extern PangoFontDescription *fd_bigtimer;
76
extern PangoFontDescription *fd_smalltimer;
77
extern PangoFontDescription *fd_songtitle;
78
extern PangoFontDescription *fd_songinfo;
79
extern PangoFontDescription *fd_statusbar;
80
81
extern GtkWidget * bigtimer_label;
82
extern GtkWidget * smalltimer_label_1;
83
extern GtkWidget * smalltimer_label_2;
84
85
extern GtkWidget * label_title;
86
extern GtkWidget * label_format;
87
extern GtkWidget * label_samplerate;
88
extern GtkWidget * label_bps;
89
extern GtkWidget * label_mono;
90
extern GtkWidget * label_output;
91
extern GtkWidget * label_src_type;
92
93
extern GtkWidget * statusbar_total;
94
extern GtkWidget * statusbar_total_label;
95
extern GtkWidget * statusbar_selected;
96
extern GtkWidget * statusbar_selected_label;
97
98
extern GtkWidget * statusbar_ms;
99
100
extern int music_store_changed;
101
102
extern GtkWidget * music_tree;
103
extern GtkTreeStore * music_store;
104
105
extern GtkWidget * play_list;
106
extern GtkTreeViewColumn * track_column;
107
extern GtkTreeViewColumn * rva_column;
108
extern GtkTreeViewColumn * length_column;
109
110
extern GtkListStore * play_store;
111
112
extern GtkWidget* gui_stock_label_button(gchar *blabel, const gchar *bstock);
113
extern void disable_bold_font_in_playlist(void);
114
extern void playlist_selection_changed(GtkTreeSelection * sel, gpointer data);
115
extern void set_buttons_relief(void);
116
extern void show_active_position_in_playlist(void);
117
118
int rva_is_enabled_shadow;
119
int rva_env_shadow;
120
float rva_refvol_shadow;
121
float rva_steepness_shadow;
122
int rva_use_averaging_shadow;
123
int rva_use_linear_thresh_shadow;
124
float rva_avg_linear_thresh_shadow;
125
float rva_avg_stddev_thresh_shadow;
126
127
int appearance_changed;
128
int reskin_flag;
129
int restart_flag;
130
int override_shadow;
131
int track_name_in_bold_shadow;
132
133
GtkWidget * options_window;
134
GtkWidget * notebook;
135
136
GtkWidget * entry_title;
137
GtkWidget * entry_param;
138
GtkWidget * check_enable_tooltips;
139
GtkWidget * check_buttons_at_the_bottom;
140
GtkWidget * check_disable_buttons_relief;
141
GtkWidget * check_main_window_always_on_top;
142
GtkWidget * check_simple_view_in_fx;
143
GtkWidget * check_united_minimization;
144
GtkWidget * check_show_sn_title;
145
GtkWidget * check_show_hidden;
146
GtkWidget * check_tags_tab_first;
147
148
GtkWidget * check_playlist_is_embedded;
149
GtkWidget * check_autoplsave;
150
GtkWidget * check_playlist_is_tree;
151
GtkWidget * check_album_shuffle_mode;
152
GtkWidget * check_enable_playlist_statusbar;
153
GtkWidget * check_pl_statusbar_show_size;
154
GtkWidget * check_show_rva_in_playlist;
155
GtkWidget * check_show_length_in_playlist;
156
GtkWidget * check_show_active_track_name_in_bold;
157
GtkWidget * check_enable_pl_rules_hint;
158
GtkListStore * plistcol_store;
159
160
GtkWidget * check_hide_comment_pane;
161
GtkWidget * check_enable_mstore_toolbar;
162
GtkWidget * check_enable_mstore_statusbar;
163
GtkWidget * check_ms_statusbar_show_size;
164
GtkWidget * check_expand_stores;
165
GtkWidget * check_enable_ms_rules_hint;
166
GtkWidget * check_enable_ms_tree_icons;
167
GtkWidget * combo_cwidth;
168
GtkWidget * check_magnify_smaller_images;
169
GtkListStore * ms_pathlist_store = NULL;
170
GtkTreeSelection * ms_pathlist_select;
171
GtkWidget * entry_ms_pathlist;
172
173
#ifdef HAVE_LADSPA
174
GtkWidget * combo_ladspa;
175
#endif /* HAVE_LADSPA */
176
#ifdef HAVE_SRC
177
GtkWidget * combo_src;
178
#endif /* HAVE_SRC */
179
GtkWidget * label_src;
180
181
GtkWidget * check_rva_is_enabled;
182
GtkWidget * rva_drawing_area;
183
GdkPixmap * rva_pixmap = NULL;
184
GtkWidget * rva_viewport;
185
GtkWidget * combo_listening_env;
186
GtkWidget * spin_refvol;
187
GtkWidget * spin_steepness;
188
GtkWidget * check_rva_use_averaging;
189
GtkWidget * combo_threshold;
190
GtkWidget * spin_linthresh;
191
GtkWidget * spin_stdthresh;
192
GtkObject * adj_refvol;
193
GtkObject * adj_steepness;
194
GtkObject * adj_linthresh;
195
GtkObject * adj_stdthresh;
196
GtkWidget * label_listening_env;
197
GtkWidget * label_refvol;
198
GtkWidget * label_steepness;
199
GtkWidget * label_threshold;
200
GtkWidget * label_linthresh;
201
GtkWidget * label_stdthresh;
202
203
GtkWidget * check_auto_use_meta_artist;
204
GtkWidget * check_auto_use_meta_record;
205
GtkWidget * check_auto_use_meta_track;
206
GtkWidget * check_auto_use_ext_meta_artist;
207
GtkWidget * check_auto_use_ext_meta_record;
208
GtkWidget * check_auto_use_ext_meta_track;
209
GtkWidget * combo_replaygain;
210
211
#ifdef HAVE_CDDA
212
GtkWidget * cdda_drive_speed_spinner;
213
GtkWidget * check_cdda_mode_overlap;
214
GtkWidget * check_cdda_mode_verify;
215
GtkWidget * check_cdda_mode_neverskip;
216
GtkWidget * check_cdda_force_drive_rescan;
217
GtkWidget * check_cdda_add_to_playlist;
218
GtkWidget * check_cdda_remove_from_playlist;
219
GtkWidget * label_cdda_maxretries;
220
GtkWidget * cdda_paranoia_maxretries_spinner;
221
#endif /* HAVE_CDDA */
222
223
#ifdef HAVE_CDDB
224
GtkWidget * cddb_server_entry;
225
GtkWidget * cddb_tout_spinner;
226
GtkWidget * cddb_email_entry;
227
GtkWidget * cddb_local_entry;
228
GtkWidget * cddb_local_check;
229
GtkWidget * cddb_radio_direct;
230
GtkWidget * cddb_radio_proxy;
231
GtkWidget * cddb_proto_combo;
232
GtkWidget * cddb_proxy_entry;
233
GtkWidget * cddb_proxy_port_spinner;
234
GtkWidget * cddb_label_proto;
235
GtkWidget * cddb_label_proxy;
236
GtkWidget * cddb_label_proxy_port;
237
#endif /* HAVE_CDDB */
238
239
GtkWidget * check_override_skin;
240
241
#define DEFAULT_FONT_NAME "Sans 11"
242
243
GtkWidget * entry_pl_font;
244
GtkWidget * entry_ms_font;
245
GtkWidget * entry_bt_font;
246
GtkWidget * entry_st_font;
247
GtkWidget * entry_songt_font;
248
GtkWidget * entry_si_font;
249
GtkWidget * entry_sb_font;
250
GtkWidget * button_pl_font;
251
GtkWidget * button_ms_font;
252
GtkWidget * button_bt_font;
253
GtkWidget * button_st_font;
254
GtkWidget * button_songt_font;
255
GtkWidget * button_si_font;
256
GtkWidget * button_sb_font;
257
258
GdkColor color;
259
GtkWidget * color_picker;
260
261
void draw_rva_diagram(void);
262
void show_restart_info(void);
263
264
GtkListStore * restart_list_store = NULL;
265
266
267
void
268
open_font_desc(void) {
269
270
if (fd_playlist) pango_font_description_free(fd_playlist);
271
fd_playlist = pango_font_description_from_string(options.playlist_font);
272
if (fd_browser) pango_font_description_free(fd_browser);
273
fd_browser = pango_font_description_from_string(options.browser_font);
274
if (fd_bigtimer) pango_font_description_free(fd_bigtimer);
275
fd_bigtimer = pango_font_description_from_string(options.bigtimer_font);
276
if (fd_smalltimer) pango_font_description_free(fd_smalltimer);
277
fd_smalltimer = pango_font_description_from_string(options.smalltimer_font);
278
if (fd_songtitle) pango_font_description_free(fd_songtitle);
279
fd_songtitle = pango_font_description_from_string(options.songtitle_font);
280
if (fd_songinfo) pango_font_description_free(fd_songinfo);
281
fd_songinfo = pango_font_description_from_string(options.songinfo_font);
282
if (fd_statusbar) pango_font_description_free(fd_statusbar);
283
fd_statusbar = pango_font_description_from_string(options.statusbar_font);
284
}
285
286
void
287
set_option_from_toggle(GtkWidget * widget, int * opt) {
288
289
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
290
*opt = 1;
291
} else {
292
*opt = 0;
293
}
294
}
295
296
void
297
set_option_from_combo(GtkWidget * widget, int * opt) {
298
299
*opt = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
300
}
301
302
void
303
set_option_from_spin(GtkWidget * widget, int * opt) {
304
305
*opt = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
306
}
307
308
void
309
set_option_from_entry(GtkWidget * widget, char * opt) {
310
311
strncpy(opt, gtk_entry_get_text(GTK_ENTRY(widget)), MAXLEN-1);
312
}
313
void
314
options_window_accept(void) {
315
316
int i;
317
int n;
318
int n_prev = 3;
319
GtkTreeIter iter;
320
GtkTreeIter iter2;
321
322
323
if (restart_flag) {
324
show_restart_info();
325
}
326
327
328
/* General */
329
330
strncpy(options.title_format, gtk_entry_get_text(GTK_ENTRY(entry_title)), MAXLEN - 1);
331
strncpy(options.default_param, gtk_entry_get_text(GTK_ENTRY(entry_param)), MAXLEN - 1);
332
333
set_option_from_toggle(check_enable_tooltips, &options.enable_tooltips);
334
if (options.enable_tooltips) {
335
gtk_tooltips_enable(aqualung_tooltips);
336
} else {
337
gtk_tooltips_disable(aqualung_tooltips);
338
}
339
340
set_option_from_toggle(check_buttons_at_the_bottom, &options.buttons_at_the_bottom_shadow);
341
set_option_from_toggle(check_disable_buttons_relief, &options.disable_buttons_relief);
342
set_option_from_toggle(check_main_window_always_on_top, &options.main_window_always_on_top);
343
344
#ifdef HAVE_LADSPA
345
set_option_from_toggle(check_simple_view_in_fx, &options.simple_view_in_fx_shadow);
346
#endif /* HAVE_LADSPA */
347
set_option_from_toggle(check_united_minimization, &options.united_minimization);
348
set_option_from_toggle(check_show_sn_title, &options.show_sn_title);
349
set_option_from_toggle(check_show_hidden, &options.show_hidden);
350
set_option_from_toggle(check_tags_tab_first, &options.tags_tab_first);
351
352
353
/* Playlist */
354
355
set_option_from_toggle(check_autoplsave, &options.auto_save_playlist);
356
set_option_from_toggle(check_playlist_is_embedded, &options.playlist_is_embedded_shadow);
357
set_option_from_toggle(check_playlist_is_tree, &options.playlist_is_tree);
358
set_option_from_toggle(check_album_shuffle_mode, &options.album_shuffle_mode);
359
set_option_from_toggle(check_enable_playlist_statusbar, &options.enable_playlist_statusbar_shadow);
360
set_option_from_toggle(check_pl_statusbar_show_size, &options.pl_statusbar_show_size);
361
set_option_from_toggle(check_show_rva_in_playlist, &options.show_rva_in_playlist);
362
gtk_tree_view_column_set_visible(GTK_TREE_VIEW_COLUMN(rva_column),
363
options.show_rva_in_playlist);
364
set_option_from_toggle(check_show_length_in_playlist, &options.show_length_in_playlist);
365
gtk_tree_view_column_set_visible(GTK_TREE_VIEW_COLUMN(length_column),
366
options.show_length_in_playlist);
367
set_option_from_toggle(check_show_active_track_name_in_bold, &options.show_active_track_name_in_bold);
368
if (!options.show_active_track_name_in_bold) {
369
disable_bold_font_in_playlist();
370
}
371
372
set_option_from_toggle(check_enable_pl_rules_hint, &options.enable_pl_rules_hint);
373
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(play_list), options.enable_pl_rules_hint);
374
375
376
/* Music Store */
377
378
set_option_from_toggle(check_hide_comment_pane, &options.hide_comment_pane_shadow);
379
380
381
set_option_from_toggle(check_enable_mstore_toolbar, &options.enable_mstore_toolbar_shadow);
382
set_option_from_toggle(check_enable_mstore_statusbar, &options.enable_mstore_statusbar_shadow);
383
set_option_from_toggle(check_ms_statusbar_show_size, &options.ms_statusbar_show_size);
384
set_option_from_toggle(check_expand_stores, &options.autoexpand_stores);
385
386
set_option_from_toggle(check_enable_ms_rules_hint, &options.enable_ms_rules_hint);
387
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(music_tree), options.enable_ms_rules_hint);
388
389
set_option_from_toggle(check_enable_ms_tree_icons, &options.enable_ms_tree_icons_shadow);
390
391
set_option_from_combo(combo_cwidth, &options.cover_width);
392
set_option_from_toggle(check_magnify_smaller_images, &options.magnify_smaller_images);
393
394
395
/* RVA */
396
397
options.rva_is_enabled = rva_is_enabled_shadow;
398
options.rva_env = rva_env_shadow;
399
options.rva_refvol = rva_refvol_shadow;
400
options.rva_steepness = rva_steepness_shadow;
401
options.rva_use_averaging = rva_use_averaging_shadow;
402
options.rva_use_linear_thresh = rva_use_linear_thresh_shadow;
403
options.rva_avg_linear_thresh = rva_avg_linear_thresh_shadow;
404
options.rva_avg_stddev_thresh = rva_avg_stddev_thresh_shadow;
405
406
407
/* Metadata */
408
409
set_option_from_toggle(check_auto_use_meta_artist, &options.auto_use_meta_artist);
410
set_option_from_toggle(check_auto_use_meta_record, &options.auto_use_meta_record);
411
set_option_from_toggle(check_auto_use_meta_track, &options.auto_use_meta_track);
412
413
414
set_option_from_toggle(check_auto_use_ext_meta_artist, &options.auto_use_ext_meta_artist);
415
set_option_from_toggle(check_auto_use_ext_meta_record, &options.auto_use_ext_meta_record);
416
set_option_from_toggle(check_auto_use_ext_meta_track, &options.auto_use_ext_meta_track);
417
418
set_option_from_combo(combo_replaygain, &options.replaygain_tag_to_use);
419
420
421
/* CDDA */
422
#ifdef HAVE_CDDA
423
set_option_from_spin(cdda_drive_speed_spinner, &options.cdda_drive_speed);
424
options.cdda_paranoia_mode =
425
(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_cdda_mode_overlap)) ? PARANOIA_MODE_OVERLAP : 0) |
426
(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_cdda_mode_verify)) ? PARANOIA_MODE_VERIFY : 0) |
427
(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_cdda_mode_neverskip)) ? PARANOIA_MODE_NEVERSKIP : 0);
428
set_option_from_spin(cdda_paranoia_maxretries_spinner, &options.cdda_paranoia_maxretries);
429
set_option_from_toggle(check_cdda_force_drive_rescan, &options.cdda_force_drive_rescan);
430
set_option_from_toggle(check_cdda_add_to_playlist, &options.cdda_add_to_playlist);
431
set_option_from_toggle(check_cdda_remove_from_playlist, &options.cdda_remove_from_playlist);
432
#endif /* HAVE_CDDA */
433
434
435
/* CDDB */
436
#ifdef HAVE_CDDB
437
set_option_from_entry(cddb_server_entry, options.cddb_server);
438
set_option_from_spin(cddb_tout_spinner, &options.cddb_timeout);
439
set_option_from_entry(cddb_email_entry, options.cddb_email);
440
set_option_from_entry(cddb_local_entry, options.cddb_local);
441
set_option_from_toggle(cddb_local_check, &options.cddb_cache_only);
442
set_option_from_toggle(cddb_radio_proxy, &options.cddb_use_proxy);
443
set_option_from_combo(cddb_proto_combo, &options.cddb_use_http);
444
set_option_from_entry(cddb_proxy_entry, options.cddb_proxy);
445
set_option_from_spin(cddb_proxy_port_spinner, &options.cddb_proxy_port);
446
#endif /* HAVE_CDDB */
447
448
449
/* Appearance */
450
451
set_option_from_toggle(check_override_skin, &options.override_skin_settings);
452
453
454
/* refresh GUI */
455
456
for (i = 0; i < 3; i++) {
457
458
GtkTreeIter iter;
459
GtkTreeViewColumn * cols[4];
460
char * pnumstr;
461
462
cols[0] = track_column;
463
cols[1] = rva_column;
464
cols[2] = length_column;
465
cols[3] = NULL;
466
467
gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(plistcol_store), &iter, NULL, i);
468
469
gtk_tree_model_get(GTK_TREE_MODEL(plistcol_store), &iter, 1, &pnumstr, -1);
470
n = atoi(pnumstr);
471
g_free(pnumstr);
472
473
gtk_tree_view_move_column_after(GTK_TREE_VIEW(play_list),
474
cols[n], cols[n_prev]);
475
476
options.plcol_idx[i] = n;
477
n_prev = n;
478
}
479
480
if (!track_name_in_bold_shadow && options.show_active_track_name_in_bold == 1) {
481
reskin_flag = 1;
482
track_name_in_bold_shadow = 0;
483
}
484
485
if (options.override_skin_settings) {
486
487
/* apply fonts */
488
489
open_font_desc();
490
491
gtk_widget_modify_font (music_tree, fd_browser);
492
gtk_widget_modify_font (play_list, fd_playlist);
493
494
gtk_widget_modify_font (bigtimer_label, fd_bigtimer);
495
gtk_widget_modify_font (smalltimer_label_1, fd_smalltimer);
496
gtk_widget_modify_font (smalltimer_label_2, fd_smalltimer);
497
gtk_widget_modify_font (label_title, fd_songtitle);
498
499
gtk_widget_modify_font (label_format, fd_songinfo);
500
gtk_widget_modify_font (label_samplerate, fd_songinfo);
501
gtk_widget_modify_font (label_bps, fd_songinfo);
502
gtk_widget_modify_font (label_mono, fd_songinfo);
503
gtk_widget_modify_font (label_output, fd_songinfo);
504
gtk_widget_modify_font (label_src_type, fd_songinfo);
505
506
if (options.enable_playlist_statusbar) {
507
gtk_widget_modify_font (statusbar_total, fd_statusbar);
508
gtk_widget_modify_font (statusbar_total_label, fd_statusbar);
509
gtk_widget_modify_font (statusbar_selected, fd_statusbar);
510
gtk_widget_modify_font (statusbar_selected_label, fd_statusbar);
511
}
512
if (options.enable_mstore_statusbar) {
513
gtk_widget_modify_font (statusbar_ms, fd_statusbar);
514
}
515
516
set_playlist_color();
517
518
if (appearance_changed) {
519
reskin_flag = 1;
520
}
521
522
} else if (override_shadow) {
523
reskin_flag = 1;
524
override_shadow = 0;
525
}
526
527
528
529
#ifdef HAVE_CDDA
530
i = 1; /* 0-th store is STORE_CDDA, skip it */
531
#else
532
i = 0;
533
#endif /* HAVE_CDDA */
534
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store),
535
&iter, NULL, i++)) {
536
char * p1;
537
int j;
538
int has;
539
540
gtk_tree_model_get(GTK_TREE_MODEL(music_store), &iter, 2, &p1, -1);
541
542
j = 0;
543
has = 0;
544
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(ms_pathlist_store),
545
&iter2, NULL, j++)) {
546
char * p2;
547
548
gtk_tree_model_get(GTK_TREE_MODEL(ms_pathlist_store), &iter2, 0, &p2, -1);
549
if (strcmp(p1, p2) == 0) {
550
551
if (access(p2, R_OK) == 0) {
552
has = 1;
553
}
554
555
g_free(p2);
556
break;
557
}
558
559
g_free(p2);
560
}
561
562
if (!has) {
563
564
float dirty;
565
char * name;
566
567
gtk_tree_model_get(GTK_TREE_MODEL(music_store), &iter,
568
0, &name, 6, &dirty, -1);
569
570
if (dirty < 0) {
571
GtkWidget * dialog;
572
573
dialog = gtk_message_dialog_new(GTK_WINDOW(options_window),
574
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
575
GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
576
_("Do you want to save store \"%s\" before removing from Music Store?"), name + 1);
577
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
578
gtk_dialog_set_default_response(GTK_DIALOG(dialog),
579
GTK_RESPONSE_YES);
580
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
581
582
if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES) {
583
save_music_store(&iter);
584
} else {
585
music_store_mark_saved(&iter);
586
}
587
588
gtk_widget_destroy(dialog);
589
g_free(name);
590
}
591
592
gtk_tree_store_remove(music_store, &iter);
593
--i;
594
}
595
596
g_free(p1);
597
}
598
599
600
i = 0;
601
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(ms_pathlist_store),
602
&iter, NULL, i++)) {
603
char * p1;
604
int j;
605
int has;
606
char sort[4];
607
608
snprintf(sort, 4, "%03d", i);
609
610
gtk_tree_model_get(GTK_TREE_MODEL(ms_pathlist_store), &iter, 0, &p1, -1);
611
612
j = 0;
613
has = 0;
614
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store),
615
&iter2, NULL, j++)) {
616
char * p2;
617
618
gtk_tree_model_get(GTK_TREE_MODEL(music_store),
619
&iter2, 2, &p2, -1);
620
621
if (strcmp(p1, p2) == 0) {
622
623
gtk_tree_store_set(music_store, &iter2, 1, sort, -1);
624
625
if (access(p2, W_OK) == 0) {
626
gtk_tree_store_set(music_store, &iter2, 7, 1.0f, -1);
627
} else {
628
gtk_tree_store_set(music_store, &iter2, 7, -1.0f, -1);
629
}
630
631
g_free(p2);
632
has = 1;
633
634
break;
635
}
636
637
g_free(p2);
638
}
639
640
if (!has) {
641
load_music_store(p1, sort);
642
}
643
644
g_free(p1);
645
}
646
647
set_buttons_relief();
648
refresh_displays();
649
gtk_window_set_keep_above(GTK_WINDOW(main_window), options.main_window_always_on_top);
650
651
playlist_content_changed();
652
playlist_selection_changed(NULL, NULL);
653
music_store_set_status_bar_info();
654
655
current_notebook_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
656
657
playlist_size_allocate(NULL, NULL);
658
show_active_position_in_playlist();
659
660
gtk_widget_destroy(options_window);
661
662
save_config();
663
}
664
665
666
#ifdef HAVE_LADSPA
667
void
668
changed_ladspa_prepost(GtkWidget * widget, gpointer * data) {
669
670
int status = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_ladspa));
671
options.ladspa_is_postfader = status;
672
}
673
#endif /* HAVE_LADSPA */
674
675
676
#ifdef HAVE_SRC
677
void
678
changed_src_type(GtkWidget * widget, gpointer * data) {
679
680
options.src_type = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_src));
681
gtk_label_set_text(GTK_LABEL(label_src), src_get_description(options.src_type));
682
set_src_type_label(options.src_type);
683
}
684
#endif /* HAVE_SRC */
685
686
687
void
688
check_rva_is_enabled_toggled(GtkWidget * widget, gpointer * data) {
689
690
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_rva_is_enabled))) {
691
rva_is_enabled_shadow = 1;
692
gtk_widget_set_sensitive(combo_listening_env, TRUE);
693
gtk_widget_set_sensitive(label_listening_env, TRUE);
694
gtk_widget_set_sensitive(spin_refvol, TRUE);
695
gtk_widget_set_sensitive(label_refvol, TRUE);
696
gtk_widget_set_sensitive(spin_steepness, TRUE);
697
gtk_widget_set_sensitive(label_steepness, TRUE);
698
699
gtk_widget_set_sensitive(check_rva_use_averaging, TRUE);
700
701
if (rva_use_averaging_shadow) {
702
gtk_widget_set_sensitive(combo_threshold, TRUE);
703
gtk_widget_set_sensitive(label_threshold, TRUE);
704
gtk_widget_set_sensitive(spin_linthresh, TRUE);
705
gtk_widget_set_sensitive(label_linthresh, TRUE);
706
gtk_widget_set_sensitive(spin_stdthresh, TRUE);
707
gtk_widget_set_sensitive(label_stdthresh, TRUE);
708
}
709
} else {
710
rva_is_enabled_shadow = 0;
711
gtk_widget_set_sensitive(combo_listening_env, FALSE);
712
gtk_widget_set_sensitive(label_listening_env, FALSE);
713
gtk_widget_set_sensitive(spin_refvol, FALSE);
714
gtk_widget_set_sensitive(label_refvol, FALSE);
715
gtk_widget_set_sensitive(spin_steepness, FALSE);
716
gtk_widget_set_sensitive(label_steepness, FALSE);
717
718
gtk_widget_set_sensitive(check_rva_use_averaging, FALSE);
719
gtk_widget_set_sensitive(combo_threshold, FALSE);
720
gtk_widget_set_sensitive(label_threshold, FALSE);
721
gtk_widget_set_sensitive(spin_linthresh, FALSE);
722
gtk_widget_set_sensitive(label_linthresh, FALSE);
723
gtk_widget_set_sensitive(spin_stdthresh, FALSE);
724
gtk_widget_set_sensitive(label_stdthresh, FALSE);
725
}
726
727
draw_rva_diagram();
728
}
729
730
731
void
732
check_rva_use_averaging_toggled(GtkWidget * widget, gpointer * data) {
733
734
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_rva_use_averaging))) {
735
rva_use_averaging_shadow = 1;
736
gtk_widget_set_sensitive(combo_threshold, TRUE);
737
gtk_widget_set_sensitive(label_threshold, TRUE);
738
gtk_widget_set_sensitive(spin_linthresh, TRUE);
739
gtk_widget_set_sensitive(label_linthresh, TRUE);
740
gtk_widget_set_sensitive(spin_stdthresh, TRUE);
741
gtk_widget_set_sensitive(label_stdthresh, TRUE);
742
} else {
743
rva_use_averaging_shadow = 0;
744
gtk_widget_set_sensitive(combo_threshold, FALSE);
745
gtk_widget_set_sensitive(label_threshold, FALSE);
746
gtk_widget_set_sensitive(spin_linthresh, FALSE);
747
gtk_widget_set_sensitive(label_linthresh, FALSE);
748
gtk_widget_set_sensitive(spin_stdthresh, FALSE);
749
gtk_widget_set_sensitive(label_stdthresh, FALSE);
750
}
751
}
752
753
754
void
755
changed_listening_env(GtkWidget * widget, gpointer * data) {
756
757
rva_env_shadow = gtk_combo_box_get_active(GTK_COMBO_BOX(combo_listening_env));
758
759
switch (rva_env_shadow) {
760
case 0: /* Audiophile */
761
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_refvol), -12.0f);
762
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_steepness), 1.0f);
763
break;
764
case 1: /* Living room */
765
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_refvol), -12.0f);
766
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_steepness), 0.7f);
767
break;
768
case 2: /* Office */
769
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_refvol), -12.0f);
770
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_steepness), 0.4f);
771
break;
772
case 3: /* Noisy workshop */
773
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_refvol), -12.0f);
774
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_steepness), 0.1f);
775
break;
776
default:
777
fprintf(stderr, "programmer error: options.c/changed_listening_env(): "
778
"invalid rva_env_shadow value.\nPlease report this to the programmers!\n");
779
break;
780
}
781
}
782
783
784
void
785
draw_rva_diagram(void) {
786
787
GdkGC * gc;
788
GdkColor fg_color;
789
int i;
790
int width = rva_viewport->allocation.width - 4;
791
int height = rva_viewport->allocation.height - 4;
792
int dw = width / 24;
793
int dh = height / 24;
794
int xoffs = (width - 24*dw) / 2 - 1;
795
int yoffs = (height - 24*dh) / 2 - 1;
796
float volx, voly;
797
int px1, py1, px2, py2;
798
799
800
gdk_draw_rectangle(rva_pixmap,
801
rva_drawing_area->style->black_gc,
802
TRUE,
803
0, 0,
804
rva_drawing_area->allocation.width,
805
rva_drawing_area->allocation.height);
806
807
gc = gdk_gc_new(rva_pixmap);
808
if (rva_is_enabled_shadow) {
809
fg_color.red = 10000;
810
fg_color.green = 10000;
811
fg_color.blue = 10000;
812
} else {
813
fg_color.red = 5000;
814
fg_color.green = 5000;
815
fg_color.blue = 5000;
816
}
817
gdk_gc_set_rgb_fg_color(gc, &fg_color);
818
819
for (i = 0; i <= 24; i++) {
820
gdk_draw_line(rva_pixmap, gc,
821
xoffs + i * dw, yoffs,
822
xoffs + i * dw, yoffs + 24 * dh);
823
}
824
825
for (i = 0; i <= 24; i++) {
826
gdk_draw_line(rva_pixmap, gc,
827
xoffs, yoffs + i * dh,
828
xoffs + 24 * dw, yoffs + i * dh);
829
}
830
831
if (rva_is_enabled_shadow) {
832
fg_color.red = 0;
833
fg_color.green = 0;
834
fg_color.blue = 65535;
835
} else {
836
fg_color.red = 0;
837
fg_color.green = 0;
838
fg_color.blue = 30000;
839
}
840
gdk_gc_set_rgb_fg_color(gc, &fg_color);
841
gdk_draw_line(rva_pixmap, gc, xoffs, yoffs + 24 * dh, xoffs + 24 * dw, yoffs);
842
843
if (rva_is_enabled_shadow) {
844
fg_color.red = 65535;
845
fg_color.green = 0;
846
fg_color.blue = 0;
847
} else {
848
fg_color.red = 30000;
849
fg_color.green = 0;
850
fg_color.blue = 0;
851
}
852
gdk_gc_set_rgb_fg_color(gc, &fg_color);
853
854
855
volx = -24.0f;
856
voly = volx + (volx - rva_refvol_shadow) * (rva_steepness_shadow - 1.0f);
857
px1 = xoffs;
858
py1 = yoffs - (voly * dh);
859
860
volx = 0.0f;
861
voly = volx + (volx - rva_refvol_shadow) * (rva_steepness_shadow - 1.0f);
862
px2 = xoffs + 24*dw;
863
py2 = yoffs - (voly * dh);
864
865
gdk_draw_line(rva_pixmap, gc, px1, py1, px2, py2);
866
867
gdk_draw_drawable(rva_drawing_area->window,
868
rva_drawing_area->style->fg_gc[GTK_WIDGET_STATE(rva_drawing_area)],
869
rva_pixmap,
870
0, 0, 0, 0,
871
width, height);
872
873
g_object_unref(gc);
874
}
875
876
877
void
878
refvol_changed(GtkWidget * widget, gpointer * data) {
879
880
rva_refvol_shadow = gtk_adjustment_get_value(GTK_ADJUSTMENT(widget));
881
draw_rva_diagram();
882
}
883
884
885
void
886
steepness_changed(GtkWidget * widget, gpointer * data) {
887
888
rva_steepness_shadow = gtk_adjustment_get_value(GTK_ADJUSTMENT(widget));
889
draw_rva_diagram();
890
}
891
892
893
static gint
894
rva_configure_event(GtkWidget * widget, GdkEventConfigure * event) {
895
896
if (rva_pixmap)
897
g_object_unref(rva_pixmap);
898
899
rva_pixmap = gdk_pixmap_new(widget->window,
900
widget->allocation.width,
901
widget->allocation.height,
902
-1);
903
gdk_draw_rectangle(rva_pixmap,
904
widget->style->black_gc,
905
TRUE,
906
0, 0,
907
widget->allocation.width,
908
widget->allocation.height);
909
draw_rva_diagram();
910
return TRUE;
911
}
912
913
914
static gint
915
rva_expose_event(GtkWidget * widget, GdkEventExpose * event) {
916
917
gdk_draw_drawable(widget->window,
918
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
919
rva_pixmap,
920
event->area.x, event->area.y,
921
event->area.x, event->area.y,
922
event->area.width, event->area.height);
923
return FALSE;
924
}
925
926
927
void
928
changed_threshold(GtkWidget * widget, gpointer * data) {
929
930
rva_use_linear_thresh_shadow =
931
gtk_combo_box_get_active(GTK_COMBO_BOX(combo_threshold));
932
}
933
934
935
void
936
linthresh_changed(GtkWidget * widget, gpointer * data) {
937
938
rva_avg_linear_thresh_shadow = gtk_adjustment_get_value(GTK_ADJUSTMENT(widget));
939
}
940
941
942
void
943
stdthresh_changed(GtkWidget * widget, gpointer * data) {
944
945
rva_avg_stddev_thresh_shadow = gtk_adjustment_get_value(GTK_ADJUSTMENT(widget)) / 100.0f;
946
}
947
948
void
949
show_restart_info(void) {
950
951
GtkWidget * info_dialog;
952
GtkWidget * list;
953
GtkWidget * viewport;
954
GtkCellRenderer * renderer;
955
GtkTreeViewColumn * column;
956
957
info_dialog = gtk_message_dialog_new(GTK_WINDOW (options_window),
958
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
959
GTK_MESSAGE_INFO,
960
GTK_BUTTONS_OK,
961
_("You will need to restart Aqualung for the following changes to take effect:"));
962
963
964
list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(restart_list_store));
965
renderer = gtk_cell_renderer_text_new();
966
column = gtk_tree_view_column_new_with_attributes("",
967
renderer,
968
"text", 0,
969
NULL);
970
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
971
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list), FALSE);
972
973
viewport = gtk_viewport_new(NULL, NULL);
974
gtk_container_add(GTK_CONTAINER(viewport), list);
975
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(info_dialog)->vbox), viewport, FALSE, FALSE, 6);
976
977
978
gtk_widget_show_all(info_dialog);
979
aqualung_dialog_run(GTK_DIALOG(info_dialog));
980
gtk_widget_destroy(info_dialog);
981
}
982
983
void
984
playlist_font_select(GtkWidget *widget) {
985
986
gchar *s;
987
GtkWidget *font_selector;
988
gint response;
989
990
font_selector = gtk_font_selection_dialog_new ("Select a font...");
991
gtk_window_set_modal(GTK_WINDOW(font_selector), TRUE);
992
gtk_window_set_transient_for(GTK_WINDOW(font_selector), GTK_WINDOW(options_window));
993
gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG(font_selector), options.playlist_font);
994
gtk_widget_show (font_selector);
995
response = aqualung_dialog_run (GTK_DIALOG (font_selector));
996
997
if (response == GTK_RESPONSE_OK) {
998
999
s = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(font_selector));
1000
strncpy(options.playlist_font, s, MAX_FONTNAME_LEN);
1001
gtk_entry_set_text(GTK_ENTRY(entry_pl_font), s);
1002
g_free (s);
1003
1004
}
1005
1006
appearance_changed = 1;
1007
gtk_widget_destroy (font_selector);
1008
}
1009
1010
void
1011
browser_font_select(GtkWidget *widget) {
1012
1013
gchar *s;
1014
GtkWidget *font_selector;
1015
gint response;
1016
1017
font_selector = gtk_font_selection_dialog_new ("Select a font...");
1018
gtk_window_set_modal(GTK_WINDOW(font_selector), TRUE);
1019
gtk_window_set_transient_for(GTK_WINDOW(font_selector), GTK_WINDOW(options_window));
1020
gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG(font_selector), options.browser_font);
1021
gtk_widget_show (font_selector);
1022
response = aqualung_dialog_run (GTK_DIALOG (font_selector));
1023
1024
if (response == GTK_RESPONSE_OK) {
1025
1026
s = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(font_selector));
1027
strncpy(options.browser_font, s, MAX_FONTNAME_LEN);
1028
gtk_entry_set_text(GTK_ENTRY(entry_ms_font), s);
1029
g_free (s);
1030
1031
}
1032
1033
appearance_changed = 1;
1034
gtk_widget_destroy (font_selector);
1035
}
1036
1037
void
1038
bigtimer_font_select(GtkWidget *widget) {
1039
1040
gchar *s;
1041
GtkWidget *font_selector;
1042
gint response;
1043
1044
font_selector = gtk_font_selection_dialog_new ("Select a font...");
1045
gtk_window_set_modal(GTK_WINDOW(font_selector), TRUE);
1046
gtk_window_set_transient_for(GTK_WINDOW(font_selector), GTK_WINDOW(options_window));
1047
gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG(font_selector), options.bigtimer_font);
1048
gtk_widget_show (font_selector);
1049
response = aqualung_dialog_run (GTK_DIALOG (font_selector));
1050
1051
if (response == GTK_RESPONSE_OK) {
1052
1053
s = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(font_selector));
1054
strncpy(options.bigtimer_font, s, MAX_FONTNAME_LEN);
1055
gtk_entry_set_text(GTK_ENTRY(entry_bt_font), s);
1056
g_free (s);
1057
1058
}
1059
1060
appearance_changed = 1;
1061
gtk_widget_destroy (font_selector);
1062
}
1063
1064
void
1065
smalltimer_font_select(GtkWidget *widget) {
1066
1067
gchar *s;
1068
GtkWidget *font_selector;
1069
gint response;
1070
1071
font_selector = gtk_font_selection_dialog_new ("Select a font...");
1072
gtk_window_set_modal(GTK_WINDOW(font_selector), TRUE);
1073
gtk_window_set_transient_for(GTK_WINDOW(font_selector), GTK_WINDOW(options_window));
1074
gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG(font_selector), options.smalltimer_font);
1075
gtk_widget_show (font_selector);
1076
response = aqualung_dialog_run (GTK_DIALOG (font_selector));
1077
1078
if (response == GTK_RESPONSE_OK) {
1079
1080
s = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(font_selector));
1081
strncpy(options.smalltimer_font, s, MAX_FONTNAME_LEN);
1082
gtk_entry_set_text(GTK_ENTRY(entry_st_font), s);
1083
g_free (s);
1084
1085
}
1086
1087
appearance_changed = 1;
1088
gtk_widget_destroy (font_selector);
1089
}
1090
1091
void
1092
songtitle_font_select(GtkWidget *widget) {
1093
1094
gchar *s;
1095
GtkWidget *font_selector;
1096
gint response;
1097
1098
font_selector = gtk_font_selection_dialog_new ("Select a font...");
1099
gtk_window_set_modal(GTK_WINDOW(font_selector), TRUE);
1100
gtk_window_set_transient_for(GTK_WINDOW(font_selector), GTK_WINDOW(options_window));
1101
gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG(font_selector), options.songtitle_font);
1102
gtk_widget_show (font_selector);
1103
response = aqualung_dialog_run (GTK_DIALOG (font_selector));
1104
1105
if (response == GTK_RESPONSE_OK) {
1106
1107
s = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(font_selector));
1108
strncpy(options.songtitle_font, s, MAX_FONTNAME_LEN);
1109
gtk_entry_set_text(GTK_ENTRY(entry_songt_font), s);
1110
g_free (s);
1111
1112
}
1113
1114
appearance_changed = 1;
1115
gtk_widget_destroy (font_selector);
1116
}
1117
1118
void
1119
songinfo_font_select(GtkWidget *widget) {
1120
1121
gchar *s;
1122
GtkWidget *font_selector;
1123
gint response;
1124
1125
font_selector = gtk_font_selection_dialog_new ("Select a font...");
1126
gtk_window_set_modal(GTK_WINDOW(font_selector), TRUE);
1127
gtk_window_set_transient_for(GTK_WINDOW(font_selector), GTK_WINDOW(options_window));
1128
gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG(font_selector), options.songinfo_font);
1129
gtk_widget_show (font_selector);
1130
response = aqualung_dialog_run (GTK_DIALOG (font_selector));
1131
1132
if (response == GTK_RESPONSE_OK) {
1133
1134
s = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(font_selector));
1135
strncpy(options.songinfo_font, s, MAX_FONTNAME_LEN);
1136
gtk_entry_set_text(GTK_ENTRY(entry_si_font), s);
1137
g_free (s);
1138
1139
}
1140
1141
appearance_changed = 1;
1142
gtk_widget_destroy (font_selector);
1143
}
1144
1145
void
1146
statusbar_font_select(GtkWidget *widget) {
1147
1148
gchar *s;
1149
GtkWidget *font_selector;
1150
gint response;
1151
1152
font_selector = gtk_font_selection_dialog_new ("Select a font...");
1153
gtk_window_set_modal(GTK_WINDOW(font_selector), TRUE);
1154
gtk_window_set_transient_for(GTK_WINDOW(font_selector), GTK_WINDOW(options_window));
1155
gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG(font_selector), options.statusbar_font);
1156
gtk_widget_show (font_selector);
1157
response = aqualung_dialog_run (GTK_DIALOG (font_selector));
1158
1159
if (response == GTK_RESPONSE_OK) {
1160
1161
s = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(font_selector));
1162
strncpy(options.statusbar_font, s, MAX_FONTNAME_LEN);
1163
gtk_entry_set_text(GTK_ENTRY(entry_sb_font), s);
1164
g_free (s);
1165
1166
}
1167
1168
appearance_changed = 1;
1169
gtk_widget_destroy (font_selector);
1170
}
1171
1172
void
1173
restart_active(GtkToggleButton * togglebutton, gpointer data) {
1174
1175
GtkTreeIter iter;
1176
char * text;
1177
int i = 0;
1178
1179
1180
restart_flag = 1;
1181
1182
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(restart_list_store), &iter, NULL, i++)) {
1183
1184
gtk_tree_model_get(GTK_TREE_MODEL(restart_list_store), &iter, 0, &text, -1);
1185
1186
if (!strcmp(text, (char *)data)) {
1187
gtk_list_store_remove(restart_list_store, &iter);
1188
if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(restart_list_store), &iter)) {
1189
restart_flag = 0;
1190
}
1191
return;
1192
}
1193
}
1194
1195
gtk_list_store_append(restart_list_store, &iter);
1196
gtk_list_store_set(restart_list_store, &iter, 0, (char *)data, -1);
1197
}
1198
1199
void
1200
set_sensitive_part(void) {
1201
1202
GtkWidget *sensitive_table[] = {
1203
entry_ms_font, entry_pl_font, entry_bt_font, entry_st_font,
1204
entry_songt_font, entry_si_font, entry_sb_font, button_ms_font,
1205
button_pl_font, button_bt_font, button_st_font, button_songt_font,
1206
button_si_font, button_sb_font, color_picker
1207
};
1208
1209
gboolean state;
1210
gint items, n;
1211
1212
if (options.override_skin_settings) {
1213
state = TRUE;
1214
} else {
1215
state = FALSE;
1216
}
1217
1218
items = sizeof(sensitive_table) / sizeof(GtkWidget*);
1219
1220
for (n = 0; n < items; n++) {
1221
gtk_widget_set_sensitive(sensitive_table[n], state);
1222
}
1223
}
1224
1225
void
1226
cb_toggle_override_skin(GtkToggleButton *togglebutton, gpointer user_data) {
1227
1228
options.override_skin_settings = options.override_skin_settings ? 0 : 1;
1229
appearance_changed = 1;
1230
set_sensitive_part();
1231
}
1232
1233
void
1234
color_selected(GtkColorButton *widget, gpointer user_data) {
1235
1236
GdkColor c;
1237
gchar str[MAX_COLORNAME_LEN];
1238
1239
appearance_changed = 1;
1240
gtk_color_button_get_color(widget, &c);
1241
sprintf(str, "#%02X%02X%02X", c.red * 256 / 65536, c.green * 256 / 65536, c.blue * 256 / 65536);
1242
1243
strncpy(options.activesong_color, str, MAX_COLORNAME_LEN-1);
1244
}
1245
1246
GtkWidget *
1247
create_notebook_tab(char * text, char * imgfile) {
1248
1249
GtkWidget * vbox;
1250
GdkPixbuf * pixbuf;
1251
GtkWidget * image;
1252
GtkWidget * label;
1253
1254
char path[MAXLEN];
1255
1256
vbox = gtk_vbox_new(FALSE, 0);
1257
1258
label = gtk_label_new(text);
1259
gtk_box_pack_end(GTK_BOX(vbox), label, FALSE, FALSE, 0);
1260
1261
sprintf(path, "%s/%s", AQUALUNG_DATADIR, imgfile);
1262
1263
pixbuf = gdk_pixbuf_new_from_file(path, NULL);
1264
1265
if (pixbuf) {
1266
image = gtk_image_new_from_pixbuf(pixbuf);
1267
gtk_box_pack_end(GTK_BOX(vbox), image, FALSE, FALSE, 0);
1268
}
1269
1270
gtk_widget_show_all(vbox);
1271
1272
return vbox;
1273
}
1274
1275
1276
void
1277
refresh_ms_pathlist_clicked(GtkWidget * widget, gpointer * data) {
1278
1279
GtkTreeIter iter;
1280
char * path;
1281
int i = 0;
1282
1283
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(ms_pathlist_store),
1284
&iter, NULL, i++)) {
1285
1286
gtk_tree_model_get(GTK_TREE_MODEL(ms_pathlist_store), &iter, 0, &path, -1);
1287
1288
if (access(path, R_OK | W_OK) == 0) {
1289
gtk_list_store_set(ms_pathlist_store, &iter, 2, _("rw"), -1);
1290
} else if (access(path, R_OK) == 0) {
1291
gtk_list_store_set(ms_pathlist_store, &iter, 2, _("r"), -1);
1292
} else {
1293
gtk_list_store_set(ms_pathlist_store, &iter, 2, _("unreachable"), -1);
1294
}
1295
1296
g_free(path);
1297
}
1298
}
1299
1300
1301
void
1302
append_ms_pathlist(char * path, char * name) {
1303
1304
GtkTreeIter iter;
1305
1306
gtk_list_store_append(ms_pathlist_store, &iter);
1307
gtk_list_store_set(ms_pathlist_store, &iter, 0, path, 1, name, -1);
1308
1309
refresh_ms_pathlist_clicked(NULL, NULL);
1310
}
1311
1312
1313
void
1314
add_ms_pathlist_clicked(GtkWidget * widget, gpointer * data) {
1315
1316
const char * pname;
1317
char name[MAXLEN];
1318
char * path;
1319
GtkTreeIter iter;
1320
int i;
1321
struct stat st_file;
1322
1323
pname = gtk_entry_get_text(GTK_ENTRY(entry_ms_pathlist));
1324
1325
if (pname[0] == '\0') return;
1326
1327
if (pname[0] == '~') {
1328
snprintf(name, MAXLEN - 1, "%s%s", options.home, pname + 1);
1329
} else if (pname[0] == '/') {
1330
strncpy(name, pname, MAXLEN - 1);
1331
} else {
1332
GtkWidget * dialog;
1333
GtkWidget * label;
1334
1335
dialog = gtk_dialog_new_with_buttons(_("Warning"),
1336
GTK_WINDOW(options_window),
1337
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1338
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1339
NULL);
1340
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
1341
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
1342
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
1343
1344
label = gtk_label_new(_("Paths must either be absolute or starting with a tilde."));
1345
1346
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, TRUE, 10);
1347
gtk_widget_show(label);
1348
1349
aqualung_dialog_run(GTK_DIALOG(dialog));
1350
gtk_widget_destroy(dialog);
1351
return;
1352
}
1353
1354
if ((path = g_locale_from_utf8(name, -1, NULL, NULL, NULL)) == NULL) {
1355
return;
1356
}
1357
1358
if (stat(path, &st_file) != -1 && S_ISDIR(st_file.st_mode)) {
1359
return;
1360
}
1361
1362
i = 0;
1363
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(ms_pathlist_store), &iter, NULL, i++)) {
1364
char * p;
1365
1366
gtk_tree_model_get(GTK_TREE_MODEL(ms_pathlist_store), &iter, 0, &p, -1);
1367
1368
if (!strcmp(p, path)) {
1369
1370
GtkWidget * dialog;
1371
1372
dialog = gtk_message_dialog_new(GTK_WINDOW(options_window),
1373
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
1374
GTK_MESSAGE_WARNING,
1375
GTK_BUTTONS_CLOSE,
1376
_("The specified store has already been added to the list."));
1377
gtk_widget_show(dialog);
1378
aqualung_dialog_run(GTK_DIALOG(dialog));
1379
gtk_widget_destroy(dialog);
1380
1381
g_free(p);
1382
g_free(path);
1383
return;
1384
}
1385
1386
g_free(p);
1387
}
1388
1389
1390
gtk_entry_set_text(GTK_ENTRY(entry_ms_pathlist), "");
1391
1392
append_ms_pathlist(path, name);
1393
1394
g_free(path);
1395
}
1396
1397
1398
void
1399
remove_ms_pathlist_clicked(GtkWidget * widget, gpointer data) {
1400
1401
GtkTreeIter iter;
1402
int i = 0;
1403
1404
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(ms_pathlist_store), &iter, NULL, i++)) {
1405
1406
if (gtk_tree_selection_iter_is_selected(ms_pathlist_select, &iter)) {
1407
gtk_list_store_remove(ms_pathlist_store, &iter);
1408
--i;
1409
}
1410
}
1411
}
1412
1413
1414
void
1415
browse_ms_pathlist_clicked(GtkWidget * widget, gpointer data) {
1416
1417
GtkWidget * dialog;
1418
const gchar * selected_filename = gtk_entry_get_text(GTK_ENTRY(data));
1419
1420
1421
dialog = gtk_file_chooser_dialog_new(_("Please select a Music Store database."),
1422
GTK_WINDOW(options_window),
1423
GTK_FILE_CHOOSER_ACTION_OPEN,
1424
GTK_STOCK_APPLY, GTK_RESPONSE_ACCEPT,
1425
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1426
NULL);
1427
1428
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
1429
gtk_window_set_default_size(GTK_WINDOW(dialog), 580, 390);
1430
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
1431
1432
if (strlen(selected_filename)) {
1433
char * locale = g_locale_from_utf8(selected_filename, -1, NULL, NULL, NULL);
1434
char tmp[MAXLEN];
1435
tmp[0] = '\0';
1436
1437
if (locale == NULL) {
1438
gtk_widget_destroy(dialog);
1439
return;
1440
}
1441
1442
normalize_filename(locale, tmp);
1443
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), tmp);
1444
g_free(locale);
1445
} else {
1446
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), options.currdir);
1447
}
1448
1449
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_show_hidden))) {
1450
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
1451
}
1452
1453
if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1454
1455
char * utf8;
1456
1457
selected_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
1458
utf8 = g_locale_to_utf8(selected_filename, -1, NULL, NULL, NULL);
1459
1460
if (utf8 == NULL) {
1461
gtk_widget_destroy(dialog);
1462
return;
1463
}
1464
1465
gtk_entry_set_text(GTK_ENTRY(entry_ms_pathlist), utf8);
1466
1467
strncpy(options.currdir, selected_filename, MAXLEN-1);
1468
g_free(utf8);
1469
}
1470
1471
gtk_widget_destroy(dialog);
1472
}
1473
1474
1475
void
1476
display_title_format_help(void) {
1477
1478
GtkWidget *help_dialog;
1479
1480
help_dialog = gtk_message_dialog_new (GTK_WINDOW(options_window),
1481
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
1482
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
1483
_("\nThe template string you enter here will be used to\n"
1484
"construct a single title line from an Artist, a Record\n"
1485
"and a Track name. These are denoted by %%a, %%r and %%t,\n"
1486
"respectively. Everything else you enter here will be\n"
1487
"literally copied into the resulting string.\n"));
1488
1489
gtk_window_set_title(GTK_WINDOW(help_dialog), _("Help"));
1490
gtk_widget_show (help_dialog);
1491
aqualung_dialog_run(GTK_DIALOG(help_dialog));
1492
gtk_widget_destroy(help_dialog);
1493
}
1494
1495
1496
void
1497
display_implict_command_line_help(void) {
1498
1499
GtkWidget *help_dialog;
1500
1501
help_dialog = gtk_message_dialog_new (GTK_WINDOW(options_window),
1502
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
1503
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
1504
_("\nThe string you enter here will be parsed as a command\n"
1505
"line before parsing the actual command line parameters.\n"
1506
"What you enter here will act as a default setting and may\n"
1507
"or may not be overrided from the 'real' command line.\n"
1508
"Example: enter '-o alsa -R' below to use ALSA output\n"
1509
"running realtime as a default.\n"));
1510
1511
gtk_window_set_title(GTK_WINDOW(help_dialog), _("Help"));
1512
gtk_widget_show (help_dialog);
1513
aqualung_dialog_run(GTK_DIALOG(help_dialog));
1514
gtk_widget_destroy(help_dialog);
1515
}
1516
1517
1518
void
1519
display_pathlist_help(void) {
1520
1521
GtkWidget *help_dialog;
1522
1523
help_dialog = gtk_message_dialog_new (GTK_WINDOW(options_window),
1524
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
1525
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
1526
_("Paths must either be absolute or starting with a tilde, which will be expanded to the user's home directory.\n\n"
1527
"Drag and drop entries in the list to set the store order in the Music Store."));
1528
1529
gtk_window_set_title(GTK_WINDOW(help_dialog), _("Help"));
1530
gtk_widget_show (help_dialog);
1531
aqualung_dialog_run(GTK_DIALOG(help_dialog));
1532
gtk_widget_destroy(help_dialog);
1533
}
1534
1535
#ifdef HAVE_CDDA
1536
void
1537
display_cdda_drive_speed_help(void) {
1538
1539
GtkWidget *help_dialog;
1540
1541
help_dialog = gtk_message_dialog_new (GTK_WINDOW(options_window),
1542
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
1543
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
1544
_("\nSet the drive speed for CD playing in CD-ROM speed units.\n"
1545
"One speed unit equals to 176 kBps raw data reading speed.\n"
1546
"Warning: not all drives honor this setting.\n\n"
1547
1548
"Lower speed usually means less drive noise. However,\n"
1549
"when using Paranoia error correction modes for increased\n"
1550
"accuracy, generally much larger speeds are required to\n"
1551
"prevent buffer underruns (and thus audible drop-outs).\n\n"
1552
1553
"Please note that these settings do not apply to CD Ripping,\n"
1554
"which always happens with maximum available speed and\n"
1555
"with error correction modes manually set before every run."));
1556
1557
gtk_window_set_title(GTK_WINDOW(help_dialog), _("Help"));
1558
gtk_widget_show (help_dialog);
1559
aqualung_dialog_run(GTK_DIALOG(help_dialog));
1560
gtk_widget_destroy(help_dialog);
1561
}
1562
1563
void
1564
display_cdda_force_drive_rescan_help(void) {
1565
1566
GtkWidget *help_dialog;
1567
1568
help_dialog = gtk_message_dialog_new (GTK_WINDOW(options_window),
1569
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
1570
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
1571
_("\nMost drives let Aqualung know when a CD has been inserted\n"
1572
"or removed by providing a 'media changed' flag. However,\n"
1573
"some drives don't set this flag properly, and thus it may\n"
1574
"happen that a newly inserted CD remains unnoticed to\n"
1575
"Aqualung. In such cases, enabling this option should help."));
1576
1577
gtk_window_set_title(GTK_WINDOW(help_dialog), _("Help"));
1578
gtk_widget_show (help_dialog);
1579
aqualung_dialog_run(GTK_DIALOG(help_dialog));
1580
gtk_widget_destroy(help_dialog);
1581
}
1582
1583
void
1584
cdda_toggled(GtkWidget * widget, gpointer * data) {
1585
1586
gtk_widget_set_sensitive(cdda_paranoia_maxretries_spinner,
1587
!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_cdda_mode_neverskip)));
1588
gtk_widget_set_sensitive(label_cdda_maxretries,
1589
!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_cdda_mode_neverskip)));
1590
}
1591
#endif /* HAVE_CDDA */
1592
1593
1594
#ifdef HAVE_CDDB
1595
void
1596
cddb_radio_direct_toggled(GtkWidget * widget, gpointer * data) {
1597
1598
gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cddb_radio_direct));
1599
1600
gtk_widget_set_sensitive(cddb_proto_combo, state);
1601
gtk_widget_set_sensitive(cddb_label_proto, state);
1602
gtk_widget_set_sensitive(cddb_proxy_entry, !state);
1603
gtk_widget_set_sensitive(cddb_proxy_port_spinner, !state);
1604
gtk_widget_set_sensitive(cddb_label_proxy, !state);
1605
gtk_widget_set_sensitive(cddb_label_proxy_port, !state);
1606
}
1607
#endif /* HAVE_CDDB */
1608
1609
void
1610
create_options_window(void) {
1611
1612
GtkWidget * vbox_general;
1613
GtkWidget * frame_title;
1614
GtkWidget * frame_param;
1615
GtkWidget * frame_misc;
1616
GtkWidget * frame_cart;
1617
GtkWidget * hbox_title;
1618
GtkWidget * hbox_param;
1619
GtkWidget * vbox_misc;
1620
GtkWidget * vbox_cart;
1621
GtkWidget * vbox_appearance;
1622
1623
GtkWidget * vbox_pl;
1624
GtkWidget * vbox_ms;
1625
GtkWidget * frame_ms_pathlist;
1626
GtkWidget * ms_pathlist_view;
1627
GtkWidget * vbox_ms_pathlist;
1628
GtkWidget * hbox_ms_pathlist;
1629
GtkWidget * hbox_ms_pathlist_2;
1630
GtkWidget * add_ms_pathlist;
1631
GtkWidget * browse_ms_pathlist;
1632
GtkWidget * remove_ms_pathlist;
1633
GtkWidget * refresh_ms_pathlist;
1634
GtkWidget * frame_plistcol;
1635
GtkWidget * vbox_plistcol;
1636
GtkWidget * label_plistcol;
1637
GtkWidget * viewport;
1638
GtkWidget * scrolled_win;
1639
GtkCellRenderer * renderer;
1640
GtkTreeViewColumn * column;
1641
GtkTreeIter iter;
1642
GtkWidget * plistcol_list;
1643
GtkWidget * label;
1644
1645
GtkWidget * vbox_dsp;
1646
GtkWidget * frame_ladspa;
1647
GtkWidget * frame_src;
1648
GtkWidget * frame_fonts;
1649
GtkWidget * frame_colors;
1650
GtkWidget * vbox_ladspa;
1651
GtkWidget * vbox_src;
1652
GtkWidget * vbox_fonts;
1653
GtkWidget * vbox_colors;
1654
1655
GtkWidget * vbox_rva;
1656
GtkWidget * table_rva;
1657
GtkWidget * label_cwidth;
1658
GtkWidget * hbox_cwidth;
1659
1660
GtkWidget * vbox_meta;
1661
1662
#ifdef HAVE_CDDA
1663
GtkWidget * table_cdda;
1664
GtkWidget * help_btn_cdda_drive_speed;
1665
GtkWidget * help_btn_cdda_force_drive_rescan;
1666
GtkWidget * frame_cdda;
1667
GtkWidget * vbox_cdda;
1668
GtkWidget * hbox_cdda;
1669
#endif /* HAVE_CDDA */
1670
1671
#ifdef HAVE_CDDB
1672
GtkWidget * table_cddb;
1673
#endif /* HAVE_CDDB */
1674
1675
GtkSizeGroup * label_size;
1676
1677
GtkWidget * hbox;
1678
GtkWidget * hbox_s;
1679
GtkWidget * help_btn_title;
1680
GtkWidget * help_btn_param;
1681
GtkWidget * help_pathlist;
1682
1683
#ifdef HAVE_LADSPA
1684
int status;
1685
#endif /* HAVE_LADSPA */
1686
int i;
1687
1688
1689
restart_flag = 0;
1690
reskin_flag = 0;
1691
appearance_changed = 0;
1692
1693
if (!restart_list_store) {
1694
restart_list_store = gtk_list_store_new(1, G_TYPE_STRING);
1695
} else {
1696
gtk_list_store_clear(restart_list_store);
1697
}
1698
1699
refresh_ms_pathlist_clicked(NULL, NULL);
1700
1701
options_window = gtk_dialog_new_with_buttons(_("Settings"),
1702
GTK_WINDOW(main_window),
1703
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
1704
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1705
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1706
NULL);
1707
gtk_window_set_position(GTK_WINDOW(options_window), GTK_WIN_POS_CENTER);
1708
gtk_dialog_set_default_response(GTK_DIALOG(options_window), GTK_RESPONSE_ACCEPT);
1709
gtk_container_set_border_width(GTK_CONTAINER(options_window), 5);
1710
1711
notebook = gtk_notebook_new();
1712
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT);
1713
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(options_window)->vbox), notebook);
1714
1715
label_size = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
1716
1717
/* "General" notebook page */
1718
1719
vbox_general = gtk_vbox_new(FALSE, 3);
1720
gtk_container_set_border_width(GTK_CONTAINER(vbox_general), 8);
1721
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_general, create_notebook_tab(_("General"), "general.png"));
1722
1723
frame_title = gtk_frame_new(_("Title format"));
1724
gtk_box_pack_start(GTK_BOX(vbox_general), frame_title, FALSE, TRUE, 0);
1725
1726
hbox_title = gtk_hbox_new(FALSE, 3);
1727
gtk_container_set_border_width(GTK_CONTAINER(hbox_title), 5);
1728
gtk_container_add(GTK_CONTAINER(frame_title), hbox_title);
1729
1730
entry_title = gtk_entry_new();
1731
gtk_entry_set_max_length(GTK_ENTRY(entry_title), MAXLEN - 1);
1732
gtk_entry_set_text(GTK_ENTRY(entry_title), options.title_format);
1733
gtk_box_pack_start(GTK_BOX(hbox_title), entry_title, TRUE, TRUE, 0);
1734
1735
help_btn_title = gtk_button_new_from_stock (GTK_STOCK_HELP);
1736
g_signal_connect(help_btn_title, "clicked", G_CALLBACK(display_title_format_help), NULL);
1737
gtk_box_pack_start(GTK_BOX(hbox_title), help_btn_title, FALSE, FALSE, 0);
1738
1739
frame_param = gtk_frame_new(_("Implicit command line"));
1740
gtk_box_pack_start(GTK_BOX(vbox_general), frame_param, FALSE, TRUE, 5);
1741
1742
1743
hbox_param = gtk_hbox_new(FALSE, 3);
1744
gtk_container_set_border_width(GTK_CONTAINER(hbox_param), 5);
1745
gtk_container_add(GTK_CONTAINER(frame_param), hbox_param);
1746
1747
entry_param = gtk_entry_new();
1748
gtk_entry_set_max_length(GTK_ENTRY(entry_param), MAXLEN - 1);
1749
gtk_entry_set_text(GTK_ENTRY(entry_param), options.default_param);
1750
gtk_box_pack_start(GTK_BOX(hbox_param), entry_param, TRUE, TRUE, 0);
1751
1752
help_btn_param = gtk_button_new_from_stock (GTK_STOCK_HELP);
1753
g_signal_connect(help_btn_param, "clicked", G_CALLBACK(display_implict_command_line_help), NULL);
1754
gtk_box_pack_start(GTK_BOX(hbox_param), help_btn_param, FALSE, FALSE, 0);
1755
1756
frame_misc = gtk_frame_new(_("Miscellaneous"));
1757
gtk_box_pack_start(GTK_BOX(vbox_general), frame_misc, FALSE, TRUE, 0);
1758
1759
vbox_misc = gtk_vbox_new(FALSE, 3);
1760
gtk_container_set_border_width(GTK_CONTAINER(vbox_misc), 8);
1761
gtk_container_add(GTK_CONTAINER(frame_misc), vbox_misc);
1762
1763
check_enable_tooltips = gtk_check_button_new_with_label(_("Enable tooltips"));
1764
gtk_widget_set_name(check_enable_tooltips, "check_on_notebook");
1765
if (options.enable_tooltips) {
1766
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_enable_tooltips), TRUE);
1767
}
1768
gtk_box_pack_start(GTK_BOX(vbox_misc), check_enable_tooltips, FALSE, FALSE, 0);
1769
1770
check_buttons_at_the_bottom =
1771
gtk_check_button_new_with_label(_("Put control buttons at the bottom of playlist"));
1772
gtk_widget_set_name(check_buttons_at_the_bottom, "check_on_notebook");
1773
if (options.buttons_at_the_bottom_shadow) {
1774
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_buttons_at_the_bottom), TRUE);
1775
}
1776
gtk_box_pack_start(GTK_BOX(vbox_misc), check_buttons_at_the_bottom, FALSE, FALSE, 0);
1777
g_signal_connect (G_OBJECT (check_buttons_at_the_bottom), "toggled",
1778
G_CALLBACK (restart_active), _("Put control buttons at the bottom of playlist"));
1779
1780
check_disable_buttons_relief =
1781
gtk_check_button_new_with_label(_("Disable control buttons relief"));
1782
gtk_widget_set_name(check_disable_buttons_relief, "check_on_notebook");
1783
if (options.disable_buttons_relief) {
1784
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_disable_buttons_relief), TRUE);
1785
}
1786
gtk_box_pack_start(GTK_BOX(vbox_misc), check_disable_buttons_relief, FALSE, FALSE, 0);
1787
1788
1789
check_main_window_always_on_top = gtk_check_button_new_with_label(_("Keep main window always on top"));
1790
gtk_widget_set_name(check_main_window_always_on_top, "check_on_notebook");
1791
if (options.main_window_always_on_top) {
1792
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_main_window_always_on_top), TRUE);
1793
}
1794
gtk_box_pack_start(GTK_BOX(vbox_misc), check_main_window_always_on_top, FALSE, FALSE, 0);
1795
1796
1797
#ifdef HAVE_LADSPA
1798
check_simple_view_in_fx =
1799
gtk_check_button_new_with_label(_("Simple view in LADSPA patch builder"));
1800
gtk_widget_set_name(check_simple_view_in_fx, "check_on_notebook");
1801
if (options.simple_view_in_fx_shadow) {
1802
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_simple_view_in_fx), TRUE);
1803
}
1804
gtk_box_pack_start(GTK_BOX(vbox_misc), check_simple_view_in_fx, FALSE, FALSE, 0);
1805
g_signal_connect(G_OBJECT (check_simple_view_in_fx), "toggled",
1806
G_CALLBACK (restart_active), _("Simple view in LADSPA patch builder"));
1807
#endif /* HAVE_LADSPA */
1808
1809
check_united_minimization =
1810
gtk_check_button_new_with_label(_("United windows minimization"));
1811
gtk_widget_set_name(check_united_minimization, "check_on_notebook");
1812
if (options.united_minimization) {
1813
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_united_minimization), TRUE);
1814
}
1815
gtk_box_pack_start(GTK_BOX(vbox_misc), check_united_minimization, FALSE, FALSE, 0);
1816
1817
check_show_sn_title =
1818
gtk_check_button_new_with_label(_("Show song name in the main window's title"));
1819
gtk_widget_set_name(check_show_sn_title, "check_on_notebook");
1820
if (options.show_sn_title) {
1821
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_show_sn_title), TRUE);
1822
}
1823
gtk_box_pack_start(GTK_BOX(vbox_misc), check_show_sn_title, FALSE, FALSE, 0);
1824
1825
1826
check_show_hidden = gtk_check_button_new_with_label(_("Show hidden files and directories in file choosers"));
1827
gtk_widget_set_name(check_show_hidden, "check_on_notebook");
1828
if (options.show_hidden) {
1829
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_show_hidden), TRUE);
1830
}
1831
gtk_box_pack_start(GTK_BOX(vbox_misc), check_show_hidden, FALSE, FALSE, 0);
1832
1833
check_tags_tab_first = gtk_check_button_new_with_label(_("Show tags tab first in the file info dialog"));
1834
gtk_widget_set_name(check_tags_tab_first, "check_on_notebook");
1835
if (options.tags_tab_first) {
1836
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tags_tab_first), TRUE);
1837
}
1838
gtk_box_pack_start(GTK_BOX(vbox_misc), check_tags_tab_first, FALSE, FALSE, 0);
1839
1840
1841
/* "Playlist" notebook page */
1842
1843
vbox_pl = gtk_vbox_new(FALSE, 3);
1844
gtk_container_set_border_width(GTK_CONTAINER(vbox_pl), 8);
1845
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_pl, create_notebook_tab(_("Playlist"), "playlist.png"));
1846
1847
check_playlist_is_embedded =
1848
gtk_check_button_new_with_label(_("Embed playlist into main window"));
1849
gtk_widget_set_name(check_playlist_is_embedded, "check_on_notebook");
1850
if (options.playlist_is_embedded_shadow) {
1851
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_playlist_is_embedded), TRUE);
1852
}
1853
gtk_box_pack_start(GTK_BOX(vbox_pl), check_playlist_is_embedded, FALSE, TRUE, 0);
1854
g_signal_connect (G_OBJECT (check_playlist_is_embedded), "toggled",
1855
G_CALLBACK (restart_active), _("Embed playlist into main window"));
1856
1857
check_autoplsave =
1858
gtk_check_button_new_with_label(_("Save and restore the playlist on exit/startup"));
1859
gtk_widget_set_name(check_autoplsave, "check_on_notebook");
1860
if (options.auto_save_playlist) {
1861
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_autoplsave), TRUE);
1862
}
1863
gtk_box_pack_start(GTK_BOX(vbox_pl), check_autoplsave, FALSE, TRUE, 0);
1864
1865
check_playlist_is_tree =
1866
gtk_check_button_new_with_label(_("Album mode is the default when adding entire records"));
1867
gtk_widget_set_name(check_playlist_is_tree, "check_on_notebook");
1868
if (options.playlist_is_tree) {
1869
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_playlist_is_tree), TRUE);
1870
}
1871
gtk_box_pack_start(GTK_BOX(vbox_pl), check_playlist_is_tree, FALSE, TRUE, 0);
1872
1873
check_album_shuffle_mode =
1874
gtk_check_button_new_with_label(_("When shuffling, records added in Album mode "
1875
"are played in order"));
1876
gtk_widget_set_name(check_album_shuffle_mode, "check_on_notebook");
1877
if (options.album_shuffle_mode) {
1878
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_album_shuffle_mode), TRUE);
1879
}
1880
gtk_box_pack_start(GTK_BOX(vbox_pl), check_album_shuffle_mode, FALSE, TRUE, 0);
1881
1882
check_enable_playlist_statusbar =
1883
gtk_check_button_new_with_label(_("Enable statusbar"));
1884
gtk_widget_set_name(check_enable_playlist_statusbar, "check_on_notebook");
1885
if (options.enable_playlist_statusbar_shadow) {
1886
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_enable_playlist_statusbar), TRUE);
1887
}
1888
g_signal_connect(G_OBJECT(check_enable_playlist_statusbar), "toggled",
1889
G_CALLBACK(restart_active), _("Enable statusbar in playlist"));
1890
gtk_box_pack_start(GTK_BOX(vbox_pl), check_enable_playlist_statusbar, FALSE, TRUE, 0);
1891
1892
check_pl_statusbar_show_size =
1893
gtk_check_button_new_with_label(_("Show soundfile size in statusbar"));
1894
gtk_widget_set_name(check_pl_statusbar_show_size, "check_on_notebook");
1895
if (options.pl_statusbar_show_size) {
1896
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_pl_statusbar_show_size), TRUE);
1897
}
1898
gtk_box_pack_start(GTK_BOX(vbox_pl), check_pl_statusbar_show_size, FALSE, TRUE, 0);
1899
1900
check_show_rva_in_playlist =
1901
gtk_check_button_new_with_label(_("Show RVA values"));
1902
gtk_widget_set_name(check_show_rva_in_playlist, "check_on_notebook");
1903
if (options.show_rva_in_playlist) {
1904
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_show_rva_in_playlist), TRUE);
1905
}
1906
gtk_box_pack_start(GTK_BOX(vbox_pl), check_show_rva_in_playlist, FALSE, TRUE, 0);
1907
1908
check_show_length_in_playlist =
1909
gtk_check_button_new_with_label(_("Show track lengths"));
1910
gtk_widget_set_name(check_show_length_in_playlist, "check_on_notebook");
1911
if (options.show_length_in_playlist) {
1912
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_show_length_in_playlist), TRUE);
1913
}
1914
gtk_box_pack_start(GTK_BOX(vbox_pl), check_show_length_in_playlist, FALSE, TRUE, 0);
1915
1916
check_show_active_track_name_in_bold =
1917
gtk_check_button_new_with_label(_("Show active track name in bold"));
1918
gtk_widget_set_name(check_show_active_track_name_in_bold, "check_on_notebook");
1919
track_name_in_bold_shadow = options.show_active_track_name_in_bold;
1920
if (options.show_active_track_name_in_bold) {
1921
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_show_active_track_name_in_bold), TRUE);
1922
}
1923
gtk_box_pack_start(GTK_BOX(vbox_pl), check_show_active_track_name_in_bold, FALSE, TRUE, 0);
1924
1925
check_enable_pl_rules_hint =
1926
gtk_check_button_new_with_label(_("Enable rules hint"));
1927
gtk_widget_set_name(check_enable_pl_rules_hint, "check_on_notebook");
1928
if (options.enable_pl_rules_hint) {
1929
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_enable_pl_rules_hint), TRUE);
1930
}
1931
gtk_box_pack_start(GTK_BOX(vbox_pl), check_enable_pl_rules_hint, FALSE, TRUE, 0);
1932
1933
frame_plistcol = gtk_frame_new(_("Playlist column order"));
1934
gtk_box_pack_start(GTK_BOX(vbox_pl), frame_plistcol, FALSE, TRUE, 5);
1935
1936
vbox_plistcol = gtk_vbox_new(FALSE, 0);
1937
gtk_container_set_border_width(GTK_CONTAINER(vbox_plistcol), 8);
1938
gtk_container_add(GTK_CONTAINER(frame_plistcol), vbox_plistcol);
1939
1940
label_plistcol = gtk_label_new(_("Drag and drop entries in the list below \n\
1941
to set the column order in the Playlist."));
1942
gtk_box_pack_start(GTK_BOX(vbox_plistcol), label_plistcol, FALSE, TRUE, 5);
1943
1944
1945
plistcol_store = gtk_list_store_new(2,
1946
G_TYPE_STRING, /* Column name */
1947
G_TYPE_STRING); /* Column index */
1948
1949
plistcol_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(plistcol_store));
1950
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(plistcol_list), FALSE);
1951
renderer = gtk_cell_renderer_text_new();
1952
column = gtk_tree_view_column_new_with_attributes(_("Column"),
1953
renderer,
1954
"text", 0,
1955
NULL);
1956
gtk_tree_view_append_column(GTK_TREE_VIEW(plistcol_list), column);
1957
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(plistcol_list), TRUE);
1958
1959
viewport = gtk_viewport_new(NULL, NULL);
1960
gtk_box_pack_start(GTK_BOX(vbox_plistcol), viewport, TRUE, TRUE, 5);
1961
1962
gtk_container_add(GTK_CONTAINER(viewport), plistcol_list);
1963
1964
for (i = 0; i < 3; i++) {
1965
switch (options.plcol_idx[i]) {
1966
case 0:
1967
gtk_list_store_append(plistcol_store, &iter);
1968
gtk_list_store_set(plistcol_store, &iter,
1969
0, _("Track titles"), 1, "0", -1);
1970
break;
1971
case 1:
1972
gtk_list_store_append(plistcol_store, &iter);
1973
gtk_list_store_set(plistcol_store, &iter,
1974
0, _("RVA values"), 1, "1", -1);
1975
break;
1976
case 2:
1977
gtk_list_store_append(plistcol_store, &iter);
1978
gtk_list_store_set(plistcol_store, &iter,
1979
0, _("Track lengths"), 1, "2", -1);
1980
break;
1981
}
1982
}
1983
1984
1985
/* "Music store" notebook page */
1986
1987
vbox_ms = gtk_vbox_new(FALSE, 3);
1988
gtk_container_set_border_width(GTK_CONTAINER(vbox_ms), 8);
1989
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_ms, create_notebook_tab(_("Music Store"), "music_store.png"));
1990
1991
check_hide_comment_pane =
1992
gtk_check_button_new_with_label(_("Hide comment pane"));
1993
gtk_widget_set_name(check_hide_comment_pane, "check_on_notebook");
1994
if (options.hide_comment_pane_shadow) {
1995
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_hide_comment_pane), TRUE);
1996
}
1997
gtk_box_pack_start(GTK_BOX(vbox_ms), check_hide_comment_pane, FALSE, FALSE, 0);
1998
g_signal_connect (G_OBJECT (check_hide_comment_pane), "toggled",
1999
G_CALLBACK (restart_active), _("Hide the Music Store comment pane"));
2000
2001
check_enable_mstore_toolbar =
2002
gtk_check_button_new_with_label(_("Enable toolbar"));
2003
gtk_widget_set_name(check_enable_mstore_toolbar, "check_on_notebook");
2004
if (options.enable_mstore_toolbar_shadow) {
2005
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_enable_mstore_toolbar), TRUE);
2006
}
2007
g_signal_connect(G_OBJECT(check_enable_mstore_toolbar), "toggled",
2008
G_CALLBACK(restart_active), _("Enable toolbar in Music Store"));
2009
gtk_box_pack_start(GTK_BOX(vbox_ms), check_enable_mstore_toolbar, FALSE, TRUE, 0);
2010
2011
check_enable_mstore_statusbar =
2012
gtk_check_button_new_with_label(_("Enable statusbar"));
2013
gtk_widget_set_name(check_enable_mstore_statusbar, "check_on_notebook");
2014
if (options.enable_mstore_statusbar_shadow) {
2015
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_enable_mstore_statusbar), TRUE);
2016
}
2017
g_signal_connect(G_OBJECT(check_enable_mstore_statusbar), "toggled",
2018
G_CALLBACK(restart_active), _("Enable statusbar in Music Store"));
2019
gtk_box_pack_start(GTK_BOX(vbox_ms), check_enable_mstore_statusbar, FALSE, TRUE, 0);
2020
2021
check_ms_statusbar_show_size =
2022
gtk_check_button_new_with_label(_("Show soundfile size in statusbar"));
2023
gtk_widget_set_name(check_ms_statusbar_show_size, "check_on_notebook");
2024
if (options.ms_statusbar_show_size) {
2025
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_ms_statusbar_show_size), TRUE);
2026
}
2027
gtk_box_pack_start(GTK_BOX(vbox_ms), check_ms_statusbar_show_size, FALSE, TRUE, 0);
2028
2029
2030
check_expand_stores = gtk_check_button_new_with_label(_("Expand Stores on startup"));
2031
gtk_widget_set_name(check_expand_stores, "check_on_notebook");
2032
if (options.autoexpand_stores) {
2033
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_expand_stores), TRUE);
2034
}
2035
gtk_box_pack_start(GTK_BOX(vbox_ms), check_expand_stores, FALSE, FALSE, 0);
2036
2037
check_enable_ms_rules_hint =
2038
gtk_check_button_new_with_label(_("Enable rules hint"));
2039
gtk_widget_set_name(check_enable_ms_rules_hint, "check_on_notebook");
2040
if (options.enable_ms_rules_hint) {
2041
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_enable_ms_rules_hint), TRUE);
2042
}
2043
gtk_box_pack_start(GTK_BOX(vbox_ms), check_enable_ms_rules_hint, FALSE, TRUE, 0);
2044
2045
check_enable_ms_tree_icons =
2046
gtk_check_button_new_with_label(_("Enable tree node icons"));
2047
gtk_widget_set_name(check_enable_ms_tree_icons, "check_on_notebook");
2048
if (options.enable_ms_tree_icons_shadow) {
2049
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_enable_ms_tree_icons), TRUE);
2050
}
2051
g_signal_connect (G_OBJECT (check_enable_ms_tree_icons), "toggled",
2052
G_CALLBACK (restart_active), _("Enable Music Store tree node icons"));
2053
gtk_box_pack_start(GTK_BOX(vbox_ms), check_enable_ms_tree_icons, FALSE, TRUE, 0);
2054
2055
frame_cart = gtk_frame_new(_("Cover art"));
2056
gtk_box_pack_start(GTK_BOX(vbox_ms), frame_cart, FALSE, TRUE, 5);
2057
2058
vbox_cart = gtk_vbox_new(FALSE, 3);
2059
gtk_container_set_border_width(GTK_CONTAINER(vbox_cart), 10);
2060
gtk_container_add(GTK_CONTAINER(frame_cart), vbox_cart);
2061
2062
hbox_cwidth = gtk_hbox_new(FALSE, 0);
2063
gtk_box_pack_start(GTK_BOX(vbox_cart), hbox_cwidth, FALSE, FALSE, 0);
2064
label_cwidth = gtk_label_new(_("Default cover width:"));
2065
gtk_box_pack_start(GTK_BOX(hbox_cwidth), label_cwidth, FALSE, FALSE, 0);
2066
2067
hbox_s = gtk_hbox_new(FALSE, 0);
2068
gtk_box_pack_start(GTK_BOX(hbox_cwidth), hbox_s, TRUE, TRUE, 3);
2069
2070
combo_cwidth = gtk_combo_box_new_text ();
2071
gtk_box_pack_start(GTK_BOX(hbox_cwidth), combo_cwidth, FALSE, FALSE, 0);
2072
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_cwidth), _("50 pixels"));
2073
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_cwidth), _("100 pixels"));
2074
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_cwidth), _("200 pixels"));
2075
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_cwidth), _("300 pixels"));
2076
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_cwidth), _("use browser window width"));
2077
2078
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_cwidth), options.cover_width);
2079
2080
check_magnify_smaller_images =
2081
gtk_check_button_new_with_label(_("Do not magnify images with smaller width"));
2082
gtk_widget_set_name(check_magnify_smaller_images, "check_on_notebook");
2083
if (!options.magnify_smaller_images) {
2084
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_magnify_smaller_images), TRUE);
2085
}
2086
gtk_box_pack_start(GTK_BOX(vbox_cart), check_magnify_smaller_images, FALSE, FALSE, 0);
2087
2088
2089
frame_ms_pathlist = gtk_frame_new(_("Paths to Music Store databases"));
2090
gtk_box_pack_start(GTK_BOX(vbox_ms), frame_ms_pathlist, FALSE, TRUE, 0);
2091
2092
vbox_ms_pathlist = gtk_vbox_new(FALSE, 0);
2093
gtk_container_set_border_width(GTK_CONTAINER(vbox_ms_pathlist), 10);
2094
gtk_container_add(GTK_CONTAINER(frame_ms_pathlist), vbox_ms_pathlist);
2095
2096
ms_pathlist_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ms_pathlist_store));
2097
ms_pathlist_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(ms_pathlist_view));
2098
2099
renderer = gtk_cell_renderer_text_new();
2100
column = gtk_tree_view_column_new_with_attributes(_("Path"), renderer,
2101
"text", 1,
2102
NULL);
2103
gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
2104
gtk_tree_view_append_column(GTK_TREE_VIEW(ms_pathlist_view), column);
2105
2106
renderer = gtk_cell_renderer_text_new();
2107
column = gtk_tree_view_column_new_with_attributes(_("Access"), renderer,
2108
"text", 2,
2109
NULL);
2110
gtk_tree_view_append_column(GTK_TREE_VIEW(ms_pathlist_view), column);
2111
2112
gtk_widget_set_size_request(ms_pathlist_view, -1, 100);
2113
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(ms_pathlist_view), TRUE);
2114
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(ms_pathlist_view), TRUE);
2115
2116
viewport = gtk_viewport_new(NULL, NULL);
2117
gtk_box_pack_start(GTK_BOX(vbox_ms_pathlist), viewport, FALSE, TRUE, 5);
2118
2119
scrolled_win = gtk_scrolled_window_new(NULL, NULL);
2120
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
2121
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2122
gtk_container_add(GTK_CONTAINER(viewport), scrolled_win);
2123
gtk_container_add(GTK_CONTAINER(scrolled_win), ms_pathlist_view);
2124
2125
hbox_ms_pathlist = gtk_hbox_new(FALSE, FALSE);
2126
gtk_box_pack_start(GTK_BOX(vbox_ms_pathlist), hbox_ms_pathlist, FALSE, FALSE, 0);
2127
2128
entry_ms_pathlist = gtk_entry_new();
2129
gtk_box_pack_start(GTK_BOX(hbox_ms_pathlist), entry_ms_pathlist, TRUE, TRUE, 2);
2130
2131
browse_ms_pathlist = gui_stock_label_button(_("Browse"), GTK_STOCK_OPEN);
2132
gtk_container_set_border_width(GTK_CONTAINER(browse_ms_pathlist), 2);
2133
g_signal_connect (G_OBJECT(browse_ms_pathlist), "clicked",
2134
G_CALLBACK(browse_ms_pathlist_clicked), (gpointer)entry_ms_pathlist);
2135
gtk_box_pack_end(GTK_BOX(hbox_ms_pathlist), browse_ms_pathlist, FALSE, FALSE, 0);
2136
2137
hbox_ms_pathlist_2 = gtk_hbox_new(FALSE, FALSE);
2138
gtk_box_pack_start(GTK_BOX(vbox_ms_pathlist), hbox_ms_pathlist_2, FALSE, FALSE, 0);
2139
2140
help_pathlist = gtk_button_new_from_stock (GTK_STOCK_HELP);
2141
gtk_container_set_border_width(GTK_CONTAINER(help_pathlist), 2);
2142
g_signal_connect(help_pathlist, "clicked", G_CALLBACK(display_pathlist_help), NULL);
2143
gtk_box_pack_start(GTK_BOX(hbox_ms_pathlist_2), help_pathlist, FALSE, FALSE, 0);
2144
2145
refresh_ms_pathlist = gui_stock_label_button(_("Refresh"), GTK_STOCK_REFRESH);
2146
gtk_container_set_border_width(GTK_CONTAINER(refresh_ms_pathlist), 2);
2147
g_signal_connect (G_OBJECT(refresh_ms_pathlist), "clicked",
2148
G_CALLBACK(refresh_ms_pathlist_clicked), NULL);
2149
gtk_box_pack_end(GTK_BOX(hbox_ms_pathlist_2), refresh_ms_pathlist, FALSE, FALSE, 0);
2150
2151
remove_ms_pathlist = gui_stock_label_button(_("Remove"), GTK_STOCK_REMOVE);
2152
gtk_container_set_border_width(GTK_CONTAINER(remove_ms_pathlist), 2);
2153
g_signal_connect (G_OBJECT(remove_ms_pathlist), "clicked",
2154
G_CALLBACK(remove_ms_pathlist_clicked), NULL);
2155
gtk_box_pack_end(GTK_BOX(hbox_ms_pathlist_2), remove_ms_pathlist, FALSE, FALSE, 0);
2156
2157
add_ms_pathlist = gui_stock_label_button(_("Add"), GTK_STOCK_ADD);
2158
gtk_container_set_border_width(GTK_CONTAINER(add_ms_pathlist), 2);
2159
g_signal_connect (G_OBJECT(add_ms_pathlist), "clicked",
2160
G_CALLBACK(add_ms_pathlist_clicked), NULL);
2161
gtk_box_pack_end(GTK_BOX(hbox_ms_pathlist_2), add_ms_pathlist, FALSE, FALSE, 0);
2162
2163
2164
/* "DSP" notebook page */
2165
2166
vbox_dsp = gtk_vbox_new(FALSE, 3);
2167
gtk_container_set_border_width(GTK_CONTAINER(vbox_dsp), 8);
2168
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_dsp, create_notebook_tab(_("DSP"), "dsp.png"));
2169
2170
frame_ladspa = gtk_frame_new(_("LADSPA plugin processing"));
2171
gtk_box_pack_start(GTK_BOX(vbox_dsp), frame_ladspa, FALSE, TRUE, 0);
2172
2173
vbox_ladspa = gtk_vbox_new(FALSE, 3);
2174
gtk_container_set_border_width(GTK_CONTAINER(vbox_ladspa), 10);
2175
gtk_container_add(GTK_CONTAINER(frame_ladspa), vbox_ladspa);
2176
2177
#ifdef HAVE_LADSPA
2178
combo_ladspa = gtk_combo_box_new_text ();
2179
gtk_box_pack_start(GTK_BOX(vbox_ladspa), combo_ladspa, TRUE, TRUE, 0);
2180
2181
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_ladspa), _("Pre Fader (before Volume & Balance)"));
2182
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_ladspa), _("Post Fader (after Volume & Balance)"));
2183
2184
status = options.ladspa_is_postfader;
2185
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_ladspa), status);
2186
g_signal_connect(combo_ladspa, "changed", G_CALLBACK(changed_ladspa_prepost), NULL);
2187
#else
2188
{
2189
GtkWidget * label = gtk_label_new(_("Aqualung is compiled without LADSPA plugin support.\n\
2190
See the About box and the documentation for details."));
2191
gtk_box_pack_start(GTK_BOX(vbox_ladspa), label, FALSE, TRUE, 5);
2192
}
2193
#endif /* HAVE_LADSPA */
2194
2195
2196
frame_src = gtk_frame_new(_("Sample Rate Converter type"));
2197
gtk_box_pack_start(GTK_BOX(vbox_dsp), frame_src, FALSE, TRUE, 5);
2198
2199
vbox_src = gtk_vbox_new(FALSE, 3);
2200
gtk_container_set_border_width(GTK_CONTAINER(vbox_src), 10);
2201
gtk_container_add(GTK_CONTAINER(frame_src), vbox_src);
2202
2203
label_src = gtk_label_new("");
2204
2205
#ifdef HAVE_SRC
2206
combo_src = gtk_combo_box_new_text ();
2207
gtk_box_pack_start(GTK_BOX(vbox_src), combo_src, TRUE, TRUE, 0);
2208
2209
{
2210
int i = 0;
2211
2212
while (src_get_name(i)) {
2213
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_src), src_get_name(i));
2214
++i;
2215
}
2216
2217
}
2218
2219
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_src), options.src_type);
2220
g_signal_connect(combo_src, "changed", G_CALLBACK(changed_src_type), NULL);
2221
2222
gtk_label_set_text(GTK_LABEL(label_src), src_get_description(options.src_type));
2223
#else
2224
gtk_label_set_text(GTK_LABEL(label_src),
2225
_("Aqualung is compiled without Sample Rate Converter support.\n\
2226
See the About box and the documentation for details."));
2227
2228
#endif /* HAVE_SRC */
2229
2230
gtk_box_pack_start(GTK_BOX(vbox_src), label_src, TRUE, TRUE, 0);
2231
2232
2233
/* "Playback RVA" notebook page */
2234
2235
vbox_rva = gtk_vbox_new(FALSE, 3);
2236
gtk_container_set_border_width(GTK_CONTAINER(vbox_rva), 8);
2237
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_rva, create_notebook_tab(_("Playback RVA"), "rva.png"));
2238
2239
check_rva_is_enabled = gtk_check_button_new_with_label(_("Enable playback RVA"));
2240
gtk_widget_set_name(check_rva_is_enabled, "check_on_notebook");
2241
if (options.rva_is_enabled) {
2242
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_rva_is_enabled), TRUE);
2243
}
2244
rva_is_enabled_shadow = options.rva_is_enabled;
2245
g_signal_connect(G_OBJECT(check_rva_is_enabled), "toggled",
2246
G_CALLBACK(check_rva_is_enabled_toggled), NULL);
2247
gtk_box_pack_start(GTK_BOX(vbox_rva), check_rva_is_enabled, FALSE, TRUE, 0);
2248
2249
2250
table_rva = gtk_table_new(8, 2, FALSE);
2251
gtk_box_pack_start(GTK_BOX(vbox_rva), table_rva, TRUE, TRUE, 5);
2252
2253
rva_viewport = gtk_viewport_new(NULL, NULL);
2254
gtk_widget_set_size_request(rva_viewport, 244, 244);
2255
gtk_table_attach(GTK_TABLE(table_rva), rva_viewport, 0, 2, 0, 1,
2256
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 5, 2);
2257
2258
rva_drawing_area = gtk_drawing_area_new();
2259
gtk_widget_set_size_request(GTK_WIDGET(rva_drawing_area), 240, 240);
2260
gtk_container_add(GTK_CONTAINER(rva_viewport), rva_drawing_area);
2261
2262
g_signal_connect(G_OBJECT(rva_drawing_area), "configure_event",
2263
G_CALLBACK(rva_configure_event), NULL);
2264
g_signal_connect(G_OBJECT(rva_drawing_area), "expose_event",
2265
G_CALLBACK(rva_expose_event), NULL);
2266
2267
hbox = gtk_hbox_new(FALSE, 0);
2268
label_listening_env = gtk_label_new(_("Listening environment:"));
2269
gtk_box_pack_start(GTK_BOX(hbox), label_listening_env, FALSE, FALSE, 0);
2270
gtk_table_attach(GTK_TABLE(table_rva), hbox, 0, 1, 1, 2,
2271
GTK_FILL, GTK_FILL, 5, 2);
2272
2273
combo_listening_env = gtk_combo_box_new_text ();
2274
gtk_table_attach(GTK_TABLE(table_rva), combo_listening_env, 1, 2, 1, 2,
2275
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 2);
2276
2277
2278
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_listening_env), _("Audiophile"));
2279
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_listening_env), _("Living room"));
2280
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_listening_env), _("Office"));
2281
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_listening_env), _("Noisy workshop"));
2282
2283
rva_env_shadow = options.rva_env;
2284
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_listening_env), options.rva_env);
2285
g_signal_connect(combo_listening_env, "changed", G_CALLBACK(changed_listening_env), NULL);
2286
2287
hbox = gtk_hbox_new(FALSE, 0);
2288
label_refvol = gtk_label_new(_("Reference volume [dBFS] :"));
2289
gtk_box_pack_start(GTK_BOX(hbox), label_refvol, FALSE, FALSE, 0);
2290
gtk_table_attach(GTK_TABLE(table_rva), hbox, 0, 1, 2, 3,
2291
GTK_FILL, GTK_FILL, 5, 2);
2292
2293
rva_refvol_shadow = options.rva_refvol;
2294
adj_refvol = gtk_adjustment_new(options.rva_refvol, -24.0f, 0.0f, 0.1f, 1.0f, 0.0f);
2295
spin_refvol = gtk_spin_button_new(GTK_ADJUSTMENT(adj_refvol), 0.1, 1);
2296
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin_refvol), TRUE);
2297
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spin_refvol), FALSE);
2298
g_signal_connect(G_OBJECT(adj_refvol), "value_changed",
2299
G_CALLBACK(refvol_changed), NULL);
2300
gtk_table_attach(GTK_TABLE(table_rva), spin_refvol, 1, 2, 2, 3,
2301
GTK_FILL, GTK_FILL, 5, 2);
2302
2303
hbox = gtk_hbox_new(FALSE, 0);
2304
label_steepness = gtk_label_new(_("Steepness [dB/dB] :"));
2305
gtk_box_pack_start(GTK_BOX(hbox), label_steepness, FALSE, FALSE, 0);
2306
gtk_table_attach(GTK_TABLE(table_rva), hbox, 0, 1, 3, 4,
2307
GTK_FILL, GTK_FILL, 5, 2);
2308
2309
rva_steepness_shadow = options.rva_steepness;
2310
adj_steepness = gtk_adjustment_new(options.rva_steepness, 0.0f, 1.0f, 0.01f, 0.1f, 0.0f);
2311
spin_steepness = gtk_spin_button_new(GTK_ADJUSTMENT(adj_steepness), 0.02, 2);
2312
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin_steepness), TRUE);
2313
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spin_steepness), FALSE);
2314
g_signal_connect(G_OBJECT(adj_steepness), "value_changed",
2315
G_CALLBACK(steepness_changed), NULL);
2316
gtk_table_attach(GTK_TABLE(table_rva), spin_steepness, 1, 2, 3, 4,
2317
GTK_FILL, GTK_FILL, 5, 2);
2318
2319
2320
2321
check_rva_use_averaging =
2322
gtk_check_button_new_with_label(_("Apply averaged RVA to tracks of the same record"));
2323
gtk_widget_set_name(check_rva_use_averaging, "check_on_notebook");
2324
if (options.rva_use_averaging) {
2325
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_rva_use_averaging), TRUE);
2326
}
2327
rva_use_averaging_shadow = options.rva_use_averaging;
2328
g_signal_connect(G_OBJECT(check_rva_use_averaging), "toggled",
2329
G_CALLBACK(check_rva_use_averaging_toggled), NULL);
2330
gtk_table_attach(GTK_TABLE(table_rva), check_rva_use_averaging, 0, 2, 4, 5,
2331
GTK_FILL, GTK_FILL, 5, 2);
2332
2333
hbox = gtk_hbox_new(FALSE, 0);
2334
label_threshold = gtk_label_new(_("Drop statistical aberrations based on"));
2335
gtk_box_pack_start(GTK_BOX(hbox), label_threshold, FALSE, FALSE, 0);
2336
gtk_table_attach(GTK_TABLE(table_rva), hbox, 0, 1, 5, 6,
2337
GTK_FILL, GTK_FILL, 5, 2);
2338
2339
combo_threshold = gtk_combo_box_new_text ();
2340
gtk_table_attach(GTK_TABLE(table_rva), combo_threshold, 1, 2, 5, 6,
2341
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 2);
2342
2343
2344
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_threshold), _("% of standard deviation"));
2345
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_threshold), _("Linear threshold [dB]"));
2346
2347
rva_use_linear_thresh_shadow = options.rva_use_linear_thresh;
2348
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_threshold), options.rva_use_linear_thresh);
2349
g_signal_connect(combo_threshold, "changed", G_CALLBACK(changed_threshold), NULL);
2350
2351
hbox = gtk_hbox_new(FALSE, 0);
2352
label_linthresh = gtk_label_new(_("Linear threshold [dB] :"));
2353
gtk_box_pack_start(GTK_BOX(hbox), label_linthresh, FALSE, FALSE, 0);
2354
gtk_table_attach(GTK_TABLE(table_rva), hbox, 0, 1, 6, 7,
2355
GTK_FILL, GTK_FILL, 5, 2);
2356
2357
rva_avg_linear_thresh_shadow = options.rva_avg_linear_thresh;
2358
adj_linthresh = gtk_adjustment_new(options.rva_avg_linear_thresh, 0.0f, 60.0f, 0.1f, 1.0f, 0.0f);
2359
spin_linthresh = gtk_spin_button_new(GTK_ADJUSTMENT(adj_linthresh), 0.1, 1);
2360
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin_linthresh), TRUE);
2361
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spin_linthresh), FALSE);
2362
g_signal_connect(G_OBJECT(adj_linthresh), "value_changed",
2363
G_CALLBACK(linthresh_changed), NULL);
2364
gtk_table_attach(GTK_TABLE(table_rva), spin_linthresh, 1, 2, 6, 7,
2365
GTK_FILL, GTK_FILL, 5, 2);
2366
2367
hbox = gtk_hbox_new(FALSE, 0);
2368
label_stdthresh = gtk_label_new(_("% of standard deviation :"));
2369
gtk_box_pack_start(GTK_BOX(hbox), label_stdthresh, FALSE, FALSE, 0);
2370
gtk_table_attach(GTK_TABLE(table_rva), hbox, 0, 1, 7, 8,
2371
GTK_FILL, GTK_FILL, 5, 2);
2372
2373
rva_avg_stddev_thresh_shadow = options.rva_avg_stddev_thresh;
2374
adj_stdthresh = gtk_adjustment_new(options.rva_avg_stddev_thresh * 100.0f,
2375
0.0f, 500.0f, 1.0f, 10.0f, 0.0f);
2376
spin_stdthresh = gtk_spin_button_new(GTK_ADJUSTMENT(adj_stdthresh), 0.5, 0);
2377
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin_stdthresh), TRUE);
2378
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spin_stdthresh), FALSE);
2379
g_signal_connect(G_OBJECT(adj_stdthresh), "value_changed",
2380
G_CALLBACK(stdthresh_changed), NULL);
2381
gtk_table_attach(GTK_TABLE(table_rva), spin_stdthresh, 1, 2, 7, 8,
2382
GTK_FILL, GTK_FILL, 5, 2);
2383
2384
2385
if (!rva_use_averaging_shadow) {
2386
gtk_widget_set_sensitive(combo_threshold, FALSE);
2387
gtk_widget_set_sensitive(label_threshold, FALSE);
2388
gtk_widget_set_sensitive(spin_linthresh, FALSE);
2389
gtk_widget_set_sensitive(label_linthresh, FALSE);
2390
gtk_widget_set_sensitive(spin_stdthresh, FALSE);
2391
gtk_widget_set_sensitive(label_stdthresh, FALSE);
2392
}
2393
2394
if (!rva_is_enabled_shadow) {
2395
gtk_widget_set_sensitive(combo_listening_env, FALSE);
2396
gtk_widget_set_sensitive(label_listening_env, FALSE);
2397
gtk_widget_set_sensitive(spin_refvol, FALSE);
2398
gtk_widget_set_sensitive(label_refvol, FALSE);
2399
gtk_widget_set_sensitive(spin_steepness, FALSE);
2400
gtk_widget_set_sensitive(label_steepness, FALSE);
2401
gtk_widget_set_sensitive(check_rva_use_averaging, FALSE);
2402
gtk_widget_set_sensitive(combo_threshold, FALSE);
2403
gtk_widget_set_sensitive(label_threshold, FALSE);
2404
gtk_widget_set_sensitive(spin_linthresh, FALSE);
2405
gtk_widget_set_sensitive(label_linthresh, FALSE);
2406
gtk_widget_set_sensitive(spin_stdthresh, FALSE);
2407
gtk_widget_set_sensitive(label_stdthresh, FALSE);
2408
}
2409
2410
/* "Metadata" notebook page */
2411
2412
vbox_meta = gtk_vbox_new(FALSE, 3);
2413
gtk_container_set_border_width(GTK_CONTAINER(vbox_meta), 8);
2414
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_meta, create_notebook_tab(_("Metadata"), "metadata.png"));
2415
2416
hbox = gtk_hbox_new(FALSE, 0);
2417
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 0);
2418
2419
label = gtk_label_new(_("When adding to playlist, use file metadata (if available) "
2420
"instead of\ninformation from the Music Store for:"));
2421
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3);
2422
2423
hbox = gtk_hbox_new(FALSE, 0);
2424
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 0);
2425
check_auto_use_meta_artist = gtk_check_button_new_with_label(_("Artist name"));
2426
gtk_widget_set_name(check_auto_use_meta_artist, "check_on_notebook");
2427
if (options.auto_use_meta_artist) {
2428
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_auto_use_meta_artist), TRUE);
2429
}
2430
gtk_box_pack_start(GTK_BOX(hbox), check_auto_use_meta_artist, FALSE, TRUE, 35);
2431
2432
hbox = gtk_hbox_new(FALSE, 0);
2433
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 0);
2434
check_auto_use_meta_record = gtk_check_button_new_with_label(_("Record name"));
2435
gtk_widget_set_name(check_auto_use_meta_record, "check_on_notebook");
2436
if (options.auto_use_meta_record) {
2437
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_auto_use_meta_record), TRUE);
2438
}
2439
gtk_box_pack_start(GTK_BOX(hbox), check_auto_use_meta_record, FALSE, TRUE, 35);
2440
2441
hbox = gtk_hbox_new(FALSE, 0);
2442
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 0);
2443
check_auto_use_meta_track = gtk_check_button_new_with_label(_("Track name"));
2444
gtk_widget_set_name(check_auto_use_meta_track, "check_on_notebook");
2445
if (options.auto_use_meta_track) {
2446
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_auto_use_meta_track), TRUE);
2447
}
2448
gtk_box_pack_start(GTK_BOX(hbox), check_auto_use_meta_track, FALSE, TRUE, 35);
2449
2450
2451
hbox = gtk_hbox_new(FALSE, 0);
2452
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 5);
2453
2454
label = gtk_label_new(_("When adding external files to playlist, use file metadata "
2455
"(if available) for:"));
2456
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3);
2457
2458
hbox = gtk_hbox_new(FALSE, 0);
2459
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 0);
2460
check_auto_use_ext_meta_artist = gtk_check_button_new_with_label(_("Artist name"));
2461
gtk_widget_set_name(check_auto_use_ext_meta_artist, "check_on_notebook");
2462
if (options.auto_use_ext_meta_artist) {
2463
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_auto_use_ext_meta_artist), TRUE);
2464
}
2465
gtk_box_pack_start(GTK_BOX(hbox), check_auto_use_ext_meta_artist, FALSE, TRUE, 35);
2466
2467
hbox = gtk_hbox_new(FALSE, 0);
2468
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 0);
2469
check_auto_use_ext_meta_record = gtk_check_button_new_with_label(_("Record name"));
2470
gtk_widget_set_name(check_auto_use_ext_meta_record, "check_on_notebook");
2471
if (options.auto_use_ext_meta_record) {
2472
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_auto_use_ext_meta_record), TRUE);
2473
}
2474
gtk_box_pack_start(GTK_BOX(hbox), check_auto_use_ext_meta_record, FALSE, TRUE, 35);
2475
2476
hbox = gtk_hbox_new(FALSE, 0);
2477
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 0);
2478
check_auto_use_ext_meta_track = gtk_check_button_new_with_label(_("Track name"));
2479
gtk_widget_set_name(check_auto_use_ext_meta_track, "check_on_notebook");
2480
if (options.auto_use_ext_meta_track) {
2481
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_auto_use_ext_meta_track), TRUE);
2482
}
2483
gtk_box_pack_start(GTK_BOX(hbox), check_auto_use_ext_meta_track, FALSE, TRUE, 35);
2484
2485
2486
hbox = gtk_hbox_new(FALSE, 0);
2487
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 5);
2488
2489
label = gtk_label_new(_("Replaygain tag to extract from Ogg Xiph and APE tags: "));
2490
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3);
2491
2492
2493
hbox = gtk_hbox_new(FALSE, 0);
2494
gtk_box_pack_start(GTK_BOX(vbox_meta), hbox, FALSE, TRUE, 0);
2495
2496
combo_replaygain = gtk_combo_box_new_text ();
2497
gtk_box_pack_start(GTK_BOX(hbox), combo_replaygain, FALSE, FALSE, 35);
2498
2499
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_replaygain), _("Replaygain_track_gain"));
2500
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_replaygain), _("Replaygain_album_gain"));
2501
2502
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_replaygain), options.replaygain_tag_to_use);
2503
2504
2505
/* CDDA notebook page */
2506
#ifdef HAVE_CDDA
2507
table_cdda = gtk_table_new(5, 3, FALSE);
2508
gtk_container_set_border_width(GTK_CONTAINER(table_cdda), 8);
2509
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table_cdda, create_notebook_tab(_("CD Audio"), "cdda.png"));
2510
2511
label = gtk_label_new(_("CD drive speed:"));
2512
hbox = gtk_hbox_new(FALSE, 0);
2513
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
2514
gtk_table_attach(GTK_TABLE(table_cdda), hbox, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 5, 3);
2515
2516
cdda_drive_speed_spinner = gtk_spin_button_new_with_range(1, 99, 1);
2517
gtk_spin_button_set_value(GTK_SPIN_BUTTON(cdda_drive_speed_spinner), options.cdda_drive_speed);
2518
gtk_table_attach(GTK_TABLE(table_cdda), cdda_drive_speed_spinner, 1, 2, 0, 1,
2519
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2520
2521
help_btn_cdda_drive_speed = gtk_button_new_from_stock(GTK_STOCK_HELP);
2522
g_signal_connect(help_btn_cdda_drive_speed, "clicked", G_CALLBACK(display_cdda_drive_speed_help), NULL);
2523
gtk_table_attach(GTK_TABLE(table_cdda), help_btn_cdda_drive_speed, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 5, 3);
2524
2525
frame_cdda = gtk_frame_new(_("Paranoia error correction"));
2526
gtk_table_attach(GTK_TABLE(table_cdda), frame_cdda, 0, 3, 1, 2,
2527
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2528
2529
vbox_cdda = gtk_vbox_new(FALSE, 3);
2530
gtk_container_set_border_width(GTK_CONTAINER(vbox_cdda), 8);
2531
gtk_container_add(GTK_CONTAINER(frame_cdda), vbox_cdda);
2532
2533
check_cdda_mode_overlap = gtk_check_button_new_with_label(_("Perform overlapped reads"));
2534
gtk_widget_set_name(check_cdda_mode_overlap, "check_on_notebook");
2535
gtk_box_pack_start(GTK_BOX(vbox_cdda), check_cdda_mode_overlap, FALSE, FALSE, 0);
2536
2537
check_cdda_mode_verify = gtk_check_button_new_with_label(_("Verify data integrity"));
2538
gtk_widget_set_name(check_cdda_mode_verify, "check_on_notebook");
2539
gtk_box_pack_start(GTK_BOX(vbox_cdda), check_cdda_mode_verify, FALSE, FALSE, 0);
2540
2541
check_cdda_mode_neverskip = gtk_check_button_new_with_label(_("Unlimited retry on failed reads (never skip)"));
2542
gtk_widget_set_name(check_cdda_mode_neverskip, "check_on_notebook");
2543
if (options.cdda_paranoia_mode & PARANOIA_MODE_NEVERSKIP) {
2544
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_cdda_mode_neverskip), TRUE);
2545
}
2546
gtk_box_pack_start(GTK_BOX(vbox_cdda), check_cdda_mode_neverskip, FALSE, FALSE, 0);
2547
g_signal_connect(check_cdda_mode_neverskip, "toggled", G_CALLBACK(cdda_toggled), NULL);
2548
2549
hbox_cdda = gtk_hbox_new(FALSE, 3);
2550
gtk_box_pack_start(GTK_BOX(vbox_cdda), hbox_cdda, FALSE, FALSE, 0);
2551
2552
label_cdda_maxretries = gtk_label_new(_("\tMaximum number of retries:"));
2553
hbox = gtk_hbox_new(FALSE, 0);
2554
gtk_box_pack_start(GTK_BOX(hbox), label_cdda_maxretries, FALSE, FALSE, 5);
2555
gtk_box_pack_start(GTK_BOX(hbox_cdda), hbox, FALSE, FALSE, 0);
2556
2557
cdda_paranoia_maxretries_spinner = gtk_spin_button_new_with_range(1, 50, 1);
2558
gtk_spin_button_set_value(GTK_SPIN_BUTTON(cdda_paranoia_maxretries_spinner), options.cdda_paranoia_maxretries);
2559
gtk_box_pack_start(GTK_BOX(hbox_cdda), cdda_paranoia_maxretries_spinner, FALSE, FALSE, 5);
2560
2561
check_cdda_force_drive_rescan =
2562
gtk_check_button_new_with_label(_("Force TOC re-read on every drive scan"));
2563
gtk_widget_set_name(check_cdda_force_drive_rescan, "check_on_notebook");
2564
gtk_table_attach(GTK_TABLE(table_cdda), check_cdda_force_drive_rescan, 0, 2, 2, 3,
2565
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2566
2567
help_btn_cdda_force_drive_rescan = gtk_button_new_from_stock(GTK_STOCK_HELP);
2568
g_signal_connect(help_btn_cdda_force_drive_rescan, "clicked", G_CALLBACK(display_cdda_force_drive_rescan_help), NULL);
2569
gtk_table_attach(GTK_TABLE(table_cdda), help_btn_cdda_force_drive_rescan, 2, 3, 2, 3, GTK_FILL, GTK_FILL, 5, 3);
2570
2571
check_cdda_add_to_playlist =
2572
gtk_check_button_new_with_label(_("Automatically add CDs to Playlist"));
2573
gtk_widget_set_name(check_cdda_add_to_playlist, "check_on_notebook");
2574
gtk_table_attach(GTK_TABLE(table_cdda), check_cdda_add_to_playlist, 0, 3, 3, 4,
2575
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2576
2577
check_cdda_remove_from_playlist =
2578
gtk_check_button_new_with_label(_("Automatically remove CDs from Playlist"));
2579
gtk_widget_set_name(check_cdda_remove_from_playlist, "check_on_notebook");
2580
gtk_table_attach(GTK_TABLE(table_cdda), check_cdda_remove_from_playlist, 0, 3, 4, 5,
2581
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2582
2583
if (options.cdda_force_drive_rescan) {
2584
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_cdda_force_drive_rescan), TRUE);
2585
}
2586
2587
if (options.cdda_paranoia_mode & PARANOIA_MODE_OVERLAP) {
2588
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_cdda_mode_overlap), TRUE);
2589
}
2590
2591
if (options.cdda_paranoia_mode & PARANOIA_MODE_VERIFY) {
2592
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_cdda_mode_verify), TRUE);
2593
}
2594
2595
if (options.cdda_paranoia_mode & PARANOIA_MODE_NEVERSKIP) {
2596
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_cdda_mode_neverskip), TRUE);
2597
gtk_widget_set_sensitive(cdda_paranoia_maxretries_spinner, FALSE);
2598
gtk_widget_set_sensitive(label_cdda_maxretries, FALSE);
2599
}
2600
2601
if (options.cdda_add_to_playlist) {
2602
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_cdda_add_to_playlist), TRUE);
2603
}
2604
2605
if (options.cdda_remove_from_playlist) {
2606
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_cdda_remove_from_playlist), TRUE);
2607
}
2608
2609
#endif /* HAVE_CDDA */
2610
2611
2612
/* CDDB notebook page */
2613
2614
#ifdef HAVE_CDDB
2615
table_cddb = gtk_table_new(8, 2, FALSE);
2616
gtk_container_set_border_width(GTK_CONTAINER(table_cddb), 8);
2617
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table_cddb, create_notebook_tab(_("CDDB"), "cddb.png"));
2618
2619
label = gtk_label_new(_("CDDB server:"));
2620
hbox = gtk_hbox_new(FALSE, 0);
2621
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
2622
gtk_table_attach(GTK_TABLE(table_cddb), hbox, 0, 1, 0, 1,
2623
GTK_FILL, GTK_FILL, 5, 3);
2624
2625
cddb_server_entry = gtk_entry_new();
2626
gtk_entry_set_text(GTK_ENTRY(cddb_server_entry), options.cddb_server);
2627
gtk_table_attach(GTK_TABLE(table_cddb), cddb_server_entry, 1, 2, 0, 1,
2628
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2629
2630
label = gtk_label_new(_("Connection timeout [sec]:"));
2631
hbox = gtk_hbox_new(FALSE, 0);
2632
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
2633
gtk_table_attach(GTK_TABLE(table_cddb), hbox, 0, 1, 1, 2,
2634
GTK_FILL, GTK_FILL, 5, 3);
2635
2636
cddb_tout_spinner = gtk_spin_button_new_with_range(1, 60, 1);
2637
gtk_spin_button_set_value(GTK_SPIN_BUTTON(cddb_tout_spinner), options.cddb_timeout);
2638
gtk_table_attach(GTK_TABLE(table_cddb), cddb_tout_spinner, 1, 2, 1, 2,
2639
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2640
2641
label = gtk_label_new(_("Email address for submission:"));
2642
hbox = gtk_hbox_new(FALSE, 0);
2643
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
2644
gtk_table_attach(GTK_TABLE(table_cddb), hbox, 0, 1, 2, 3,
2645
GTK_FILL, GTK_FILL, 5, 3);
2646
2647
cddb_email_entry = gtk_entry_new();
2648
gtk_entry_set_text(GTK_ENTRY(cddb_email_entry), options.cddb_email);
2649
gtk_table_attach(GTK_TABLE(table_cddb), cddb_email_entry, 1, 2, 2, 3,
2650
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2651
2652
label = gtk_label_new(_("Local CDDB directory:"));
2653
hbox = gtk_hbox_new(FALSE, 0);
2654
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
2655
gtk_table_attach(GTK_TABLE(table_cddb), hbox, 0, 1, 3, 4,
2656
GTK_FILL, GTK_FILL, 5, 3);
2657
2658
cddb_local_entry = gtk_entry_new();
2659
gtk_entry_set_text(GTK_ENTRY(cddb_local_entry), options.cddb_local);
2660
gtk_table_attach(GTK_TABLE(table_cddb), cddb_local_entry, 1, 2, 3, 4,
2661
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2662
2663
cddb_local_check =
2664
gtk_check_button_new_with_label(_("Use the local database only"));
2665
gtk_widget_set_name(cddb_local_check, "check_on_notebook");
2666
gtk_table_attach(GTK_TABLE(table_cddb), cddb_local_check, 0, 2, 4, 5,
2667
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2668
if (options.cddb_cache_only) {
2669
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cddb_local_check), TRUE);
2670
} else {
2671
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cddb_local_check), FALSE);
2672
}
2673
2674
2675
cddb_radio_direct = gtk_radio_button_new_with_label(NULL, _("Direct connection to CDDB server"));
2676
gtk_widget_set_name(cddb_radio_direct, "check_on_notebook");
2677
g_signal_connect(G_OBJECT(cddb_radio_direct), "toggled",
2678
G_CALLBACK(cddb_radio_direct_toggled), NULL);
2679
gtk_table_attach(GTK_TABLE(table_cddb), cddb_radio_direct, 0, 2, 5, 6,
2680
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2681
2682
cddb_label_proto = gtk_label_new(_("Protocol for querying:"));
2683
hbox = gtk_hbox_new(FALSE, 0);
2684
gtk_box_pack_start(GTK_BOX(hbox), cddb_label_proto, FALSE, FALSE, 0);
2685
gtk_table_attach(GTK_TABLE(table_cddb), hbox, 0, 1, 6, 7,
2686
GTK_FILL, GTK_FILL, 35, 3);
2687
2688
cddb_proto_combo = gtk_combo_box_new_text();
2689
gtk_combo_box_append_text(GTK_COMBO_BOX(cddb_proto_combo), _("CDDBP (port 888)"));
2690
gtk_combo_box_append_text(GTK_COMBO_BOX(cddb_proto_combo), _("HTTP (port 80)"));
2691
if (options.cddb_use_http) {
2692
gtk_combo_box_set_active(GTK_COMBO_BOX(cddb_proto_combo), 1);
2693
} else {
2694
gtk_combo_box_set_active(GTK_COMBO_BOX(cddb_proto_combo), 0);
2695
}
2696
gtk_table_attach(GTK_TABLE(table_cddb), cddb_proto_combo, 1, 2, 6, 7,
2697
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2698
2699
cddb_radio_proxy = gtk_radio_button_new_with_label_from_widget(
2700
GTK_RADIO_BUTTON(cddb_radio_direct), _("HTTP tunneling through proxy"));
2701
gtk_widget_set_name(cddb_radio_proxy, "check_on_notebook");
2702
gtk_table_attach(GTK_TABLE(table_cddb), cddb_radio_proxy, 0, 2, 7, 8,
2703
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2704
2705
cddb_label_proxy = gtk_label_new(_("HTTP proxy:"));
2706
hbox = gtk_hbox_new(FALSE, 0);
2707
gtk_box_pack_start(GTK_BOX(hbox), cddb_label_proxy, FALSE, FALSE, 0);
2708
gtk_table_attach(GTK_TABLE(table_cddb), hbox, 0, 1, 8, 9,
2709
GTK_FILL, GTK_FILL, 35, 3);
2710
2711
cddb_proxy_entry = gtk_entry_new();
2712
gtk_entry_set_text(GTK_ENTRY(cddb_proxy_entry), options.cddb_proxy);
2713
gtk_table_attach(GTK_TABLE(table_cddb), cddb_proxy_entry, 1, 2, 8, 9,
2714
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2715
2716
cddb_label_proxy_port = gtk_label_new(_("Port:"));
2717
hbox = gtk_hbox_new(FALSE, 0);
2718
gtk_box_pack_start(GTK_BOX(hbox), cddb_label_proxy_port, FALSE, FALSE, 0);
2719
gtk_table_attach(GTK_TABLE(table_cddb), hbox, 0, 1, 9, 10,
2720
GTK_FILL, GTK_FILL, 35, 3);
2721
2722
cddb_proxy_port_spinner = gtk_spin_button_new_with_range(0, 65535, 1);
2723
gtk_spin_button_set_value(GTK_SPIN_BUTTON(cddb_proxy_port_spinner), options.cddb_proxy_port);
2724
gtk_table_attach(GTK_TABLE(table_cddb), cddb_proxy_port_spinner, 1, 2, 9, 10,
2725
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 3);
2726
2727
if (options.cddb_use_proxy) {
2728
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cddb_radio_direct), TRUE);
2729
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cddb_radio_proxy), TRUE);
2730
} else {
2731
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cddb_radio_proxy), TRUE);
2732
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cddb_radio_direct), TRUE);
2733
}
2734
2735
#endif /* HAVE_CDDB */
2736
2737
/* Appearance notebook page */
2738
2739
override_shadow = options.override_skin_settings;
2740
2741
vbox_appearance = gtk_vbox_new(FALSE, 3);
2742
gtk_container_set_border_width(GTK_CONTAINER(vbox_appearance), 8);
2743
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox_appearance, create_notebook_tab(_("Appearance"), "appearance.png"));
2744
2745
check_override_skin =
2746
gtk_check_button_new_with_label(_("Override skin settings"));
2747
2748
gtk_widget_set_name(check_override_skin, "check_on_notebook");
2749
if (options.override_skin_settings) {
2750
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_override_skin), TRUE);
2751
}
2752
gtk_box_pack_start(GTK_BOX(vbox_appearance), check_override_skin, FALSE, FALSE, 0);
2753
g_signal_connect (G_OBJECT (check_override_skin), "toggled",
2754
G_CALLBACK (cb_toggle_override_skin), NULL);
2755
2756
frame_fonts = gtk_frame_new(_("Fonts"));
2757
gtk_box_pack_start(GTK_BOX(vbox_appearance), frame_fonts, FALSE, TRUE, 5);
2758
2759
vbox_fonts = gtk_vbox_new(FALSE, 3);
2760
gtk_container_set_border_width(GTK_CONTAINER(vbox_fonts), 5);
2761
gtk_container_add(GTK_CONTAINER(frame_fonts), vbox_fonts);
2762
2763
/* playlist font */
2764
2765
hbox = gtk_hbox_new(FALSE, 5);
2766
gtk_box_pack_start(GTK_BOX(vbox_fonts), hbox, FALSE, FALSE, 0);
2767
2768
label = gtk_label_new(_("Playlist: "));
2769
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
2770
gtk_size_group_add_widget(label_size, label);
2771
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2772
2773
entry_pl_font = gtk_entry_new();
2774
GTK_WIDGET_UNSET_FLAGS(entry_pl_font, GTK_CAN_FOCUS);
2775
gtk_box_pack_start(GTK_BOX(hbox), entry_pl_font, TRUE, TRUE, 0);
2776
gtk_editable_set_editable(GTK_EDITABLE(entry_pl_font), FALSE);
2777
2778
if (strlen(options.playlist_font)) {
2779
gtk_entry_set_text(GTK_ENTRY(entry_pl_font), options.playlist_font);
2780
} else {
2781
gtk_entry_set_text(GTK_ENTRY(entry_pl_font), DEFAULT_FONT_NAME);
2782
strcpy(options.playlist_font, DEFAULT_FONT_NAME);
2783
}
2784
2785
button_pl_font = gui_stock_label_button(_("Select"), GTK_STOCK_SELECT_FONT);
2786
gtk_box_pack_start(GTK_BOX(hbox), button_pl_font, FALSE, FALSE, 0);
2787
g_signal_connect (G_OBJECT (button_pl_font), "clicked",
2788
G_CALLBACK (playlist_font_select), NULL);
2789
2790
/* music store font */
2791
2792
hbox = gtk_hbox_new(FALSE, 5);
2793
gtk_box_pack_start(GTK_BOX(vbox_fonts), hbox, FALSE, TRUE, 0);
2794
2795
label = gtk_label_new(_("Music Store: "));
2796
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
2797
gtk_size_group_add_widget(label_size, label);
2798
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2799
2800
entry_ms_font = gtk_entry_new();
2801
GTK_WIDGET_UNSET_FLAGS(entry_ms_font, GTK_CAN_FOCUS);
2802
gtk_box_pack_start(GTK_BOX(hbox), entry_ms_font, TRUE, TRUE, 0);
2803
gtk_editable_set_editable(GTK_EDITABLE(entry_ms_font), FALSE);
2804
2805
if (strlen(options.browser_font)) {
2806
2807
gtk_entry_set_text(GTK_ENTRY(entry_ms_font), options.browser_font);
2808
2809
} else {
2810
2811
gtk_entry_set_text(GTK_ENTRY(entry_ms_font), DEFAULT_FONT_NAME);
2812
strcpy(options.browser_font, DEFAULT_FONT_NAME);
2813
2814
}
2815
2816
button_ms_font = gui_stock_label_button(_("Select"), GTK_STOCK_SELECT_FONT);
2817
gtk_box_pack_start(GTK_BOX(hbox), button_ms_font, FALSE, FALSE, 0);
2818
g_signal_connect (G_OBJECT (button_ms_font), "clicked",
2819
G_CALLBACK (browser_font_select), NULL);
2820
2821
2822
/* big timer font */
2823
2824
hbox = gtk_hbox_new(FALSE, 5);
2825
gtk_box_pack_start(GTK_BOX(vbox_fonts), hbox, FALSE, TRUE, 0);
2826
2827
label = gtk_label_new(_("Big timer: "));
2828
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
2829
gtk_size_group_add_widget(label_size, label);
2830
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2831
2832
entry_bt_font = gtk_entry_new();
2833
GTK_WIDGET_UNSET_FLAGS(entry_bt_font, GTK_CAN_FOCUS);
2834
gtk_box_pack_start(GTK_BOX(hbox), entry_bt_font, TRUE, TRUE, 0);
2835
gtk_editable_set_editable(GTK_EDITABLE(entry_bt_font), FALSE);
2836
2837
if (strlen(options.bigtimer_font)) {
2838
2839
gtk_entry_set_text(GTK_ENTRY(entry_bt_font), options.bigtimer_font);
2840
2841
} else {
2842
2843
gtk_entry_set_text(GTK_ENTRY(entry_bt_font), DEFAULT_FONT_NAME);
2844
strcpy(options.bigtimer_font, DEFAULT_FONT_NAME);
2845
2846
}
2847
2848
button_bt_font = gui_stock_label_button(_("Select"), GTK_STOCK_SELECT_FONT);
2849
gtk_box_pack_start(GTK_BOX(hbox), button_bt_font, FALSE, FALSE, 0);
2850
g_signal_connect (G_OBJECT (button_bt_font), "clicked",
2851
G_CALLBACK (bigtimer_font_select), NULL);
2852
2853
/* small timer font */
2854
2855
hbox = gtk_hbox_new(FALSE, 5);
2856
gtk_box_pack_start(GTK_BOX(vbox_fonts), hbox, FALSE, TRUE, 0);
2857
2858
label = gtk_label_new(_("Small timers: "));
2859
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
2860
gtk_size_group_add_widget(label_size, label);
2861
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2862
2863
entry_st_font = gtk_entry_new();
2864
GTK_WIDGET_UNSET_FLAGS(entry_st_font, GTK_CAN_FOCUS);
2865
gtk_box_pack_start(GTK_BOX(hbox), entry_st_font, TRUE, TRUE, 0);
2866
gtk_editable_set_editable(GTK_EDITABLE(entry_st_font), FALSE);
2867
2868
if (strlen(options.smalltimer_font)) {
2869
2870
gtk_entry_set_text(GTK_ENTRY(entry_st_font), options.smalltimer_font);
2871
2872
} else {
2873
2874
gtk_entry_set_text(GTK_ENTRY(entry_st_font), DEFAULT_FONT_NAME);
2875
strcpy(options.smalltimer_font, DEFAULT_FONT_NAME);
2876
2877
}
2878
2879
button_st_font = gui_stock_label_button(_("Select"), GTK_STOCK_SELECT_FONT);
2880
gtk_box_pack_start(GTK_BOX(hbox), button_st_font, FALSE, FALSE, 0);
2881
g_signal_connect (G_OBJECT (button_st_font), "clicked",
2882
G_CALLBACK (smalltimer_font_select), NULL);
2883
2884
/* song title font */
2885
2886
hbox = gtk_hbox_new(FALSE, 5);
2887
gtk_box_pack_start(GTK_BOX(vbox_fonts), hbox, FALSE, TRUE, 0);
2888
2889
label = gtk_label_new(_("Song title: "));
2890
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
2891
gtk_size_group_add_widget(label_size, label);
2892
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2893
2894
entry_songt_font = gtk_entry_new();
2895
GTK_WIDGET_UNSET_FLAGS(entry_songt_font, GTK_CAN_FOCUS);
2896
gtk_box_pack_start(GTK_BOX(hbox), entry_songt_font, TRUE, TRUE, 0);
2897
gtk_editable_set_editable(GTK_EDITABLE(entry_songt_font), FALSE);
2898
2899
if (strlen(options.songtitle_font)) {
2900
2901
gtk_entry_set_text(GTK_ENTRY(entry_songt_font), options.songtitle_font);
2902
2903
} else {
2904
2905
gtk_entry_set_text(GTK_ENTRY(entry_songt_font), DEFAULT_FONT_NAME);
2906
strcpy(options.songtitle_font, DEFAULT_FONT_NAME);
2907
2908
}
2909
2910
button_songt_font = gui_stock_label_button(_("Select"), GTK_STOCK_SELECT_FONT);
2911
gtk_box_pack_start(GTK_BOX(hbox), button_songt_font, FALSE, FALSE, 0);
2912
g_signal_connect (G_OBJECT (button_songt_font), "clicked",
2913
G_CALLBACK (songtitle_font_select), NULL);
2914
2915
/* song info font */
2916
2917
hbox = gtk_hbox_new(FALSE, 5);
2918
gtk_box_pack_start(GTK_BOX(vbox_fonts), hbox, FALSE, TRUE, 0);
2919
2920
label = gtk_label_new(_("Song info: "));
2921
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
2922
gtk_size_group_add_widget(label_size, label);
2923
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2924
2925
entry_si_font = gtk_entry_new();
2926
GTK_WIDGET_UNSET_FLAGS(entry_si_font, GTK_CAN_FOCUS);
2927
gtk_box_pack_start(GTK_BOX(hbox), entry_si_font, TRUE, TRUE, 0);
2928
gtk_editable_set_editable(GTK_EDITABLE(entry_si_font), FALSE);
2929
2930
if (strlen(options.songinfo_font)) {
2931
2932
gtk_entry_set_text(GTK_ENTRY(entry_si_font), options.songinfo_font);
2933
2934
} else {
2935
2936
gtk_entry_set_text(GTK_ENTRY(entry_si_font), DEFAULT_FONT_NAME);
2937
strcpy(options.songinfo_font, DEFAULT_FONT_NAME);
2938
2939
}
2940
2941
button_si_font = gui_stock_label_button(_("Select"), GTK_STOCK_SELECT_FONT);
2942
gtk_box_pack_start(GTK_BOX(hbox), button_si_font, FALSE, FALSE, 0);
2943
g_signal_connect (G_OBJECT (button_si_font), "clicked",
2944
G_CALLBACK (songinfo_font_select), NULL);
2945
2946
/* statusbar font */
2947
2948
hbox = gtk_hbox_new(FALSE, 5);
2949
gtk_box_pack_start(GTK_BOX(vbox_fonts), hbox, FALSE, TRUE, 0);
2950
2951
label = gtk_label_new(_("Statusbar: "));
2952
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
2953
gtk_size_group_add_widget(label_size, label);
2954
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2955
2956
entry_sb_font = gtk_entry_new();
2957
GTK_WIDGET_UNSET_FLAGS(entry_sb_font, GTK_CAN_FOCUS);
2958
gtk_box_pack_start(GTK_BOX(hbox), entry_sb_font, TRUE, TRUE, 0);
2959
gtk_editable_set_editable(GTK_EDITABLE(entry_sb_font), FALSE);
2960
2961
if (strlen(options.statusbar_font)) {
2962
2963
gtk_entry_set_text(GTK_ENTRY(entry_sb_font), options.statusbar_font);
2964
2965
} else {
2966
2967
gtk_entry_set_text(GTK_ENTRY(entry_sb_font), DEFAULT_FONT_NAME);
2968
strcpy(options.statusbar_font, DEFAULT_FONT_NAME);
2969
2970
}
2971
2972
button_sb_font = gui_stock_label_button(_("Select"), GTK_STOCK_SELECT_FONT);
2973
gtk_box_pack_start(GTK_BOX(hbox), button_sb_font, FALSE, FALSE, 0);
2974
g_signal_connect (G_OBJECT (button_sb_font), "clicked",
2975
G_CALLBACK (statusbar_font_select), NULL);
2976
2977
/* colors */
2978
2979
frame_colors = gtk_frame_new(_("Colors"));
2980
gtk_box_pack_start(GTK_BOX(vbox_appearance), frame_colors, FALSE, TRUE, 5);
2981
2982
vbox_colors = gtk_vbox_new(FALSE, 3);
2983
gtk_container_set_border_width(GTK_CONTAINER(vbox_colors), 5);
2984
gtk_container_add(GTK_CONTAINER(frame_colors), vbox_colors);
2985
2986
/* active song */
2987
2988
hbox = gtk_hbox_new(FALSE, 5);
2989
gtk_box_pack_start(GTK_BOX(vbox_colors), hbox, FALSE, TRUE, 0);
2990
2991
label = gtk_label_new(_("Active song in playlist: "));
2992
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
2993
gtk_size_group_add_widget(label_size, label);
2994
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2995
2996
hbox_s = gtk_hbox_new(FALSE, 0);
2997
gtk_box_pack_start(GTK_BOX(hbox), hbox_s, TRUE, TRUE, 0);
2998
2999
if (gdk_color_parse(options.activesong_color, &color) == FALSE) {
3000
3001
color.red = play_list->style->fg[SELECTED].red;
3002
color.green = play_list->style->fg[SELECTED].green;
3003
color.blue = play_list->style->fg[SELECTED].blue;
3004
color.pixel = (gulong)((color.red & 0xff00)*256 + (color.green & 0xff00) + (color.blue & 0xff00)/256);
3005
}
3006
3007
color_picker = gtk_color_button_new_with_color (&color);
3008
gtk_widget_set_size_request(GTK_WIDGET(color_picker), 60, -1);
3009
gtk_box_pack_start(GTK_BOX(hbox), color_picker, FALSE, TRUE, 0);
3010
g_signal_connect (G_OBJECT (color_picker), "color-set",
3011
G_CALLBACK (color_selected), NULL);
3012
3013
3014
set_sensitive_part();
3015
3016
/* end of notebook */
3017
3018
gtk_widget_show_all(options_window);
3019
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), current_notebook_page);
3020
3021
if (aqualung_dialog_run(GTK_DIALOG(options_window)) == GTK_RESPONSE_ACCEPT) {
3022
options_window_accept();
3023
3024
if (reskin_flag) {
3025
change_skin(options.skin);
3026
}
3027
} else {
3028
gtk_widget_destroy(options_window);
3029
}
3030
}
3031
3032
3033
#define SAVE_STR(Var) \
3034
xmlNewTextChild(root, NULL, (const xmlChar *) #Var, (xmlChar *) options.Var);
3035
3036
#define SAVE_FONT(Font) \
3037
snprintf(str, MAX_FONTNAME_LEN, "%s", options.Font); \
3038
xmlNewTextChild(root, NULL, (const xmlChar *) #Font, (xmlChar *) str);
3039
3040
#define SAVE_COLOR(Color) \
3041
snprintf(str, MAX_COLORNAME_LEN, "%s", options.Color); \
3042
xmlNewTextChild(root, NULL, (const xmlChar *) #Color, (xmlChar *) str);
3043
3044
#define SAVE_INT(Var) \
3045
snprintf(str, 31, "%d", options.Var); \
3046
xmlNewTextChild(root, NULL, (const xmlChar *) #Var, (xmlChar *) str);
3047
3048
#define SAVE_INT_ARRAY(Var, Idx) \
3049
snprintf(str, 31, "%d", options.Var[Idx]); \
3050
xmlNewTextChild(root, NULL, (const xmlChar *) #Var "_" #Idx, (xmlChar *) str);
3051
3052
#define SAVE_INT_SH(Var) \
3053
snprintf(str, 31, "%d", options.Var##_shadow); \
3054
xmlNewTextChild(root, NULL, (const xmlChar *) #Var, (xmlChar *) str);
3055
3056
#define SAVE_FLOAT(Var) \
3057
snprintf(str, 31, "%f", options.Var); \
3058
xmlNewTextChild(root, NULL, (const xmlChar *) #Var, (xmlChar *) str);
3059
3060
3061
void
3062
save_config(void) {
3063
3064
xmlDocPtr doc;
3065
xmlNodePtr root;
3066
int c, d;
3067
FILE * fin;
3068
FILE * fout;
3069
char tmpname[MAXLEN];
3070
char config_file[MAXLEN];
3071
char str[32];
3072
3073
GtkTreeIter iter;
3074
int i = 0;
3075
char * path;
3076
3077
sprintf(config_file, "%s/config.xml", options.confdir);
3078
3079
doc = xmlNewDoc((const xmlChar *) "1.0");
3080
root = xmlNewNode(NULL, (const xmlChar *) "aqualung_config");
3081
xmlDocSetRootElement(doc, root);
3082
3083
3084
SAVE_STR(currdir);
3085
SAVE_STR(default_param);
3086
SAVE_STR(title_format);
3087
SAVE_STR(skin);
3088
SAVE_INT(src_type);
3089
SAVE_INT(ladspa_is_postfader);
3090
SAVE_INT(auto_save_playlist);
3091
SAVE_INT(show_rva_in_playlist);
3092
SAVE_INT(pl_statusbar_show_size);
3093
SAVE_INT(ms_statusbar_show_size);
3094
SAVE_INT(show_length_in_playlist);
3095
SAVE_INT(show_active_track_name_in_bold);
3096
SAVE_INT(enable_pl_rules_hint);
3097
SAVE_INT(enable_ms_rules_hint);
3098
SAVE_INT_SH(enable_ms_tree_icons);
3099
SAVE_INT(auto_use_meta_artist);
3100
SAVE_INT(auto_use_meta_record);
3101
SAVE_INT(auto_use_meta_track);
3102
SAVE_INT(auto_use_ext_meta_artist);
3103
SAVE_INT(auto_use_ext_meta_record);
3104
SAVE_INT(auto_use_ext_meta_track);
3105
SAVE_INT(enable_tooltips);
3106
SAVE_INT_SH(buttons_at_the_bottom);
3107
SAVE_INT(disable_buttons_relief);
3108
SAVE_INT_SH(simple_view_in_fx);
3109
SAVE_INT(show_sn_title);
3110
SAVE_INT(united_minimization);
3111
SAVE_INT(magnify_smaller_images);
3112
SAVE_INT(cover_width);
3113
SAVE_INT_SH(hide_comment_pane);
3114
SAVE_INT_SH(enable_mstore_toolbar);
3115
SAVE_INT_SH(enable_mstore_statusbar);
3116
SAVE_INT(autoexpand_stores);
3117
SAVE_INT(show_hidden);
3118
SAVE_INT(main_window_always_on_top);
3119
SAVE_INT(tags_tab_first);
3120
SAVE_INT(override_skin_settings);
3121
SAVE_INT(replaygain_tag_to_use);
3122
SAVE_FLOAT(vol);
3123
SAVE_FLOAT(bal);
3124
SAVE_INT(rva_is_enabled);
3125
SAVE_INT(rva_env);
3126
SAVE_FLOAT(rva_refvol);
3127
SAVE_FLOAT(rva_steepness);
3128
SAVE_INT(rva_use_averaging);
3129
SAVE_INT(rva_use_linear_thresh);
3130
SAVE_FLOAT(rva_avg_linear_thresh);
3131
SAVE_FLOAT(rva_avg_stddev_thresh);
3132
SAVE_INT(main_pos_x);
3133
SAVE_INT(main_pos_y);
3134
SAVE_INT(main_size_x);
3135
3136
if (options.playlist_is_embedded && !options.playlist_is_embedded_shadow && options.playlist_on) {
3137
snprintf(str, 31, "%d", options.main_size_y - playlist_window->allocation.height - 6);
3138
} else {
3139
snprintf(str, 31, "%d", options.main_size_y);
3140
}
3141
xmlNewTextChild(root, NULL, (const xmlChar *) "main_size_y", (xmlChar *) str);
3142
3143
SAVE_INT(browser_pos_x);
3144
SAVE_INT(browser_pos_y);
3145
SAVE_INT(browser_size_x);
3146
SAVE_INT(browser_size_y);
3147
SAVE_INT(browser_on);
3148
SAVE_INT(browser_paned_pos);
3149
SAVE_INT(playlist_pos_x);
3150
SAVE_INT(playlist_pos_y);
3151
SAVE_INT(playlist_size_x);
3152
SAVE_INT(playlist_size_y);
3153
SAVE_INT(playlist_on);
3154
SAVE_INT_SH(playlist_is_embedded);
3155
SAVE_INT(playlist_is_tree);
3156
SAVE_INT(album_shuffle_mode);
3157
SAVE_INT_SH(enable_playlist_statusbar);
3158
SAVE_FONT(browser_font);
3159
SAVE_FONT(playlist_font);
3160
SAVE_FONT(bigtimer_font);
3161
SAVE_FONT(smalltimer_font);
3162
SAVE_FONT(songtitle_font);
3163
SAVE_FONT(songinfo_font);
3164
SAVE_FONT(statusbar_font);
3165
SAVE_COLOR(activesong_color);
3166
SAVE_INT(repeat_on);
3167
SAVE_INT(repeat_all_on);
3168
SAVE_INT(shuffle_on);
3169
SAVE_INT_ARRAY(time_idx, 0);
3170
SAVE_INT_ARRAY(time_idx, 1);
3171
SAVE_INT_ARRAY(time_idx, 2);
3172
SAVE_INT_ARRAY(plcol_idx, 0);
3173
SAVE_INT_ARRAY(plcol_idx, 1);
3174
SAVE_INT_ARRAY(plcol_idx, 2);
3175
SAVE_INT(search_pl_flags);
3176
SAVE_INT(search_ms_flags);
3177
SAVE_INT(cdda_drive_speed);
3178
SAVE_INT(cdda_paranoia_mode);
3179
SAVE_INT(cdda_paranoia_maxretries);
3180
SAVE_INT(cdda_force_drive_rescan);
3181
SAVE_INT(cdda_add_to_playlist);
3182
SAVE_INT(cdda_remove_from_playlist);
3183
SAVE_STR(cddb_server);
3184
SAVE_INT(cddb_timeout);
3185
SAVE_STR(cddb_email);
3186
SAVE_STR(cddb_local);
3187
SAVE_INT(cddb_cache_only);
3188
SAVE_INT(cddb_use_http);
3189
SAVE_INT(cddb_use_proxy);
3190
SAVE_STR(cddb_proxy);
3191
SAVE_INT(cddb_proxy_port);
3192
SAVE_FLOAT(loop_range_start);
3193
SAVE_FLOAT(loop_range_end);
3194
3195
i = 0;
3196
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(ms_pathlist_store), &iter, NULL, i++)) {
3197
char * utf8;
3198
gtk_tree_model_get(GTK_TREE_MODEL(ms_pathlist_store), &iter, 0, &path, -1);
3199
utf8 = g_locale_to_utf8(path, -1, NULL, NULL, NULL);
3200
xmlNewTextChild(root, NULL, (const xmlChar *) "music_store", (xmlChar *) utf8);
3201
g_free(path);
3202
g_free(utf8);
3203
}
3204
3205
3206
sprintf(tmpname, "%s/config.xml.temp", options.confdir);
3207
xmlSaveFormatFile(tmpname, doc, 1);
3208
xmlFreeDoc(doc);
3209
3210
if ((fin = fopen(config_file, "rt")) == NULL) {
3211
fprintf(stderr, "Error opening file: %s\n", config_file);
3212
return;
3213
}
3214
if ((fout = fopen(tmpname, "rt")) == NULL) {
3215
fprintf(stderr, "Error opening file: %s\n", tmpname);
3216
return;
3217
}
3218
3219
c = 0; d = 0;
3220
while (((c = fgetc(fin)) != EOF) && ((d = fgetc(fout)) != EOF)) {
3221
if (c != d) {
3222
fclose(fin);
3223
fclose(fout);
3224
unlink(config_file);
3225
rename(tmpname, config_file);
3226
return;
3227
}
3228
}
3229
3230
fclose(fin);
3231
fclose(fout);
3232
unlink(tmpname);
3233
}
3234
3235
3236
#define LOAD_STR(Var) \
3237
if ((!xmlStrcmp(cur->name, (const xmlChar *) #Var))) { \
3238
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); \
3239
if (key != NULL) \
3240
strncpy(options.Var, (char *) key, MAXLEN-1); \
3241
xmlFree(key); \
3242
}
3243
3244
#define LOAD_FONT(Font) \
3245
if ((!xmlStrcmp(cur->name, (const xmlChar *)#Font))) { \
3246
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); \
3247
if (key != NULL) \
3248
strncpy(options.Font, (char *) key, MAX_FONTNAME_LEN-1); \
3249
xmlFree(key); \
3250
}
3251
3252
#define LOAD_COLOR(Color) \
3253
if ((!xmlStrcmp(cur->name, (const xmlChar *) #Color))) { \
3254
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); \
3255
if (key != NULL) \
3256
strncpy(options.Color, (char *) key, MAX_COLORNAME_LEN-1); \
3257
xmlFree(key); \
3258
}
3259
3260
#define LOAD_INT(Var) \
3261
if ((!xmlStrcmp(cur->name, (const xmlChar *) #Var))) { \
3262
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); \
3263
if (key != NULL) \
3264
sscanf((char *) key, "%d", &options.Var); \
3265
xmlFree(key); \
3266
}
3267
3268
#define LOAD_INT_ARRAY(Var, Idx) \
3269
if ((!xmlStrcmp(cur->name, (const xmlChar *) #Var "_" #Idx))) { \
3270
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); \
3271
if (key != NULL) \
3272
sscanf((char *) key, "%d", options.Var + Idx); \
3273
xmlFree(key); \
3274
}
3275
3276
#define LOAD_INT_SH(Var) \
3277
if ((!xmlStrcmp(cur->name, (const xmlChar *) #Var))) { \
3278
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); \
3279
if (key != NULL) { \
3280
sscanf((char *) key, "%d", &options.Var); \
3281
options.Var##_shadow = options.Var; \
3282
} \
3283
xmlFree(key); \
3284
}
3285
3286
#define LOAD_FLOAT(Var) \
3287
if ((!xmlStrcmp(cur->name, (const xmlChar *) #Var))) { \
3288
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); \
3289
if (key != NULL) { \
3290
options.Var = convf((char *) key); \
3291
} \
3292
xmlFree(key); \
3293
}
3294
3295
3296
void
3297
load_config(void) {
3298
3299
xmlDocPtr doc;
3300
xmlNodePtr cur;
3301
xmlNodePtr root;
3302
xmlChar * key;
3303
char config_file[MAXLEN];
3304
FILE * f;
3305
3306
3307
sprintf(config_file, "%s/config.xml", options.confdir);
3308
3309
if ((f = fopen(config_file, "rt")) == NULL) {
3310
/* no warning -- done that in core.c::load_default_cl() */
3311
doc = xmlNewDoc((const xmlChar *) "1.0");
3312
root = xmlNewNode(NULL, (const xmlChar *) "aqualung_config");
3313
xmlDocSetRootElement(doc, root);
3314
xmlSaveFormatFile(config_file, doc, 1);
3315
xmlFreeDoc(doc);
3316
return;
3317
}
3318
fclose(f);
3319
3320
doc = xmlParseFile(config_file);
3321
if (doc == NULL) {
3322
fprintf(stderr, "An XML error occured while parsing %s\n", config_file);
3323
return;
3324
}
3325
3326
cur = xmlDocGetRootElement(doc);
3327
if (cur == NULL) {
3328
fprintf(stderr, "load_config: empty XML document\n");
3329
xmlFreeDoc(doc);
3330
return;
3331
}
3332
3333
if (xmlStrcmp(cur->name, (const xmlChar *)"aqualung_config")) {
3334
fprintf(stderr, "load_config: XML document of the wrong type, "
3335
"root node != aqualung_config\n");
3336
xmlFreeDoc(doc);
3337
return;
3338
}
3339
3340
3341
options.src_type = 4;
3342
options.vol = 0.0f;
3343
options.bal = 0.0f;
3344
3345
options.repeat_on = 0;
3346
options.repeat_all_on = 0;
3347
options.shuffle_on = 0;
3348
3349
options.loop_range_start = 0.0f;
3350
options.loop_range_end = 1.0f;
3351
3352
options.search_pl_flags = 0;
3353
options.search_ms_flags = SEARCH_F_AN | SEARCH_F_RT | SEARCH_F_TT | SEARCH_F_CO;
3354
3355
options.browser_paned_pos = 400;
3356
3357
options.skin[0] = '\0';
3358
3359
options.default_param[0] = '\0';
3360
options.title_format[0] = '\0';
3361
options.enable_tooltips = 1;
3362
options.show_sn_title = 1;
3363
options.united_minimization = 1;
3364
options.buttons_at_the_bottom = options.buttons_at_the_bottom_shadow = 0;
3365
options.playlist_is_embedded = options.playlist_is_embedded_shadow = 1;
3366
options.playlist_is_tree = 1;
3367
3368
options.enable_mstore_statusbar = options.enable_mstore_statusbar_shadow = 1;
3369
options.enable_mstore_toolbar = options.enable_mstore_toolbar_shadow = 1;
3370
options.enable_ms_tree_icons = options.enable_ms_tree_icons_shadow = 1;
3371
options.ms_statusbar_show_size = 1;
3372
3373
options.cover_width = 2;
3374
3375
options.autoexpand_stores = 1;
3376
3377
options.auto_save_playlist = 1;
3378
options.show_length_in_playlist = 1;
3379
options.enable_playlist_statusbar = options.enable_playlist_statusbar_shadow = 1;
3380
options.pl_statusbar_show_size = 1;
3381
3382
options.rva_refvol = -12.0f;
3383
options.rva_steepness = 1.0f;
3384
options.rva_use_averaging = 1;
3385
options.rva_use_linear_thresh = 0;
3386
options.rva_avg_linear_thresh = 3.0f;
3387
options.rva_avg_stddev_thresh = 2.0f;
3388
3389
options.auto_use_ext_meta_artist = 1;
3390
options.auto_use_ext_meta_record = 1;
3391
options.auto_use_ext_meta_track = 1;
3392
3393
options.cdda_drive_speed = 4;
3394
options.cdda_paranoia_mode = 0; /* no paranoia */
3395
options.cdda_paranoia_maxretries = 20;
3396
options.cdda_force_drive_rescan = 0;
3397
3398
options.cddb_server[0] = '\0';
3399
options.cddb_email[0] = '\0';
3400
options.cddb_local[0] = '\0';
3401
options.cddb_proxy[0] = '\0';
3402
options.cddb_timeout = 10;
3403
3404
options.time_idx[0] = 0;
3405
options.time_idx[1] = 1;
3406
options.time_idx[2] = 2;
3407
3408
options.plcol_idx[0] = 0;
3409
options.plcol_idx[1] = 1;
3410
options.plcol_idx[2] = 2;
3411
3412
ms_pathlist_store = gtk_list_store_new(3,
3413
G_TYPE_STRING, /* path */
3414
G_TYPE_STRING, /* displayed name */
3415
G_TYPE_STRING); /* state (rw, r, unreachable) */
3416
3417
cur = cur->xmlChildrenNode;
3418
while (cur != NULL) {
3419
LOAD_STR(currdir);
3420
LOAD_STR(default_param);
3421
LOAD_STR(title_format);
3422
LOAD_STR(skin);
3423
3424
if (!src_type_parsed) {
3425
LOAD_INT(src_type)
3426
}
3427
3428
LOAD_INT(ladspa_is_postfader);
3429
LOAD_INT(auto_save_playlist);
3430
LOAD_INT(auto_use_meta_artist);
3431
LOAD_INT(auto_use_meta_record);
3432
LOAD_INT(auto_use_meta_track);
3433
LOAD_INT(auto_use_ext_meta_artist);
3434
LOAD_INT(auto_use_ext_meta_record);
3435
LOAD_INT(auto_use_ext_meta_track);
3436
LOAD_INT(show_rva_in_playlist);
3437
LOAD_INT(pl_statusbar_show_size);
3438
LOAD_INT(ms_statusbar_show_size);
3439
LOAD_INT(show_length_in_playlist);
3440
LOAD_INT(show_active_track_name_in_bold);
3441
LOAD_INT(enable_pl_rules_hint);
3442
LOAD_INT(enable_ms_rules_hint);
3443
LOAD_INT_SH(enable_ms_tree_icons);
3444
LOAD_INT(enable_tooltips);
3445
LOAD_INT_SH(buttons_at_the_bottom);
3446
LOAD_INT(disable_buttons_relief);
3447
LOAD_INT_SH(simple_view_in_fx);
3448
LOAD_INT(show_sn_title);
3449
LOAD_INT(united_minimization);
3450
LOAD_INT(magnify_smaller_images);
3451
LOAD_INT(cover_width);
3452
LOAD_INT_SH(hide_comment_pane);
3453
LOAD_INT_SH(enable_mstore_toolbar);
3454
LOAD_INT_SH(enable_mstore_statusbar);
3455
LOAD_INT(autoexpand_stores);
3456
LOAD_INT(show_hidden);
3457
LOAD_INT(main_window_always_on_top);
3458
LOAD_INT(tags_tab_first);
3459
LOAD_INT(override_skin_settings);
3460
LOAD_INT(replaygain_tag_to_use);
3461
LOAD_FLOAT(vol);
3462
LOAD_FLOAT(bal);
3463
LOAD_INT(rva_is_enabled);
3464
LOAD_INT(rva_env);
3465
LOAD_FLOAT(rva_refvol);
3466
LOAD_FLOAT(rva_steepness);
3467
LOAD_INT(rva_use_averaging);
3468
LOAD_INT(rva_use_linear_thresh);
3469
LOAD_FLOAT(rva_avg_linear_thresh);
3470
LOAD_FLOAT(rva_avg_stddev_thresh);
3471
LOAD_INT(main_pos_x);
3472
LOAD_INT(main_pos_y);
3473
LOAD_INT(main_size_x);
3474
LOAD_INT(main_size_y);
3475
LOAD_INT(browser_pos_x);
3476
LOAD_INT(browser_pos_y);
3477
LOAD_INT(browser_size_x);
3478
LOAD_INT(browser_size_y);
3479
LOAD_INT(browser_on);
3480
LOAD_INT(browser_paned_pos);
3481
LOAD_INT(playlist_pos_x);
3482
LOAD_INT(playlist_pos_y);
3483
LOAD_INT(playlist_size_x);
3484
LOAD_INT(playlist_size_y);
3485
LOAD_INT(playlist_on);
3486
LOAD_INT_SH(playlist_is_embedded);
3487
LOAD_INT(playlist_is_tree);
3488
LOAD_INT(album_shuffle_mode);
3489
LOAD_INT_SH(enable_playlist_statusbar);
3490
LOAD_FONT(browser_font);
3491
LOAD_FONT(playlist_font);
3492
LOAD_FONT(bigtimer_font);
3493
LOAD_FONT(smalltimer_font);
3494
LOAD_FONT(songtitle_font);
3495
LOAD_FONT(songinfo_font);
3496
LOAD_FONT(statusbar_font);
3497
LOAD_COLOR(activesong_color);
3498
LOAD_INT(repeat_on);
3499
LOAD_INT(repeat_all_on);
3500
LOAD_INT(shuffle_on);
3501
LOAD_INT_ARRAY(time_idx, 0);
3502
LOAD_INT_ARRAY(time_idx, 1);
3503
LOAD_INT_ARRAY(time_idx, 2);
3504
LOAD_INT_ARRAY(plcol_idx, 0);
3505
LOAD_INT_ARRAY(plcol_idx, 1);
3506
LOAD_INT_ARRAY(plcol_idx, 2);
3507
LOAD_INT(search_pl_flags);
3508
LOAD_INT(search_ms_flags);
3509
LOAD_INT(cdda_drive_speed);
3510
LOAD_INT(cdda_paranoia_mode);
3511
LOAD_INT(cdda_paranoia_maxretries);
3512
LOAD_INT(cdda_force_drive_rescan);
3513
LOAD_INT(cdda_add_to_playlist);
3514
LOAD_INT(cdda_remove_from_playlist);
3515
LOAD_STR(cddb_server);
3516
LOAD_INT(cddb_timeout);
3517
LOAD_STR(cddb_email);
3518
LOAD_STR(cddb_local);
3519
LOAD_INT(cddb_cache_only);
3520
LOAD_INT(cddb_use_http);
3521
LOAD_STR(cddb_proxy);
3522
LOAD_INT(cddb_proxy_port);
3523
LOAD_INT(cddb_use_proxy);
3524
LOAD_FLOAT(loop_range_start);
3525
LOAD_FLOAT(loop_range_end);
3526
3527
if ((!xmlStrcmp(cur->name, (const xmlChar *)"music_store"))) {
3528
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
3529
if (key != NULL) {
3530
3531
char path[MAXLEN];
3532
char * ppath;
3533
3534
snprintf(path, MAXLEN - 1, "%s", (char *)key);
3535
ppath = g_locale_from_utf8(path, -1, NULL, NULL, NULL);
3536
3537
append_ms_pathlist(ppath, path);
3538
3539
g_free(ppath);
3540
}
3541
3542
xmlFree(key);
3543
}
3544
cur = cur->next;
3545
}
3546
3547
xmlFreeDoc(doc);
3548
return;
3549
}
3550
3551
// vim: shiftwidth=8:tabstop=8:softtabstop=8 :
3552
Loggerhead is a web-based interface for Breezy
Version: 2.0.1