mp3splt-gtk 0.9.2
Loading...
Searching...
No Matches
preferences_manager.c
Go to the documentation of this file.
1/**********************************************************
2 *
3 * mp3splt-gtk -- utility based on mp3splt,
4 * for mp3/ogg splitting without decoding
5 *
6 * Copyright: (C) 2005-2014 Alexandru Munteanu
7 * Contact: m@ioalex.net
8 *
9 * http://mp3splt.sourceforge.net/
10 *
11 *********************************************************/
12
13/**********************************************************
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * USA.
28 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
29 *
30 *********************************************************/
31
32/*!********************************************************
33 * \file
34 * Save and read preferences
35 *
36 * This file contains the functions to save the preferences
37 * on the hard disk and to read them again at the next
38 * start of the program.
39 ********************************************************/
40
41#include "all_includes.h"
42
43#include "preferences_manager.h"
44
45static void check_pref_file_and_write_default(ui_state *ui);
46static void pm_free_spinner_int_preferences(GArray *spinner_int_preferences);
47static void pm_free_range_preferences(GArray *range_preferences);
48static void pm_load_spinner_int_preferences(GKeyFile *key_file, preferences_state *pm);
49static void pm_save_spinner_int_preferences(GKeyFile *key_file, preferences_state *pm);
50static void pm_write_default_spinner_int_preferences(GKeyFile *key_file, preferences_state *pm);
51static void pm_load_range_preferences(GKeyFile *key_file, preferences_state *pm);
52static void pm_save_range_preferences(GKeyFile *key_file, preferences_state *pm);
53static void pm_write_default_range_preferences(GKeyFile *key_file, preferences_state *pm);
54
55void pm_register_spinner_int_preference(gchar *main_key, gchar *second_key,
56 gint default_value, GtkWidget *spinner,
57 void (*update_spinner_value_cb)(GtkWidget *spinner, gpointer data),
58 gpointer user_data_for_cb, preferences_state *pm)
59{
60 spinner_int_preference preference;
61
62 preference.main_key = strdup(main_key);
63 preference.second_key = strdup(second_key);
64 preference.default_value = default_value;
65 preference.spinner = spinner;
66 preference.update_spinner_value_cb = update_spinner_value_cb;
67 preference.user_data_for_cb = user_data_for_cb;
68
69 g_array_append_val(pm->spinner_int_preferences, preference);
70}
71
72void pm_register_range_preference(gchar *main_key, gchar *second_key,
73 gint default_value, GtkWidget *range,
74 void (*update_adjustment_value)(GtkAdjustment *adjustment, gpointer data),
75 gpointer user_data_for_cb, preferences_state *pm)
76{
77 range_preference preference;
78
79 preference.main_key = strdup(main_key);
80 preference.second_key = strdup(second_key);
81 preference.default_value = default_value;
82 preference.range = range;
83 preference.update_adjustment_value = update_adjustment_value;
84 preference.user_data_for_cb = user_data_for_cb;
85
86 g_array_append_val(pm->range_preferences, preference);
87}
88
89preferences_state *pm_state_new()
90{
91 preferences_state *pm = g_malloc0(sizeof(preferences_state));
92
93 pm->spinner_int_preferences = g_array_new(TRUE, TRUE, sizeof(spinner_int_preference));
94 pm->range_preferences = g_array_new(TRUE, TRUE, sizeof(range_preference));
95
96 return pm;
97}
98
99void pm_free(preferences_state **pm)
100{
101 if (!pm || !*pm)
102 {
103 return;
104 }
105
106 pm_free_spinner_int_preferences((*pm)->spinner_int_preferences);
107 pm_free_range_preferences((*pm)->range_preferences);
108
109 g_free(*pm);
110 *pm = NULL;
111}
112
113static void pm_load(GKeyFile *key_file, preferences_state *pm)
114{
115 pm_load_spinner_int_preferences(key_file, pm);
116 pm_load_range_preferences(key_file, pm);
117}
118
119static void pm_save(GKeyFile *key_file, preferences_state *pm)
120{
121 pm_save_spinner_int_preferences(key_file, pm);
122 pm_save_range_preferences(key_file, pm);
123}
124
125static void pm_write_default(GKeyFile *key_file, preferences_state *pm)
126{
127 pm_write_default_spinner_int_preferences(key_file, pm);
128 pm_write_default_range_preferences(key_file, pm);
129}
130
131gchar *get_configuration_directory()
132{
133 gchar mp3splt_dir[14] = ".mp3splt-gtk";
134
135 gchar *home_dir = g_strdup(g_get_home_dir());
136
137#ifdef __WIN32__
138 //manage c:\ because the gtk dir returns us "c:\"
139 //and the normal directories without the "\"
140 if (home_dir[strlen(home_dir)-1] == '\\')
141 {
142 home_dir[strlen(home_dir)-1] = '\0';
143 }
144#endif
145
146 gint malloc_number = strlen(home_dir) + strlen(mp3splt_dir) + 2;
147 gchar *mp3splt_dir_with_path = malloc(malloc_number * sizeof(gchar));
148 g_snprintf(mp3splt_dir_with_path, malloc_number,
149 "%s%s%s", home_dir, G_DIR_SEPARATOR_S, mp3splt_dir);
150
151 if (home_dir)
152 {
153 g_free(home_dir);
154 home_dir = NULL;
155 }
156
157 struct stat buffer;
158 gint status = g_stat(mp3splt_dir_with_path, &buffer);
159 if ((status != 0) || (S_ISDIR(buffer.st_mode) == 0))
160 {
161 if ((status == 0) && (S_ISREG(buffer.st_mode) != 0))
162 {
163 gint malloc_number = strlen(mp3splt_dir_with_path) + 5;
164 gchar *backup_file = malloc(malloc_number * sizeof(gchar));
165 snprintf(backup_file, malloc_number, "%s%s", mp3splt_dir_with_path,".bak");
166 g_rename(mp3splt_dir_with_path, backup_file);
167 g_free(backup_file);
168 }
169
170 //if it is not a directory and not a file, we suppose we can
171 //create the directory
172#ifdef __WIN32__
173 g_mkdir(mp3splt_dir_with_path, 0775);
174#else
175 g_mkdir(mp3splt_dir_with_path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
176#endif
177 }
178
179 return mp3splt_dir_with_path;
180}
181
191{
192 gchar *mp3splt_dir_with_path = get_configuration_directory();
193
194 gint fname_malloc_number = strlen(mp3splt_dir_with_path) + 30;
195 gchar *filename = malloc(fname_malloc_number * sizeof(gchar));
196
197 g_snprintf(filename, fname_malloc_number, "%s%smp3splt-gtk_prefs",
198 mp3splt_dir_with_path, G_DIR_SEPARATOR_S);
199
200 if (mp3splt_dir_with_path)
201 {
202 g_free(mp3splt_dir_with_path);
203 mp3splt_dir_with_path = NULL;
204 }
205
206 return filename;
207}
208
212{
213 check_pref_file_and_write_default(ui);
214
215 GKeyFile *key_file = g_key_file_new();
216
217 gchar *filename = get_preferences_filename();
218 g_key_file_load_from_file(key_file, filename, G_KEY_FILE_KEEP_COMMENTS, NULL);
219 if (filename)
220 {
221 g_free(filename);
222 }
223
224#ifdef __WIN32__
225 //language
226 gchar *file_string = g_key_file_get_string(key_file, "general", "language", NULL);
227 GString *lang = g_string_new(file_string);
228
229 //0 = german, 1 = french, 2 = english
230 gint list_number = 2;
231 if (g_string_equal(lang,g_string_new("de")) || g_string_equal(lang,g_string_new("de_DE")))
232 {
233 list_number = 0;
234 }
235 else if (g_string_equal(lang, g_string_new("fr")) || g_string_equal(lang, g_string_new("fr_FR")))
236 {
237 list_number = 1;
238 }
239
240 GSList *radio_button_list = gtk_radio_button_get_group(GTK_RADIO_BUTTON(ui->gui->radio_button));
241 GtkWidget *our_button = GTK_WIDGET(g_slist_nth_data(radio_button_list, list_number));
242 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(our_button), TRUE);
243
244 g_free(file_string);
245 g_string_free(lang, TRUE);
246 file_string = NULL;
247 lang = NULL;
248#endif
249
250 // If get_output_directory()!=NULL the path where to output the split file
251 // to has been set from command line
252 if (get_output_directory(ui) == NULL)
253 {
254 // No output_path from command-line => get the path from the preferences
255 gchar *save_path = g_key_file_get_string(key_file, "split", "save_path", NULL);
256 if (save_path != NULL)
257 {
258 set_output_directory_and_update_ui(save_path, ui);
259 }
260 g_free(save_path);
261 save_path = NULL;
262 }
263
264 //player
265 gint item = g_key_file_get_integer(key_file, "player", "default_player",NULL);
266 ch_set_active_value(GTK_COMBO_BOX(ui->gui->player_combo_box), item);
267
268 item = g_key_file_get_boolean(key_file, "player", "amplitude_wave_ticked", NULL);
269 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->gui->silence_wave_check_button), item);
270 ui->status->show_silence_wave = item;
271
272 pm_load(key_file, ui->preferences);
273
274 //frame mode
275 item = g_key_file_get_boolean(key_file, "split", "frame_mode", NULL);
276 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->gui->frame_mode), item);
277
278 //bit reservoir mode
279 item = g_key_file_get_boolean(key_file, "split", "bit_reservoir_mode", NULL);
280 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->gui->bit_reservoir_mode), item);
281
282 //adjust mode
283 item = g_key_file_get_boolean(key_file, "split", "adjust_mode", NULL);
284 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->gui->adjust_mode), item);
285
286 item = g_key_file_get_boolean(key_file, "output", "splitpoint_names_from_filename", NULL);
287 if (item)
288 {
289 gtk_toggle_button_set_active(ui->gui->names_from_filename, TRUE);
290 }
291 else
292 {
293 gtk_toggle_button_set_active(ui->gui->names_from_filename, FALSE);
294 }
295
296 //adjust threshold
297 gfloat item2;
298 item = g_key_file_get_integer(key_file, "split", "adjust_threshold", NULL);
299 item2 = item/100 + (item%100)/100.;
300 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ui->gui->spinner_adjust_threshold), item2);
301 //adjust offset
302 item = g_key_file_get_integer(key_file, "split", "adjust_offset", NULL);
303 item2 = item/100 + (item%100)/100.;
304 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ui->gui->spinner_adjust_offset), item2);
305 //adjust gap
306 item = g_key_file_get_integer(key_file, "split", "adjust_gap", NULL);
307 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ui->gui->spinner_adjust_gap), item);
308 //adjust min
309 item = g_key_file_get_integer(key_file, "split", "adjust_min", NULL);
310 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ui->gui->spinner_adjust_min), item);
311
312 //tags options
313 gint tag_pref_file = g_key_file_get_integer(key_file, "split", "tags", NULL);
314 rh_set_radio_value(ui->gui->tags_radio, tag_pref_file, TRUE);
315
316 //replace underscores by spaces
317 item = g_key_file_get_boolean(key_file, "split", "replace_underscore_by_space", NULL);
318 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->gui->replace_underscore_by_space_check_box),
319 item);
320
321 //artist text properties
322 item = g_key_file_get_integer(key_file, "split", "artist_text_properties",NULL);
323 if (item)
324 {
325 ch_set_active_value(ui->gui->artist_text_properties_combo, item);
326 }
327 else
328 {
329 ch_set_active_value(ui->gui->artist_text_properties_combo, SPLT_NO_CONVERSION);
330 }
331 //album text properties
332 item = g_key_file_get_integer(key_file, "split", "album_text_properties",NULL);
333 if (item)
334 {
335 ch_set_active_value(ui->gui->album_text_properties_combo, item);
336 }
337 else
338 {
339 ch_set_active_value(ui->gui->album_text_properties_combo, SPLT_NO_CONVERSION);
340 }
341 //title text properties
342 item = g_key_file_get_integer(key_file, "split", "title_text_properties",NULL);
343 if (item)
344 {
345 ch_set_active_value(ui->gui->title_text_properties_combo, item);
346 }
347 else
348 {
349 ch_set_active_value(ui->gui->title_text_properties_combo, SPLT_NO_CONVERSION);
350 }
351 //comment text properties
352 item = g_key_file_get_integer(key_file, "split", "comment_text_properties",NULL);
353 if (item)
354 {
355 ch_set_active_value(ui->gui->comment_text_properties_combo, item);
356 }
357 else
358 {
359 ch_set_active_value(ui->gui->comment_text_properties_combo, SPLT_NO_CONVERSION);
360 }
361
362 //genre
363 gchar *default_genre = g_key_file_get_string(key_file, "split", "genre", NULL);
364 if (default_genre)
365 {
366 ch_set_active_str_value(ui->gui->genre_combo, default_genre);
367 g_free(default_genre);
368 default_genre = NULL;
369 }
370 else
371 {
372 ch_set_active_str_value(ui->gui->genre_combo, SPLT_UNDEFINED_GENRE);
373 }
374
375 //default comment tag
376 gchar *default_comment_tag = g_key_file_get_string(key_file, "split", "default_comment_tag", NULL);
377 if (default_comment_tag)
378 {
379 gtk_entry_set_text(GTK_ENTRY(ui->gui->comment_tag_entry), default_comment_tag);
380 g_free(default_comment_tag);
381 default_comment_tag = NULL;
382 }
383
384 //regexp to parse filename into tags
385 gchar *tags_from_fname_regex =
386 g_key_file_get_string(key_file, "split", "tags_from_filename_regex", NULL);
387 if (tags_from_fname_regex)
388 {
389 gtk_entry_set_text(GTK_ENTRY(ui->gui->regex_entry), tags_from_fname_regex);
390 g_free(tags_from_fname_regex);
391 tags_from_fname_regex = NULL;
392 }
393
394 gchar *test_regex_fname =
395 g_key_file_get_string(key_file, "split", "test_regex_fname", NULL);
396 if (test_regex_fname)
397 {
398 gtk_entry_set_text(GTK_ENTRY(ui->gui->test_regex_fname_entry), test_regex_fname);
399 g_free(test_regex_fname);
400 test_regex_fname = NULL;
401 }
402
403 //tags version
404 tag_pref_file = g_key_file_get_integer(key_file, "split", "tags_version", NULL);
405
406 GSList *tags_version_radio_button_list =
407 gtk_radio_button_get_group(GTK_RADIO_BUTTON(ui->gui->tags_version_radio));
408 GtkWidget *the_selection =
409 GTK_WIDGET(g_slist_nth_data(tags_version_radio_button_list, tag_pref_file));
410 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(the_selection), TRUE);
411
412 //default output format or not
413 gint default_output_format =
414 g_key_file_get_boolean(key_file, "output", "default_output_format", NULL);
415 GSList *output_radio_button_list =
416 gtk_radio_button_get_group(GTK_RADIO_BUTTON(ui->gui->radio_output));
417 GtkWidget *our_selection =
418 GTK_WIDGET(g_slist_nth_data(output_radio_button_list, default_output_format));
419 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(our_selection), TRUE);
420 if (default_output_format)
421 {
422 gtk_widget_set_sensitive(ui->gui->output_entry, FALSE);
423 gtk_widget_set_sensitive(ui->gui->output_label, FALSE);
424 }
425 else
426 {
427 gtk_widget_set_sensitive(ui->gui->output_default_label, FALSE);
428 }
429
430 //output format
431 gchar *output_format = g_key_file_get_string(key_file, "output", "output_format", NULL);
432 if (output_format)
433 {
434 gtk_entry_set_text(GTK_ENTRY(ui->gui->output_entry), output_format);
435 g_free(output_format);
436 output_format = NULL;
437 }
438
439 //create directories if needed
440 item = g_key_file_get_boolean(key_file, "output", "create_dirs_if_needed", NULL);
441 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->gui->create_dirs_from_output_files), item);
442
443 //type of split: split mode
444 gint split_mode = g_key_file_get_integer(key_file, "split", "split_mode", NULL);
445 select_split_mode(split_mode, ui);
446
447 //time value
448 gint time_value = g_key_file_get_integer(key_file, "split", "split_mode_time_value", NULL);
449 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ui->gui->spinner_time), time_value);
450
451 //equal time tracks value
452 gint equal_tracks = g_key_file_get_integer(key_file, "split",
453 "split_mode_equal_time_tracks", NULL);
454 gtk_spin_button_set_value(GTK_SPIN_BUTTON(ui->gui->spinner_equal_tracks), equal_tracks);
455
456 gint root_x = g_key_file_get_integer(key_file, "gui", "root_x_position", NULL);
457 gint root_y = g_key_file_get_integer(key_file, "gui", "root_y_position", NULL);
458 if (root_x && root_y)
459 {
460 ui_set_main_win_position(ui, root_x, root_y);
461 }
462
463 gint width = g_key_file_get_integer(key_file, "gui", "width", NULL);
464 gint height = g_key_file_get_integer(key_file, "gui", "height", NULL);
465 if (width && height)
466 {
467 ui_set_main_win_size(ui, width, height);
468 }
469
470 gchar *browser_directory = g_key_file_get_string(key_file, "gui", "browser_directory", NULL);
471 if (browser_directory)
472 {
473 ui_set_browser_directory(ui, browser_directory);
474 g_free(browser_directory);
475 }
476
477 g_key_file_free(key_file);
478 key_file = NULL;
479}
480
481void save_preferences(ui_state *ui)
482{
483 gchar *filename = get_preferences_filename();
484
485 GKeyFile *my_key_file = g_key_file_new();
486 g_key_file_load_from_file(my_key_file, filename, G_KEY_FILE_KEEP_COMMENTS, NULL);
487
488 //save_path
489 g_key_file_set_string(my_key_file, "split", "save_path", get_output_directory(ui));
490
491 //player
492 g_key_file_set_integer(my_key_file, "player", "default_player", ui->infos->selected_player);
493
494 g_key_file_set_boolean(my_key_file, "player", "amplitude_wave_ticked",
495 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->gui->silence_wave_check_button)));
496
497 pm_save(my_key_file, ui->preferences);
498
499#ifdef __WIN32__
500 GString *selected_lang = get_checked_language(ui);
501 g_key_file_set_string(my_key_file, "general", "language", selected_lang->str);
502 g_string_free(selected_lang, TRUE);
503 selected_lang = NULL;
504#endif
505
506 //frame mode
507 g_key_file_set_boolean(my_key_file, "split", "frame_mode",
508 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->gui->frame_mode)));
509
510 g_key_file_set_boolean(my_key_file, "split", "bit_reservoir_mode",
511 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->gui->bit_reservoir_mode)));
512
513 //adjust mode
514 g_key_file_set_boolean(my_key_file, "split", "adjust_mode",
515 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->gui->adjust_mode)));
516
517 //adjust threshold
518 g_key_file_set_integer(my_key_file, "split", "adjust_threshold",
519 gtk_spin_button_get_value(GTK_SPIN_BUTTON(ui->gui->spinner_adjust_threshold)) * 100);
520 //adjust offset
521 g_key_file_set_integer(my_key_file, "split", "adjust_offset",
522 gtk_spin_button_get_value(GTK_SPIN_BUTTON(ui->gui->spinner_adjust_offset)) * 100);
523 //adjust gap
524 g_key_file_set_integer(my_key_file, "split", "adjust_gap",
525 gtk_spin_button_get_value(GTK_SPIN_BUTTON(ui->gui->spinner_adjust_gap)));
526 //adjust min
527 g_key_file_set_integer(my_key_file, "split", "adjust_min",
528 gtk_spin_button_get_value(GTK_SPIN_BUTTON(ui->gui->spinner_adjust_min)));
529
530 g_key_file_set_boolean(my_key_file, "output", "splitpoint_names_from_filename",
531 gtk_toggle_button_get_active(ui->gui->names_from_filename));
532
533 //output format
534 g_key_file_set_string(my_key_file, "output", "output_format",
535 gtk_entry_get_text(GTK_ENTRY(ui->gui->output_entry)));
536 //default output format
537 g_key_file_set_boolean(my_key_file, "output", "default_output_format",
539 g_key_file_set_boolean(my_key_file, "output", "create_dirs_if_needed",
540 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->gui->create_dirs_from_output_files)));
541
542 //tags
543 g_key_file_set_integer(my_key_file, "split", "tags", rh_get_active_value(ui->gui->tags_radio));
544
545 //replace underscores by space
546 g_key_file_set_boolean(my_key_file, "split", "replace_underscore_by_space",
547 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ui->gui->replace_underscore_by_space_check_box)));
548
549 //artist text properties
550 g_key_file_set_integer(my_key_file, "split", "artist_text_properties",
551 ch_get_active_value(ui->gui->artist_text_properties_combo));
552 //album text properties
553 g_key_file_set_integer(my_key_file, "split", "album_text_properties",
554 ch_get_active_value(ui->gui->album_text_properties_combo));
555 //title text properties
556 g_key_file_set_integer(my_key_file, "split", "title_text_properties",
557 ch_get_active_value(ui->gui->title_text_properties_combo));
558 //comment text properties
559 g_key_file_set_integer(my_key_file, "split", "comment_text_properties",
560 ch_get_active_value(ui->gui->comment_text_properties_combo));
561
562 //genre
563 gchar *genre_value = ch_get_active_str_value(ui->gui->genre_combo);
564 if (genre_value != NULL)
565 {
566 g_key_file_set_string(my_key_file, "split", "genre", genre_value);
567 g_free(genre_value);
568 }
569
570 const gchar *comment = gtk_entry_get_text(GTK_ENTRY(ui->gui->comment_tag_entry));
571 if (comment != NULL)
572 {
573 g_key_file_set_string(my_key_file, "split", "default_comment_tag", comment);
574 }
575
576 const gchar *regex_text = gtk_entry_get_text(GTK_ENTRY(ui->gui->regex_entry));
577 if (regex_text != NULL)
578 {
579 g_key_file_set_string(my_key_file, "split", "tags_from_filename_regex", regex_text);
580 }
581
582 const gchar *test_regex_fname = gtk_entry_get_text(GTK_ENTRY(ui->gui->test_regex_fname_entry));
583 if (test_regex_fname != NULL)
584 {
585 g_key_file_set_string(my_key_file, "split", "test_regex_fname", test_regex_fname);
586 }
587
588 //tags version
589 g_key_file_set_integer(my_key_file, "split", "tags_version",
591
592 //type of split: split mode
593 g_key_file_set_integer(my_key_file, "split", "split_mode", get_selected_split_mode(ui));
594 //time value
595 g_key_file_set_integer(my_key_file, "split", "split_mode_time_value",
596 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ui->gui->spinner_time)));
597 //equal time tracks value
598 g_key_file_set_integer(my_key_file, "split", "split_mode_equal_time_tracks",
599 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ui->gui->spinner_equal_tracks)));
600
601 const ui_main_window *main_win = ui_get_main_window_infos(ui);
602 g_key_file_set_integer(my_key_file, "gui", "root_x_position", main_win->root_x_pos);
603 g_key_file_set_integer(my_key_file, "gui", "root_y_position", main_win->root_y_pos);
604 g_key_file_set_integer(my_key_file, "gui", "width", main_win->width);
605 g_key_file_set_integer(my_key_file, "gui", "height", main_win->height);
606
607 const char *browser_directory = ui_get_browser_directory(ui);
608 if (browser_directory != NULL)
609 {
610 g_key_file_set_string(my_key_file, "gui", "browser_directory", browser_directory);
611 }
612
613 gchar *key_data = g_key_file_to_data(my_key_file, NULL, NULL);
614
615 //we write to the preference file
616 FILE *preferences_file;
617 preferences_file = (FILE *)g_fopen(filename,"w");
618 g_fprintf(preferences_file,"%s", key_data);
619 fclose(preferences_file);
620 preferences_file = NULL;
621
622 //we free memory
623 g_free(key_data);
624 g_key_file_free(my_key_file);
625
626 if (filename)
627 {
628 g_free(filename);
629 filename = NULL;
630 }
631}
632
633/* \brief writes a default configuration file
634
635Also is used to write good values on a bad existing configuration file
636*/
637static void write_default_preferences_file(ui_state *ui)
638{
639 gchar *filename = get_preferences_filename();
640
641 GKeyFile *my_key_file = g_key_file_new();
642 g_key_file_load_from_file(my_key_file, filename, G_KEY_FILE_KEEP_COMMENTS, NULL);
643
644#ifdef __WIN32__
645 //default language
646 if (!g_key_file_has_key(my_key_file, "general", "language",NULL))
647 {
648 g_key_file_set_string(my_key_file, "general", "language", "en");
649 g_key_file_set_comment(my_key_file, "general", "language",
650 "\n language of the gui: en = english, fr = french, de = german", NULL);
651 }
652 //if we have the key, but we have ugly values
653 else
654 {
655 gchar *file_string = g_key_file_get_string(my_key_file, "general", "language", NULL);
656 GString * lang_char = g_string_new(file_string);
657
658 if((!g_string_equal(lang_char,g_string_new("en")))
659 &&(!g_string_equal(lang_char, g_string_new("fr")))
660 &&(!g_string_equal(lang_char, g_string_new("fr_FR")))
661 &&(!g_string_equal(lang_char, g_string_new("de")))
662 &&(!g_string_equal(lang_char, g_string_new("de_DE")))
663 )
664 {
665 g_key_file_set_string(my_key_file, "general", "language", "en");
666 g_key_file_set_comment(my_key_file, "general", "language",
667 "\n language of the gui: en = english, fr_FR = french, de_DE = german", NULL);
668 }
669
670 g_free(file_string);
671 g_string_free(lang_char, TRUE);
672 file_string = NULL;
673 lang_char = NULL;
674 }
675#endif
676
677 //frame mode
678 if (!g_key_file_has_key(my_key_file, "split", "frame_mode",NULL))
679 {
680 g_key_file_set_boolean(my_key_file, "split", "frame_mode", FALSE);
681 }
682
683 if (!g_key_file_has_key(my_key_file, "split", "bit_reservoir_mode",NULL))
684 {
685 g_key_file_set_boolean(my_key_file, "split", "bit_reservoir_mode", FALSE);
686 }
687
688 //adjust mode
689 if (!g_key_file_has_key(my_key_file, "split", "adjust_mode",NULL))
690 {
691 g_key_file_set_boolean(my_key_file, "split", "adjust_mode", FALSE);
692 }
693
694 gint item;
695 gfloat item2;
696 //adjust threshold
697 if (!g_key_file_has_key(my_key_file, "split", "adjust_threshold",NULL))
698 {
699 g_key_file_set_integer(my_key_file, "split", "adjust_threshold",
700 (int)(SPLT_DEFAULT_PARAM_THRESHOLD * 100));
701 }
702 //if we have the key but we have ugly values
703 else
704 {
705 item = g_key_file_get_integer(my_key_file, "split", "adjust_threshold", NULL);
706 //convert to float
707 item2 = item/100 + (item%100)/100.;
708
709 if ((item2 < -96) || (item2 > 0))
710 {
711 g_key_file_set_integer(my_key_file, "split", "adjust_threshold",
712 (int)(SPLT_DEFAULT_PARAM_THRESHOLD * 100));
713 }
714 }
715
716 //adjust offset
717 if (!g_key_file_has_key(my_key_file, "split", "adjust_offset",NULL))
718 {
719 g_key_file_set_integer(my_key_file, "split", "adjust_offset",
720 (int)(SPLT_DEFAULT_PARAM_OFFSET * 100));
721 }
722 //if we have the key but we have ugly values
723 else
724 {
725 item = g_key_file_get_integer(my_key_file, "split", "adjust_offset", NULL);
726 //convert to float
727 item2 = item/100 + (item%100)/100.;
728
729 //if ugly values
730 if ((item2 < -2) || (item2 > 2))
731 {
732 g_key_file_set_integer(my_key_file, "split", "adjust_offset",
733 (int)(SPLT_DEFAULT_PARAM_OFFSET * 100));
734 }
735 }
736
737 //adjust gap
738 if (!g_key_file_has_key(my_key_file, "split", "adjust_gap",NULL))
739 {
740 g_key_file_set_integer(my_key_file, "split", "adjust_gap", SPLT_DEFAULT_PARAM_GAP);
741 }
742 //if we have the key but we have ugly values
743 else
744 {
745 item = g_key_file_get_integer(my_key_file, "split", "adjust_gap", NULL);
746 if ((item < 0) || (item > 2000))
747 {
748 g_key_file_set_integer(my_key_file, "split", "adjust_gap", SPLT_DEFAULT_PARAM_GAP);
749 }
750 }
751
752 //tags options
753 if (!g_key_file_has_key(my_key_file, "split", "tags",NULL))
754 {
755 g_key_file_set_integer(my_key_file, "split", "tags", 1);
756 g_key_file_set_comment(my_key_file, "split", "tags",
757 "\n 0 - No tags, 1 - Default tags, 2 - Original tags, 3 - Tags from filename", NULL);
758 }
759
760 //tags version
761 if (!g_key_file_has_key(my_key_file, "split", "tags_version",NULL))
762 {
763 g_key_file_set_integer(my_key_file, "split", "tags_version", 0);
764 g_key_file_set_comment(my_key_file, "split", "tags_version",
765 "\n 0 - same tags version as the input file, 1 - ID3v1 tags,"
766 " 2 - ID3v2 tags, 3 - ID3v1 & ID3v2 tags",
767 NULL);
768 }
769
770 //default player
771 if (!g_key_file_has_key(my_key_file, "player", "default_player",NULL))
772 {
773 g_key_file_set_integer(my_key_file, "player", "default_player",
774 PLAYER_GSTREAMER);
775 g_key_file_set_comment (my_key_file, "player", "default_player",
776 "\n 1 = PLAYER_AUDACIOUS, 2 = PLAYER_SNACKAMP, 3 = PLAYER_GSTREAMER",
777 NULL);
778 }
779 else
780 {
781 //check if we support selected player
782 gint the_player =
783 g_key_file_get_integer(my_key_file, "player", "default_player", NULL);
784 if (the_player == PLAYER_AUDACIOUS)
785 {
786#ifdef NO_AUDACIOUS
787 g_key_file_set_integer(my_key_file, "player", "default_player", PLAYER_SNACKAMP);
788#endif
789 }
790 //if the value do not make sense
791 else if ((the_player > PLAYER_GSTREAMER) || (the_player < 0))
792 {
793 g_key_file_set_integer(my_key_file, "player", "default_player",
794 PLAYER_GSTREAMER);
795 }
796 }
797
798 pm_write_default(my_key_file, ui->preferences);
799
800 //output format
801 if (!g_key_file_has_key(my_key_file, "output", "output_format",NULL))
802 {
803 g_key_file_set_string(my_key_file, "output", "output_format", SPLT_DEFAULT_OUTPUT);
804 g_key_file_set_comment (my_key_file, "output", "output_format",
805 "\n the output format, contains @a,"
806 "@b, @g, @p, @t and @n, see the program for"
807 " more details", NULL);
808 }
809
810 //default output path boolean
811 if (!g_key_file_has_key(my_key_file, "output", "default_output_format",NULL))
812 {
813 g_key_file_set_boolean(my_key_file, "output", "default_output_format", TRUE);
814 g_key_file_set_comment(my_key_file, "output", "default_output_format",
815 "\n can be true or false"
816 " - if we use the default output or"
817 " not for cddb, cue and freedb search", NULL);
818 }
819
820 //frame mode
821 if (!g_key_file_has_key(my_key_file, "output", "create_dirs_if_needed", NULL))
822 {
823 g_key_file_set_boolean(my_key_file, "output", "create_dirs_if_needed", TRUE);
824 }
825
826 //split save path (output dir)
827 if (!g_key_file_has_key(my_key_file, "split", "save_path",NULL))
828 {
829#ifdef __WIN32__
830 const gchar *home_dir = g_get_home_dir();
831 gint dir_malloc_number = strlen(home_dir)+ 10;
832 gchar *default_dir = malloc(dir_malloc_number*sizeof(gchar *));
833 g_snprintf(default_dir, dir_malloc_number, "%s\\Desktop",home_dir);
834
835 //see if the directory exists
836 struct stat buffer;
837 gint status = g_stat(default_dir, &buffer);
838 if ((status == 0) && (S_ISDIR(buffer.st_mode) == 0))
839 {
840 g_snprintf(default_dir, dir_malloc_number, "%s",home_dir);
841 }
842#else
843 const gchar *default_dir = g_get_home_dir();
844#endif
845
846 g_key_file_set_string(my_key_file, "split", "save_path", default_dir);
847 g_key_file_set_comment(my_key_file, "split", "save_path",
848 "\n this is the path where you will find your split files ",
849 NULL);
850
851#ifdef __WIN32__
852 g_free(default_dir);
853#endif
854 }
855
856 //type of split: split mode
857 if (!g_key_file_has_key(my_key_file, "split", "split_mode",NULL))
858 {
859 g_key_file_set_integer(my_key_file, "split", "split_mode", 3);
860 g_key_file_set_comment(my_key_file, "split", "split_mode",
861 "\n 0 - error mode, 1 - wrap mode, 2 - time mode, 3 - normal mode, 4 - equal time tracks",
862 NULL);
863 }
864
865 //type of split: time value
866 if (!g_key_file_has_key(my_key_file, "split", "split_mode_time_value",NULL))
867 {
868 g_key_file_set_integer(my_key_file, "split", "split_mode_time_value", 60);
869 g_key_file_set_comment(my_key_file, "split", "split_mode_time_value",
870 "\n value in seconds to split every X seconds (for the time split)", NULL);
871 }
872
873 //equal time tracks
874 if (!g_key_file_has_key(my_key_file, "split", "split_mode_equal_time_tracks",NULL))
875 {
876 g_key_file_set_integer(my_key_file, "split", "split_mode_equal_time_tracks", 10);
877 g_key_file_set_comment(my_key_file, "split", "split_mode_equal_time_tracks",
878 "\n number of tracks when to split in X tracks (for the equal time tracks split)", NULL);
879 }
880
881 gchar *key_data = g_key_file_to_data(my_key_file, NULL, NULL);
882
883 FILE *preferences_file = (FILE *)fopen(filename,"w");
884 g_fprintf(preferences_file,"%s", key_data);
885 fclose(preferences_file);
886
887 if (filename)
888 {
889 g_free(filename);
890 }
891
892 g_free(key_data);
893 g_key_file_free(my_key_file);
894}
895
900static void check_pref_file_and_write_default(ui_state *ui)
901{
902 gchar *pref_file = get_preferences_filename();
903
904 struct stat buffer;
905 gint status = stat(pref_file, &buffer);
906 if ((status == 0) &&
907 (S_ISREG(buffer.st_mode) == 0) &&
908 (S_ISDIR(buffer.st_mode) != 0))
909 {
910 gint malloc_number = strlen(pref_file)+5;
911 gchar *backup_dir = malloc(malloc_number * sizeof(gchar *));
912 snprintf(backup_dir,malloc_number, "%s%s", pref_file, ".bak");
913 g_rename(pref_file, backup_dir);
914 g_free(backup_dir);
915 backup_dir = NULL;
916 }
917
918 if (pref_file)
919 {
920 g_free(pref_file);
921 pref_file = NULL;
922 }
923
924 write_default_preferences_file(ui);
925}
926
927static void pm_free_spinner_int_preferences(GArray *spinner_int_preferences)
928{
929 gint i = 0;
930 for (i = 0; i < spinner_int_preferences->len; i++)
931 {
932 spinner_int_preference preference =
933 g_array_index(spinner_int_preferences, spinner_int_preference, i);
934
935 g_free(preference.main_key);
936 preference.main_key = NULL;
937
938 g_free(preference.second_key);
939 preference.second_key = NULL;
940 }
941
942 g_array_free(spinner_int_preferences, TRUE);
943}
944
945static void pm_free_range_preferences(GArray *range_preferences)
946{
947 gint i = 0;
948 for (i = 0; i < range_preferences->len; i++)
949 {
950 spinner_int_preference preference =
951 g_array_index(range_preferences, spinner_int_preference, i);
952
953 g_free(preference.main_key);
954 preference.main_key = NULL;
955
956 g_free(preference.second_key);
957 preference.second_key = NULL;
958 }
959
960 g_array_free(range_preferences, TRUE);
961}
962
963static void pm_load_spinner_int_preferences(GKeyFile *key_file, preferences_state *pm)
964{
965 GArray *spinner_int_preferences = pm->spinner_int_preferences;
966
967 gint i = 0;
968 for (i = 0; i < spinner_int_preferences->len; i++)
969 {
970 spinner_int_preference preference =
971 g_array_index(spinner_int_preferences, spinner_int_preference, i);
972
973 gint value =
974 g_key_file_get_integer(key_file, preference.main_key, preference.second_key, NULL);
975 gtk_spin_button_set_value(GTK_SPIN_BUTTON(preference.spinner), value);
976 preference.update_spinner_value_cb(preference.spinner, preference.user_data_for_cb);
977 }
978}
979
980static void pm_save_spinner_int_preferences(GKeyFile *key_file, preferences_state *pm)
981{
982 GArray *spinner_int_preferences = pm->spinner_int_preferences;
983
984 gint i = 0;
985 for (i = 0; i < spinner_int_preferences->len; i++)
986 {
987 spinner_int_preference preference =
988 g_array_index(spinner_int_preferences, spinner_int_preference, i);
989
990 g_key_file_set_integer(key_file, preference.main_key, preference.second_key,
991 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(preference.spinner)));
992 }
993}
994
995static void pm_write_default_spinner_int_preferences(GKeyFile *key_file, preferences_state *pm)
996{
997 GArray *spinner_int_preferences = pm->spinner_int_preferences;
998
999 gint i = 0;
1000 for (i = 0; i < spinner_int_preferences->len; i++)
1001 {
1002 spinner_int_preference preference =
1003 g_array_index(spinner_int_preferences, spinner_int_preference, i);
1004
1005 if (!g_key_file_has_key(key_file, preference.main_key, preference.second_key, NULL))
1006 {
1007 g_key_file_set_integer(key_file, preference.main_key, preference.second_key,
1008 preference.default_value);
1009 }
1010 }
1011}
1012
1013static void pm_load_range_preferences(GKeyFile *key_file, preferences_state *pm)
1014{
1015 GArray *range_preferences = pm->range_preferences;
1016
1017 gint i = 0;
1018 for (i = 0; i < range_preferences->len; i++)
1019 {
1020 range_preference preference = g_array_index(range_preferences, range_preference, i);
1021
1022 gint value =
1023 g_key_file_get_integer(key_file, preference.main_key, preference.second_key, NULL);
1024
1025 gtk_range_set_value(GTK_RANGE(preference.range), value);
1026 GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(preference.range));
1027 preference.update_adjustment_value(adj, preference.user_data_for_cb);
1028 }
1029}
1030
1031static void pm_save_range_preferences(GKeyFile *key_file, preferences_state *pm)
1032{
1033 GArray *range_preferences = pm->range_preferences;
1034
1035 gint i = 0;
1036 for (i = 0; i < range_preferences->len; i++)
1037 {
1038 range_preference preference = g_array_index(range_preferences, range_preference, i);
1039
1040 GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(preference.range));
1041 g_key_file_set_integer(key_file, preference.main_key, preference.second_key,
1042 (gint)gtk_adjustment_get_value(adj));
1043 }
1044}
1045
1046static void pm_write_default_range_preferences(GKeyFile *key_file, preferences_state *pm)
1047{
1048 GArray *range_preferences = pm->range_preferences;
1049
1050 gint i = 0;
1051 for (i = 0; i < range_preferences->len; i++)
1052 {
1053 range_preference preference = g_array_index(range_preferences, range_preference, i);
1054
1055 if (!g_key_file_has_key(key_file, preference.main_key, preference.second_key, NULL))
1056 {
1057 g_key_file_set_integer(key_file, preference.main_key, preference.second_key,
1058 preference.default_value);
1059 }
1060 }
1061}
1062
void load_preferences(ui_state *ui)
Read the preferences from the preferences file.
gchar * get_preferences_filename()
Get the name of the preferences file.
gchar * get_output_directory(ui_state *ui)
Get the name of the output directory.
GString * get_checked_language(ui_state *ui)
Returns the selected language.
gboolean get_checked_output_radio_box(ui_state *ui)
returns the checked output radio box
gint get_checked_tags_version_radio_box(gui_state *gui)
returns the checked tags radio box
void select_split_mode(int split_mode, ui_state *ui)
Set the split mode.