mp3splt-gtk
preferences_tab.c
Go to the documentation of this file.
00001 /**********************************************************
00002  *
00003  * mp3splt-gtk -- utility based on mp3splt,
00004  *                for mp3/ogg splitting without decoding
00005  *
00006  * Copyright: (C) 2005-2012 Alexandru Munteanu
00007  * Contact: io_fx@yahoo.fr
00008  *
00009  * http://mp3splt.sourceforge.net/
00010  *
00011  *********************************************************/
00012 
00013 /**********************************************************
00014  *
00015  * This program is free software; you can redistribute it and/or
00016  * modify it under the terms of the GNU General Public License
00017  * as published by the Free Software Foundation; either version 2
00018  * of the License, or (at your option) any later version.
00019  *
00020  * This program is distributed in the hope that it will be useful,
00021  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00023  * GNU General Public License for more details.
00024  *
00025  * along with this program; if not, write to the Free Software
00026  * You should have received a copy of the GNU General Public License
00027  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
00028  * USA.
00029  *
00030  *********************************************************/
00031 
00032 /*!********************************************************
00033  * \file 
00034  * The preferences tab
00035  *
00036  * this file contains the code for the preferences tab where 
00037  * the preferences can be chosen.
00038  ********************************************************/
00039 
00040 #include <gtk/gtk.h>
00041 #include <glib/gi18n.h>
00042 #include <glib.h>
00043 #include <glib/gstdio.h>
00044 #include <string.h>
00045 
00046 #include <libmp3splt/mp3splt.h>
00047 
00048 #include "preferences_tab.h"
00049 #include "player.h"
00050 #include "util.h"
00051 #include "player_tab.h"
00052 #include "utilities.h"
00053 #include "main_win.h"
00054 #include "preferences_manager.h"
00055 #include "widgets_helper.h"
00056 #include "combo_helper.h"
00057 #include "radio_helper.h"
00058 #include "options_manager.h"
00059 #include "ui_manager.h"
00060 #include "widgets_helper.h"
00061 
00067 GString *outputdirname = NULL;
00068 
00070 GtkWidget *directory_entry = NULL;
00071 
00073 GtkWidget *output_entry = NULL;
00074 GtkWidget *output_label = NULL;
00075 
00077 GtkWidget *player_combo_box = NULL;
00078 GtkWidget *player_refresh_rate_spinner = NULL;
00079 
00081 GList *player_pref_list = NULL;
00082 GList *text_options_list = NULL;
00083 //selected player
00084 gint selected_player = PLAYER_GSTREAMER;
00085 
00087 GtkWidget *radio_button = NULL;
00088 
00090 GtkWidget *radio_output = NULL;
00091 
00093 GtkWidget *tags_radio = NULL;
00094 GtkWidget *tags_version_radio = NULL;
00095 
00096 //split options
00098 GtkWidget *frame_mode = NULL;
00100 GtkWidget *adjust_mode = NULL;
00101 // when ticked, name for split tag derived from filename
00102 GtkWidget *names_from_filename = NULL;
00103 
00104 GtkWidget *create_dirs_from_output_files = NULL;
00105 
00109 GtkWidget *spinner_adjust_gap = NULL;
00110 GtkWidget *gap_label = NULL;
00111 GtkWidget *spinner_adjust_offset = NULL;
00112 GtkWidget *offset_label = NULL;
00113 GtkWidget *spinner_adjust_threshold = NULL;
00114 GtkWidget *threshold_label = NULL;
00116 
00120 GtkWidget *replace_underscore_by_space_check_box = NULL;
00121 GtkComboBox *artist_text_properties_combo = NULL;
00122 GtkComboBox *album_text_properties_combo = NULL;
00123 GtkComboBox *title_text_properties_combo = NULL;
00124 GtkComboBox *comment_text_properties_combo = NULL;
00125 GtkComboBox *genre_combo = NULL;
00126 GtkWidget *comment_tag_entry = NULL;
00127 GtkWidget *regex_entry = NULL;
00128 GtkWidget *test_regex_fname_entry = NULL;
00129 GtkWidget *sample_result_label = NULL;
00130 
00131 GtkWidget *extract_tags_box = NULL;
00133 
00134 extern gint timeout_value;
00135 extern GtkWidget *player_box;
00136 extern GtkWidget *playlist_box;
00137 extern GtkWidget *queue_files_button;
00138 extern splt_state *the_state;
00139 extern gint selected_split_mode;
00140 extern gint split_file_mode;
00141 extern GtkWidget *spinner_time;
00142 extern GtkWidget *spinner_equal_tracks;
00143 
00144 extern gint file_browsed;
00145 
00146 static GtkWidget *create_extract_tags_from_filename_options_box();
00147 static GtkWidget *create_test_regex_table();
00148 
00149 extern void clear_current_description(void);
00150 extern void copy_filename_to_current_description(const gchar *fname);
00151 
00152 extern ui_state *ui;
00153 
00158 GString *get_checked_language()
00159 {
00160   GSList *radio_button_list;
00161   radio_button_list = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio_button));
00162   GtkWidget *our_button;
00163 
00164   //0 = german, 1 = french, 2 = english
00165   our_button = (GtkWidget *)g_slist_nth_data(radio_button_list, 0);
00166   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(our_button)))
00167   {
00168     return g_string_new("de_DE");
00169   }
00170   else 
00171   {
00172     our_button = (GtkWidget *)g_slist_nth_data(radio_button_list, 1);
00173     if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(our_button)))
00174     {
00175       return g_string_new("fr_FR");
00176     }
00177   }
00178 
00179   return g_string_new("en");
00180 }
00181 
00183 gboolean get_checked_output_radio_box()
00184 {
00185   //get the radio buttons
00186   GSList *radio_button_list;
00187   radio_button_list = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio_output));
00188   //we check which bubble is checked
00189   GtkToggleButton *test;
00190   gint i, selected = 0;
00191   //O = default output mode
00192   //1 = custom output mode
00193   for(i = 0; i<2;i++)
00194   {
00195     test = (GtkToggleButton *)g_slist_nth_data(radio_button_list,i);
00196     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(test)))
00197     {
00198       selected = i;
00199     }
00200   }
00201 
00202   return selected;
00203 }
00204 
00206 gint get_checked_tags_version_radio_box()
00207 {
00208   //get the radio buttons
00209   GSList *radio_button_list;
00210   radio_button_list = gtk_radio_button_get_group(GTK_RADIO_BUTTON(tags_version_radio));
00211 
00212   //we check which bubble is checked
00213   GtkToggleButton *test;
00214   gint i, selected = 0;
00215   //O = The same version as the original file
00216   //1 = ID3v1
00217   //2 = ID3v2
00218   //3 = ID3v1 & ID3v2
00219   for(i = 0; i<4;i++)
00220   {
00221     test = (GtkToggleButton *)g_slist_nth_data(radio_button_list,i);
00222     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(test)))
00223     {
00224       selected = i;
00225     }
00226   }
00227   
00228   return selected;
00229 }
00230 
00232 void outputdirectory_set(gchar *dirname)
00233 {
00234   if(dirname!=NULL)
00235     {
00236       // Free the old string before allocating memory for the new one
00237       if(outputdirname!=NULL)g_string_free(outputdirname,TRUE);
00238       outputdirname=g_string_new(dirname);
00239 
00240       // Update the text in the gui field displaying the output 
00241       // directory - if this field is already there and thus can 
00242       // be updated.
00243       if(directory_entry!=NULL)
00244         gtk_entry_set_text(GTK_ENTRY(directory_entry), dirname);
00245     }
00246 }
00247 
00254 gchar* outputdirectory_get()
00255 {
00256   if(outputdirname!=NULL)
00257     return(outputdirname->str);
00258   else
00259     return NULL;
00260 }
00261 
00262 void save_preferences(GtkWidget *widget, gpointer data)
00263 {
00264   gchar *filename = get_preferences_filename();
00265 
00266   GKeyFile *my_key_file = g_key_file_new();
00267   g_key_file_load_from_file(my_key_file, filename, G_KEY_FILE_KEEP_COMMENTS, NULL);
00268 
00269   //save_path
00270   g_key_file_set_string(my_key_file, "split", "save_path",
00271                         outputdirectory_get());
00272 
00273   //player
00274   g_key_file_set_integer(my_key_file, "player", "default_player", selected_player);
00275   g_key_file_set_integer(my_key_file, "player", "refresh_rate",
00276       gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(player_refresh_rate_spinner)));
00277  
00278 #ifdef __WIN32__
00279   //language
00280   GString *selected_lang;
00281   selected_lang = (GString *)get_checked_language();
00282   g_key_file_set_string(my_key_file, "general", "language", selected_lang->str);
00283   g_string_free(selected_lang, TRUE);
00284   selected_lang = NULL;
00285 #endif
00286 
00287   //frame mode
00288   g_key_file_set_boolean(my_key_file, "split", "frame_mode",
00289       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(frame_mode)));
00290 
00291   //adjust mode
00292   g_key_file_set_boolean(my_key_file, "split", "adjust_mode",
00293       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(adjust_mode)));
00294 
00295   //adjust threshold
00296   g_key_file_set_integer(my_key_file, "split", "adjust_threshold",
00297       gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_adjust_threshold)) * 100);
00298   //adjust offset
00299   g_key_file_set_integer(my_key_file, "split", "adjust_offset",
00300       gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_adjust_offset)) * 100);
00301   //adjust gap
00302   g_key_file_set_integer(my_key_file, "split", "adjust_gap",
00303       gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinner_adjust_gap)));
00304 
00305   g_key_file_set_boolean(my_key_file, "output", "splitpoint_names_from_filename",
00306       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(names_from_filename)));
00307 
00308   //output format
00309   g_key_file_set_string(my_key_file, "output", "output_format",
00310       gtk_entry_get_text(GTK_ENTRY(output_entry)));
00311   //default output format
00312   g_key_file_set_boolean(my_key_file, "output", "default_output_format",
00313       get_checked_output_radio_box());
00314   g_key_file_set_boolean(my_key_file, "output", "create_dirs_if_needed",
00315       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(create_dirs_from_output_files)));
00316 
00317   //tags
00318   g_key_file_set_integer(my_key_file, "split", "tags", rh_get_active_value(tags_radio));
00319 
00320   //replace underscores by space
00321   g_key_file_set_boolean(my_key_file, "split", "replace_underscore_by_space",
00322   gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(replace_underscore_by_space_check_box)));
00323 
00324   //artist text properties
00325   g_key_file_set_integer(my_key_file, "split", "artist_text_properties",
00326       ch_get_active_value(artist_text_properties_combo));
00327   //album text properties
00328   g_key_file_set_integer(my_key_file, "split", "album_text_properties",
00329       ch_get_active_value(album_text_properties_combo));
00330   //title text properties
00331   g_key_file_set_integer(my_key_file, "split", "title_text_properties",
00332       ch_get_active_value(title_text_properties_combo));
00333   //comment text properties
00334   g_key_file_set_integer(my_key_file, "split", "comment_text_properties",
00335       ch_get_active_value(comment_text_properties_combo));
00336 
00337   //genre
00338   gchar *genre_value = ch_get_active_str_value(genre_combo);
00339   if (genre_value != NULL)
00340   {
00341     g_key_file_set_string(my_key_file, "split", "genre", genre_value);
00342   }
00343 
00344   const gchar *comment = gtk_entry_get_text(GTK_ENTRY(comment_tag_entry));
00345   if (comment != NULL)
00346   {
00347     g_key_file_set_string(my_key_file, "split", "default_comment_tag", comment);
00348   }
00349 
00350   const gchar *regex_text = gtk_entry_get_text(GTK_ENTRY(regex_entry));
00351   if (regex_text != NULL)
00352   {
00353     g_key_file_set_string(my_key_file, "split", "tags_from_filename_regex", regex_text);
00354   }
00355 
00356   const gchar *test_regex_fname = gtk_entry_get_text(GTK_ENTRY(test_regex_fname_entry));
00357   if (test_regex_fname_entry != NULL)
00358   {
00359     g_key_file_set_string(my_key_file, "split", "test_regex_fname", test_regex_fname);
00360   }
00361 
00362   //tags version
00363   g_key_file_set_integer(my_key_file, "split", "tags_version",
00364       get_checked_tags_version_radio_box());
00365 
00366   //type of split: split mode
00367   g_key_file_set_integer(my_key_file, "split", "split_mode",
00368       selected_split_mode);
00369   //time value
00370   g_key_file_set_integer(my_key_file, "split", "split_mode_time_value",
00371       gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spinner_time)));
00372   //type of split: file mode
00373   g_key_file_set_integer(my_key_file, "split", "file_mode",
00374       split_file_mode);
00375   //equal time tracks value
00376   g_key_file_set_integer(my_key_file, "split", "split_mode_equal_time_tracks",
00377       gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spinner_equal_tracks)));
00378 
00379   const ui_main_window *main_win = ui_get_main_window_infos(ui);
00380   g_key_file_set_integer(my_key_file, "gui", "root_x_position", 
00381       main_win->root_x_pos);
00382   g_key_file_set_integer(my_key_file, "gui", "root_y_position", 
00383       main_win->root_y_pos);
00384   g_key_file_set_integer(my_key_file, "gui", "width", 
00385       main_win->width);
00386   g_key_file_set_integer(my_key_file, "gui", "height", 
00387       main_win->height);
00388 
00389   const char *browser_directory = ui_get_browser_directory(ui);
00390   if (browser_directory != NULL)
00391   {
00392     g_key_file_set_string(my_key_file, "gui", "browser_directory", browser_directory);
00393   }
00394 
00395   gchar *key_data = g_key_file_to_data(my_key_file, NULL, NULL);
00396 
00397   //we write to the preference file
00398   FILE *preferences_file;
00399   preferences_file = (FILE *)g_fopen(filename,"w");
00400   g_fprintf(preferences_file,"%s", key_data);
00401   fclose(preferences_file);
00402   preferences_file = NULL;
00403 
00404   //we free memory
00405   g_free(key_data);
00406   g_key_file_free(my_key_file);
00407 
00408   if (filename)
00409   {
00410     g_free(filename);
00411     filename = NULL;
00412   }
00413 }
00414 
00416 GtkWidget *create_scrolled_window()
00417 {
00418   GtkWidget *scrolled_window;
00419   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
00420   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_NONE);
00421   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
00422                                   GTK_POLICY_AUTOMATIC,
00423                                   GTK_POLICY_AUTOMATIC);
00424   return scrolled_window;
00425 }
00426 
00428 void output_radio_box_event(GtkToggleButton *radio_b, gpointer data)
00429 {
00430   GtkWidget *output_label = (GtkWidget *)data;
00431 
00432   gint selected = get_checked_output_radio_box();
00433 
00434   //custom output mode
00435   if (selected == 0)
00436   {
00437     gtk_widget_set_sensitive(GTK_WIDGET(output_entry), TRUE);
00438     gtk_widget_set_sensitive(GTK_WIDGET(output_label), TRUE);
00439     mp3splt_set_int_option(the_state, SPLT_OPT_OUTPUT_FILENAMES,
00440         SPLT_OUTPUT_FORMAT);
00441   }
00442   else
00443   {
00444     gtk_widget_set_sensitive(GTK_WIDGET(output_entry), FALSE);
00445     gtk_widget_set_sensitive(GTK_WIDGET(output_label), FALSE);
00446     mp3splt_set_int_option(the_state, SPLT_OPT_OUTPUT_FILENAMES,
00447         SPLT_OUTPUT_DEFAULT);
00448   }
00449 
00450   save_preferences(NULL, NULL);
00451 }
00452 
00454 GtkWidget *create_language_box()
00455 {
00456   GtkWidget *radio_vbox = gtk_vbox_new (FALSE, 0);
00457 
00458   radio_button = gtk_radio_button_new_with_label(NULL, "English");
00459   g_signal_connect(GTK_TOGGLE_BUTTON(radio_button), "toggled",
00460       G_CALLBACK(save_preferences), NULL);
00461   gtk_box_pack_start(GTK_BOX(radio_vbox), radio_button, TRUE, TRUE, 0);
00462 
00463   radio_button = gtk_radio_button_new_with_label_from_widget
00464     (GTK_RADIO_BUTTON(radio_button), "Français");
00465   g_signal_connect(GTK_TOGGLE_BUTTON(radio_button), "toggled",
00466       G_CALLBACK(save_preferences), NULL);
00467   gtk_box_pack_start(GTK_BOX(radio_vbox), radio_button, TRUE, TRUE, 0);
00468 
00469   radio_button = gtk_radio_button_new_with_label_from_widget
00470     (GTK_RADIO_BUTTON(radio_button), "Deutsch");
00471   g_signal_connect(GTK_TOGGLE_BUTTON (radio_button), "toggled",
00472       G_CALLBACK(save_preferences), NULL);
00473   gtk_box_pack_start(GTK_BOX(radio_vbox), radio_button, TRUE, TRUE, 0);
00474 
00475   return wh_set_title_and_get_vbox(radio_vbox,
00476       _("<b>Choose language (requires restart)</b>"));
00477 }
00478 
00480 GtkWidget *create_pref_language_page()
00481 {
00482   GtkWidget *language_hbox = gtk_hbox_new(FALSE, 0);;
00483  
00484   //vertical box inside the scrolled window
00485   GtkWidget *language_inside_hbox = gtk_hbox_new(FALSE, 0);;
00486 
00487   //scrolled window
00488   GtkWidget *scrolled_window;
00489   scrolled_window = create_scrolled_window();
00490   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 
00491                                         GTK_WIDGET(language_inside_hbox));
00492   gtk_box_pack_start(GTK_BOX(language_hbox), scrolled_window, TRUE, TRUE, 0);
00493  
00494   //vertical box inside the horizontal box from the scrolled window
00495   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);;
00496   gtk_box_pack_start(GTK_BOX(language_inside_hbox), vbox, TRUE, TRUE, 10);
00497 
00498   GtkWidget *lang_box = create_language_box();
00499   gtk_box_pack_start(GTK_BOX(vbox), lang_box, FALSE, FALSE, 10);
00500   
00501   return language_hbox;
00502 }
00503 
00505 void browse_dir_button_event(GtkWidget *widget, gpointer data)
00506 {
00507   // file chooser
00508   GtkWidget *dir_chooser;
00509 
00510   //creates and shows the dialog
00511   dir_chooser = gtk_file_chooser_dialog_new(_("Choose split directory"),
00512       NULL,
00513       GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
00514       GTK_STOCK_CANCEL,
00515       GTK_RESPONSE_CANCEL,
00516       GTK_STOCK_OPEN,
00517       GTK_RESPONSE_ACCEPT,
00518       NULL);
00519 
00520   wh_set_browser_directory_handler(ui, dir_chooser);
00521 
00522   if (gtk_dialog_run(GTK_DIALOG(dir_chooser)) == GTK_RESPONSE_ACCEPT)
00523   {
00524     gchar *filename =
00525       gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dir_chooser));
00526 
00527     outputdirectory_set(filename);
00528 
00529     g_free (filename);
00530     filename = NULL;
00531 
00532     save_preferences(NULL, NULL);
00533   }
00534 
00535   //destroys dialog
00536   gtk_widget_destroy(dir_chooser);
00537 }
00538 
00540 void disable_adjust_spinners()
00541 {
00542   gtk_widget_set_sensitive(spinner_adjust_threshold, FALSE);
00543   gtk_widget_set_sensitive(spinner_adjust_offset, FALSE);
00544   gtk_widget_set_sensitive(spinner_adjust_gap, FALSE);
00545   gtk_widget_set_sensitive(threshold_label, FALSE);
00546   gtk_widget_set_sensitive(offset_label, FALSE);
00547   gtk_widget_set_sensitive(gap_label, FALSE);
00548 }
00549 
00551 void enable_adjust_spinners()
00552 {
00553   gtk_widget_set_sensitive(spinner_adjust_threshold, TRUE);
00554   gtk_widget_set_sensitive(spinner_adjust_offset, TRUE);
00555   gtk_widget_set_sensitive(spinner_adjust_gap, TRUE);
00556   gtk_widget_set_sensitive(threshold_label, TRUE);
00557   gtk_widget_set_sensitive(offset_label, TRUE);
00558   gtk_widget_set_sensitive(gap_label, TRUE);
00559 }
00560 
00562 void adjust_event(GtkToggleButton *adjust_mode, gpointer user_data)
00563 {
00564   //if it is toggled
00565   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(adjust_mode)))
00566   {
00567     if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(frame_mode)))
00568     {
00569       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(frame_mode),TRUE);
00570     }
00571     enable_adjust_spinners();
00572   }
00573   else
00574   {
00575     //disable spinners
00576     disable_adjust_spinners();
00577   }
00578 
00579   save_preferences(NULL, NULL);
00580 }
00581 
00583 void frame_event(GtkToggleButton *frame_mode, gpointer user_data)
00584 {
00585   if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(frame_mode)))
00586   {
00587     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(adjust_mode)))
00588     {
00589       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(adjust_mode),FALSE);
00590     }
00591   }
00592 
00593   save_preferences(NULL, NULL);
00594 }
00595 
00596 void splitpoints_from_filename_event(GtkToggleButton *frame_mode, gpointer user_data)
00597 {
00598   gint splitpoints_from_filename = FALSE;
00599 
00600   if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(names_from_filename)))
00601   {
00602     splitpoints_from_filename = FALSE;
00603   }
00604   else
00605   {
00606     splitpoints_from_filename = TRUE;
00607   }
00608 
00609   if (splitpoints_from_filename == TRUE && file_browsed == TRUE)
00610   {
00611     copy_filename_to_current_description(inputfilename_get());
00612   }
00613   else
00614   {
00615     clear_current_description();
00616   }
00617 
00618   save_preferences(NULL, NULL);
00619 }
00620 
00622 void set_default_prefs_event(GtkWidget *widget, gpointer data)
00623 {
00624   //set frame mode inactive
00625   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(frame_mode), FALSE);
00626   //set adjust mode inactive
00627   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(adjust_mode), FALSE);
00628   //set adjust mode preferences
00629   gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_adjust_threshold),
00630                             SPLT_DEFAULT_PARAM_THRESHOLD);
00631   gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_adjust_offset),
00632                             SPLT_DEFAULT_PARAM_OFFSET);
00633   gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_adjust_gap),
00634                             SPLT_DEFAULT_PARAM_GAP);
00635   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(names_from_filename), FALSE);
00636 
00637   save_preferences(NULL, NULL);
00638 }
00639 
00641 void song_dir_button_event(GtkWidget *widget, gpointer data)
00642 {
00643     outputdirectory_set("");
00644     save_preferences(NULL, NULL);
00645 }
00646 
00648 GtkWidget *create_directory_box()
00649 {
00650   GtkWidget *dir_hbox = gtk_hbox_new(FALSE, 0);
00651   
00652   //directory entry
00653   directory_entry = gtk_entry_new();
00654   gtk_editable_set_editable(GTK_EDITABLE(directory_entry), FALSE);
00655   gtk_box_pack_start(GTK_BOX(dir_hbox), directory_entry, TRUE, TRUE, 0);
00656   // Put the right text into the text box containing the output directory
00657   // name if this name was provided on command line
00658   if(outputdirectory_get()!=NULL)
00659     gtk_entry_set_text(GTK_ENTRY(directory_entry), outputdirectory_get());
00660   
00661   //browse dir button
00662   GtkWidget *browse_dir_button = (GtkWidget *)
00663     create_cool_button(GTK_STOCK_DIRECTORY,_("Br_owse dir"), FALSE);
00664   g_signal_connect(G_OBJECT(browse_dir_button), "clicked",
00665       G_CALLBACK(browse_dir_button_event), NULL);
00666   gtk_box_pack_start(GTK_BOX(dir_hbox), browse_dir_button, FALSE, FALSE, 8);
00667   
00668   //to set the directory for split files to the current song
00669   //directory
00670   GtkWidget *song_dir_button = (GtkWidget *)
00671     create_cool_button(GTK_STOCK_CLEAR, _("_Song dir"), FALSE);
00672   g_signal_connect(G_OBJECT(song_dir_button), "clicked",
00673       G_CALLBACK(song_dir_button_event), NULL);
00674   gtk_box_pack_start(GTK_BOX(dir_hbox), song_dir_button, FALSE, FALSE, 0);
00675 
00676   return wh_set_title_and_get_vbox(dir_hbox, _("<b>Directory for split files</b>"));
00677 }
00678 
00680 GtkWidget *create_split_options_box()
00681 {
00682   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
00683 
00684   //names from filename
00685   names_from_filename = gtk_check_button_new_with_mnemonic(_("_Splitpoint name from filename (testing)"));
00686   gtk_box_pack_start(GTK_BOX(vbox), names_from_filename, FALSE, FALSE, 0);
00687   g_signal_connect(G_OBJECT(names_from_filename), "toggled",
00688       G_CALLBACK(splitpoints_from_filename_event), NULL);
00689 
00690   create_dirs_from_output_files =
00691     gtk_check_button_new_with_mnemonic(_("_Create directories from filenames "));
00692   gtk_box_pack_start(GTK_BOX(vbox), create_dirs_from_output_files, FALSE, FALSE, 0);
00693   g_signal_connect(G_OBJECT(create_dirs_from_output_files), "toggled",
00694       G_CALLBACK(save_preferences), NULL);
00695 
00696   //frame mode option
00697   frame_mode = gtk_check_button_new_with_mnemonic(_("F_rame mode (useful"
00698         " for mp3 VBR) (mp3 only)"));
00699   gtk_box_pack_start(GTK_BOX(vbox), frame_mode, FALSE, FALSE, 0);
00700   g_signal_connect(G_OBJECT(frame_mode), "toggled",
00701       G_CALLBACK(frame_event), NULL);
00702 
00703   //auto adjust option
00704   adjust_mode = gtk_check_button_new_with_mnemonic(_("_Auto-adjust mode (uses"
00705         " silence detection to auto-adjust splitpoints)"));
00706   gtk_box_pack_start(GTK_BOX(vbox), adjust_mode, FALSE, FALSE, 0);
00707   g_signal_connect(G_OBJECT(adjust_mode), "toggled",
00708       G_CALLBACK(adjust_event), NULL);
00709   
00710   //parameters for the adjust option
00711   GtkWidget *horiz_fake = gtk_hbox_new(FALSE,0);
00712   gtk_box_pack_start(GTK_BOX(vbox), horiz_fake, FALSE, FALSE, 0);
00713   
00714   GtkWidget *param_vbox = gtk_vbox_new(FALSE,0);
00715   gtk_box_pack_start(GTK_BOX(horiz_fake), param_vbox, FALSE, FALSE, 25);
00716   
00717   //threshold level
00718   horiz_fake = gtk_hbox_new(FALSE,0);
00719   gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
00720   
00721   threshold_label = gtk_label_new(_("Threshold level (dB):"));
00722   gtk_box_pack_start(GTK_BOX(horiz_fake), threshold_label, FALSE, FALSE, 0);
00723   
00724   GtkAdjustment *adj = (GtkAdjustment *) gtk_adjustment_new(0.0, -96.0, 0.0,
00725       0.5, 10.0, 0.0);
00726   spinner_adjust_threshold = gtk_spin_button_new (adj, 0.5, 2);
00727   g_signal_connect(G_OBJECT(spinner_adjust_threshold), "value_changed",
00728       G_CALLBACK(save_preferences), NULL);
00729   gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_adjust_threshold,
00730                       FALSE, FALSE, 6);
00731   
00732   //offset level
00733   horiz_fake = gtk_hbox_new(FALSE,0);
00734   gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
00735   
00736   offset_label = gtk_label_new(_("Cutpoint offset (0 is the begin of silence "
00737         "and 1 the end):"));
00738   gtk_box_pack_start(GTK_BOX(horiz_fake), offset_label, FALSE, FALSE, 0);
00739   
00740   //adjustement for the offset spinner
00741   adj = (GtkAdjustment *)gtk_adjustment_new(0.0, -2, 2, 0.05, 10.0, 0.0);
00742   //the offset spinner
00743   spinner_adjust_offset = gtk_spin_button_new (adj, 0.05, 2);
00744   g_signal_connect(G_OBJECT(spinner_adjust_offset), "value_changed",
00745       G_CALLBACK(save_preferences), NULL);
00746   gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_adjust_offset,
00747       FALSE, FALSE, 6);
00748   
00749   //gap level (seconds)
00750   horiz_fake = gtk_hbox_new(FALSE,0);
00751   gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
00752   
00753   gap_label = gtk_label_new(_("Gap level (seconds around splitpoint to "
00754         "search for silence):"));
00755   gtk_box_pack_start(GTK_BOX(horiz_fake), gap_label, FALSE, FALSE, 0);
00756   
00757   adj = (GtkAdjustment *) gtk_adjustment_new(0.0, 0, 2000, 1.0, 10.0, 0.0);
00758   spinner_adjust_gap = gtk_spin_button_new (adj, 1, 0);
00759   g_signal_connect(G_OBJECT(spinner_adjust_gap), "value_changed",
00760       G_CALLBACK(save_preferences), NULL);
00761   gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_adjust_gap, FALSE, FALSE, 6);
00762   
00763   disable_adjust_spinners();
00764  
00765   //set default preferences button
00766   //horizontal box fake for the gap level
00767   horiz_fake = gtk_hbox_new(FALSE,0);
00768   gtk_box_pack_start(GTK_BOX(vbox), horiz_fake, FALSE, FALSE, 0);
00769   
00770   GtkWidget *set_default_prefs_button =
00771     (GtkWidget *)create_cool_button(GTK_STOCK_PREFERENCES,
00772         _("Set _default split" " options"),FALSE); 
00773   g_signal_connect(G_OBJECT(set_default_prefs_button), "clicked",
00774       G_CALLBACK(set_default_prefs_event), NULL);
00775   gtk_box_pack_start (GTK_BOX (horiz_fake), set_default_prefs_button,
00776                       FALSE, FALSE, 5);
00777 
00778   return wh_set_title_and_get_vbox(vbox, _("<b>Split options</b>"));
00779 }
00780 
00782 GtkWidget *create_pref_splitpoints_page()
00783 {
00784   GtkWidget *general_hbox = gtk_hbox_new(FALSE,0);
00785   GtkWidget *inside_hbox = gtk_hbox_new(FALSE,0);
00786   
00787   GtkWidget *scrolled_window = create_scrolled_window();
00788   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 
00789                                         GTK_WIDGET(inside_hbox));
00790   gtk_box_pack_start(GTK_BOX(general_hbox), scrolled_window, TRUE, TRUE, 0);
00791  
00792   //vertical box inside the horizontal box from the scrolled window
00793   GtkWidget *inside_vbox = gtk_vbox_new(FALSE, 0);
00794   gtk_box_pack_start(GTK_BOX(inside_hbox), inside_vbox, TRUE, TRUE, 5);
00795  
00796   GtkWidget *dir_box = create_directory_box();
00797   gtk_box_pack_start(GTK_BOX(inside_vbox), dir_box, FALSE, FALSE, 2);
00798 
00799   GtkWidget *split_options_box = create_split_options_box();
00800   gtk_box_pack_start(GTK_BOX(inside_vbox), split_options_box, FALSE, FALSE, 1);
00801  
00802   return general_hbox;
00803 }
00804 
00806 void player_combo_box_event(GtkComboBox *widget, gpointer data)
00807 {
00808   disconnect_button_event(NULL, NULL);
00809 
00810   selected_player = ch_get_active_value(widget);
00811 
00812   if (selected_player == PLAYER_GSTREAMER)
00813   {
00814     hide_connect_button();
00815     gtk_widget_show(playlist_box);
00816   }
00817   else
00818   {
00819     show_connect_button();
00820     close_playlist_popup_window_event(NULL, NULL);
00821     gtk_widget_hide(playlist_box);
00822   }
00823   
00824   gtk_widget_show(player_box);
00825   gtk_widget_show(queue_files_button);
00826 
00827   save_preferences(NULL, NULL);
00828 }
00829 
00830 void update_timeout_value(GtkWidget *refresh_rate_spinner, gpointer data)
00831 {
00832   timeout_value = 
00833     gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(player_refresh_rate_spinner));
00834 
00835   restart_player_timer();
00836   save_preferences(NULL, NULL);
00837 }
00838 
00840 GtkWidget *create_player_options_box()
00841 {
00842   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
00843 
00844   GtkWidget *horiz_fake = gtk_hbox_new(FALSE, 0);
00845 
00846   GtkWidget *label = gtk_label_new(_("Player:"));
00847   gtk_box_pack_start(GTK_BOX(horiz_fake), label, FALSE, FALSE, 0);
00848 
00849   player_combo_box = GTK_WIDGET(ch_new_combo());
00850 
00851 #ifndef NO_AUDACIOUS
00852   ch_append_to_combo(GTK_COMBO_BOX(player_combo_box), "Audacious", PLAYER_AUDACIOUS);
00853 #endif
00854   ch_append_to_combo(GTK_COMBO_BOX(player_combo_box), "SnackAmp", PLAYER_SNACKAMP);
00855 #ifndef NO_GSTREAMER
00856   ch_append_to_combo(GTK_COMBO_BOX(player_combo_box), "GStreamer", PLAYER_GSTREAMER);
00857 #endif
00858 
00859   g_signal_connect(G_OBJECT(player_combo_box), "changed",
00860       G_CALLBACK(player_combo_box_event), NULL);
00861 
00862   gtk_box_pack_start(GTK_BOX(horiz_fake), player_combo_box, FALSE, FALSE, 5);
00863   gtk_box_pack_start(GTK_BOX(vbox), horiz_fake, FALSE, FALSE, 0);
00864 
00865   //Player Splitpoints view refresh rate
00866   horiz_fake = gtk_hbox_new(FALSE,0);
00867 
00868   label = gtk_label_new(_("Refresh player every "));
00869   gtk_box_pack_start(GTK_BOX(horiz_fake), label, FALSE, FALSE, 0);
00870 
00871   GtkAdjustment *adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
00872       20, 1000, 10.0, 100.0, 0.0);
00873   player_refresh_rate_spinner = gtk_spin_button_new(adj, 0, 0);
00874   gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(player_refresh_rate_spinner), TRUE);
00875   g_signal_connect(G_OBJECT(player_refresh_rate_spinner), "value_changed",
00876       G_CALLBACK(update_timeout_value), NULL);
00877 
00878   gtk_box_pack_start(GTK_BOX(horiz_fake), player_refresh_rate_spinner, FALSE, FALSE, 5);
00879   gtk_box_pack_start(GTK_BOX(horiz_fake), gtk_label_new(_("milliseconds.")), FALSE, FALSE, 3);
00880   gtk_box_pack_start(GTK_BOX(vbox), horiz_fake, FALSE, FALSE, 5);
00881 
00882   horiz_fake = gtk_hbox_new(FALSE,0);
00883   gtk_box_pack_start(GTK_BOX(horiz_fake), 
00884       gtk_label_new(_("Higher refresh rate decreases CPU usage - default is 200.")),
00885       FALSE, FALSE, 0);
00886   gtk_box_pack_start(GTK_BOX(vbox), horiz_fake, FALSE, FALSE, 5);
00887  
00888   return wh_set_title_and_get_vbox(vbox, _("<b>Player options</b>"));
00889 }
00890 
00892 GtkWidget *create_pref_player_page()
00893 {
00894   GtkWidget *player_hbox = gtk_hbox_new(FALSE, 0);;
00895 
00896   GtkWidget *inside_hbox = gtk_hbox_new(FALSE, 0);;
00897   
00898   GtkWidget *scrolled_window = create_scrolled_window();
00899   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 
00900                                         GTK_WIDGET(inside_hbox));
00901   gtk_box_pack_start(GTK_BOX(player_hbox), scrolled_window, TRUE, TRUE, 0);
00902   
00903   //vertical box inside the horizontal box from the scrolled window
00904   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);;
00905   gtk_box_pack_start(GTK_BOX(inside_hbox), vbox, TRUE, TRUE, 5);
00906   
00907   //choose player combo box
00908   GtkWidget *player_options_box = create_player_options_box();
00909   gtk_box_pack_start(GTK_BOX(vbox), player_options_box, FALSE, FALSE, 3);
00910  
00911   return player_hbox;
00912 }
00913 
00915 gboolean output_entry_event(GtkWidget *widget, GdkEventKey *event,
00916     gpointer user_data)
00917 {
00918   //we check if the output format is correct
00919   const char *data = gtk_entry_get_text(GTK_ENTRY(output_entry));
00920   gint error = SPLT_OUTPUT_FORMAT_OK;
00921   mp3splt_set_oformat(the_state, data, &error);
00922   remove_status_message();
00923   print_status_bar_confirmation(error);
00924 
00925   save_preferences(NULL, NULL);
00926   
00927   return FALSE;
00928 }
00929 
00931 GtkWidget *create_output_filename_box()
00932 {
00933   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
00934 
00935   //default/custom radio buttons
00936   radio_output = gtk_radio_button_new_with_label(NULL, _("Default format"));
00937   gtk_box_pack_start(GTK_BOX(vbox), radio_output, FALSE, FALSE, 0);
00938 
00939   radio_output = gtk_radio_button_new_with_label_from_widget
00940     (GTK_RADIO_BUTTON(radio_output), _("Custom format"));
00941   gtk_box_pack_start(GTK_BOX(vbox), radio_output, FALSE, FALSE, 0);
00942 
00943   //output entry
00944   GtkWidget *horiz_fake = gtk_hbox_new(FALSE,0);
00945   gtk_box_pack_start(GTK_BOX(vbox), horiz_fake, FALSE, FALSE, 5);
00946 
00947   output_entry = gtk_entry_new();
00948   gtk_editable_set_editable(GTK_EDITABLE(output_entry), TRUE);
00949   g_signal_connect(G_OBJECT(output_entry), "key_release_event",
00950       G_CALLBACK(output_entry_event), NULL);
00951   gtk_entry_set_max_length(GTK_ENTRY(output_entry),244);
00952   gtk_box_pack_start(GTK_BOX(horiz_fake), output_entry, TRUE, TRUE, 0);
00953 
00954   //output label
00955   horiz_fake = gtk_hbox_new(FALSE,0);
00956   gtk_box_pack_start(GTK_BOX(vbox), horiz_fake, FALSE, FALSE, 5);
00957   output_label = gtk_label_new(_("    @f - file name\n"
00958         "    @a - artist name\n"
00959         "    @p - performer of each song (does not"
00960         " always exist)\n"
00961         "    @b - album title\n"
00962         "    @t - song title\n"
00963         "    @g - genre\n"
00964         "    @n - track number"));
00965   gtk_box_pack_start(GTK_BOX(horiz_fake), output_label, FALSE, FALSE, 0);
00966 
00967   g_signal_connect(GTK_TOGGLE_BUTTON(radio_output),
00968       "toggled", G_CALLBACK(output_radio_box_event), output_label);
00969 
00970   return wh_set_title_and_get_vbox(vbox, _("<b>Output filename format</b>"));
00971 }
00972 
00974 GtkWidget *create_pref_output_page()
00975 {
00976   GtkWidget *output_hbox = gtk_hbox_new(FALSE, 0);;
00977   GtkWidget *output_inside_hbox = gtk_hbox_new(FALSE, 0);;
00978   
00979   GtkWidget *scrolled_window = create_scrolled_window();
00980   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 
00981                                         GTK_WIDGET(output_inside_hbox));
00982   gtk_box_pack_start(GTK_BOX(output_hbox), scrolled_window, TRUE, TRUE, 0);
00983  
00984   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);;
00985   gtk_box_pack_start(GTK_BOX(output_inside_hbox), vbox, TRUE, TRUE, 5);
00986 
00987   GtkWidget *output_fname_box = create_output_filename_box();
00988   gtk_box_pack_start(GTK_BOX(vbox), output_fname_box, FALSE, FALSE, 2);
00989 
00990   return output_hbox;
00991 }
00992 
00993 void change_tags_options(GtkToggleButton *button, gpointer data)
00994 {
00995   if (extract_tags_box != NULL)
00996   {
00997     if (rh_get_active_value(tags_radio) == TAGS_FROM_FILENAME)
00998     {
00999       gtk_widget_set_sensitive(extract_tags_box, SPLT_TRUE);
01000     }
01001     else
01002     {
01003       gtk_widget_set_sensitive(extract_tags_box, SPLT_FALSE);
01004     }
01005   }
01006 
01007   save_preferences(NULL, NULL);
01008 }
01009 
01011 GtkWidget *create_tags_options_box()
01012 {
01013   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
01014 
01015   tags_radio = rh_append_radio_to_vbox(tags_radio, _("Original file tags"),
01016       ORIGINAL_FILE_TAGS, change_tags_options, vbox);
01017 
01018   tags_radio = rh_append_radio_to_vbox(tags_radio, _("Default tags (cddb or cue tags)"),
01019       DEFAULT_TAGS, change_tags_options, vbox);
01020 
01021   tags_radio = rh_append_radio_to_vbox(tags_radio, _("No tags"),
01022       NO_TAGS, change_tags_options, vbox);
01023 
01024   tags_radio = rh_append_radio_to_vbox(tags_radio, _("Extract tags from filename"),
01025       TAGS_FROM_FILENAME, change_tags_options, vbox);
01026 
01027   extract_tags_box = create_extract_tags_from_filename_options_box();
01028   gtk_widget_set_sensitive(extract_tags_box, SPLT_FALSE);
01029   gtk_box_pack_start(GTK_BOX(vbox), extract_tags_box, FALSE, FALSE, 2);
01030 
01031   return wh_set_title_and_get_vbox(vbox, _("<b>Split files tags</b>"));
01032 }
01033 
01034 static GtkComboBox *create_genre_combo()
01035 {
01036   GtkComboBox *combo = ch_new_combo();
01037 
01038   int i = 0;
01039   for (i = 0;i < SPLT_ID3V1_NUMBER_OF_GENRES;i++)
01040   {
01041     ch_append_to_combo(combo, splt_id3v1_genres[i], 0);
01042   }
01043 
01044   g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(save_preferences), NULL);
01045 
01046   return combo;
01047 }
01048 
01049 static GtkComboBox *create_text_preferences_combo()
01050 {
01051   GtkComboBox *combo = ch_new_combo();
01052 
01053   ch_append_to_combo(combo, _("No change"), SPLT_NO_CONVERSION);
01054   ch_append_to_combo(combo, _("lowercase"), SPLT_TO_LOWERCASE);
01055   ch_append_to_combo(combo, _("UPPERCASE"), SPLT_TO_UPPERCASE);
01056   ch_append_to_combo(combo, _("First uppercase"), SPLT_TO_FIRST_UPPERCASE);
01057   ch_append_to_combo(combo, _("Word Uppercase"), SPLT_TO_WORD_FIRST_UPPERCASE);
01058 
01059   g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(save_preferences), NULL);
01060 
01061   return combo;
01062 }
01063 
01064 void test_regex_event(GtkWidget *widget, gpointer data)
01065 {
01066   put_tags_from_filename_regex_options();
01067   const gchar *test_regex_filename = gtk_entry_get_text(GTK_ENTRY(test_regex_fname_entry));
01068   mp3splt_set_filename_to_split(the_state, test_regex_filename);
01069 
01070   gint error = SPLT_OK;
01071   splt_tags *tags = mp3splt_parse_filename_regex(the_state, &error);
01072   print_status_bar_confirmation(error);
01073 
01074   if (error >= 0)
01075   {
01076     GString *regex_result = g_string_new(NULL);
01077 
01078     g_string_append(regex_result, _("<artist>: "));
01079     if (tags->artist)
01080     {
01081       g_string_append(regex_result, tags->artist);
01082     }
01083     g_string_append(regex_result, "\n");
01084 
01085     g_string_append(regex_result, _("<album>: "));
01086     if (tags->album)
01087     {
01088       g_string_append(regex_result, tags->album);
01089     }
01090     g_string_append(regex_result, "\n");
01091 
01092 
01093     g_string_append(regex_result, _("<title>: "));
01094     if (tags->title)
01095     {
01096       g_string_append(regex_result, tags->title);
01097     }
01098     g_string_append(regex_result, "\n");
01099 
01100     g_string_append(regex_result, _("<genre>: "));
01101     if (tags->genre)
01102     {
01103       g_string_append(regex_result, tags->genre);
01104     }
01105     g_string_append(regex_result, "\n");
01106 
01107     g_string_append(regex_result, _("<comment>: "));
01108     if (tags->comment)
01109     {
01110       g_string_append(regex_result, tags->comment);
01111     }
01112     g_string_append(regex_result, "\n");
01113 
01114     g_string_append(regex_result, _("<year>: "));
01115     if (tags->year)
01116     {
01117       g_string_append(regex_result, tags->year);
01118     }
01119     g_string_append(regex_result, "\n");
01120 
01121     g_string_append(regex_result, _("<track>: "));
01122     if (tags->track >= 0)
01123     {
01124       g_string_append_printf(regex_result, "%d", tags->track);
01125     }
01126 
01127     gchar *regex_result_text = g_string_free(regex_result, FALSE);
01128     if (regex_result_text)
01129     {
01130       gtk_label_set_text(GTK_LABEL(sample_result_label), regex_result_text);
01131       g_free(regex_result_text);
01132     }
01133   }
01134   else
01135   {
01136     gtk_label_set_text(GTK_LABEL(sample_result_label), "");
01137   }
01138 
01139   mp3splt_free_one_tag(tags);
01140 }
01141 
01142 static GtkWidget *create_extract_tags_from_filename_options_box()
01143 {
01144   GtkWidget *table = wh_new_table();
01145 
01146   regex_entry = wh_new_entry(save_preferences);
01147   wh_add_in_table_with_label_expand(table, _("Regular expression:"), regex_entry);
01148 
01149   GtkWidget *regex_label = gtk_label_new(_(
01150         "Above enter PERL-like regular expression using named subgroups.\nFollowing names are recognized:\n"
01151         "    (?<artist>)   - artist name\n"
01152         "    (?<album>)    - album title\n"
01153         "    (?<title>)    - track title\n"
01154         "    (?<tracknum>) - current track number\n"
01155         //"    (?<tracks>)   - total number of tracks\n"
01156         "    (?<year>)     - year of emission\n"
01157         "    (?<genre>)    - genre\n"
01158         "    (?<comment>)  - comment"));
01159   gtk_misc_set_alignment(GTK_MISC(regex_label), 0.0, 0.5);
01160   wh_add_in_table(table, wh_put_in_new_hbox_with_margin_level(regex_label, 2));
01161 
01162   text_options_list =
01163     g_list_append(text_options_list, GINT_TO_POINTER(SPLT_NO_CONVERSION));
01164   text_options_list = 
01165     g_list_append(text_options_list, GINT_TO_POINTER(SPLT_TO_LOWERCASE));
01166   text_options_list = 
01167     g_list_append(text_options_list, GINT_TO_POINTER(SPLT_TO_UPPERCASE));
01168   text_options_list =
01169     g_list_append(text_options_list, GINT_TO_POINTER(SPLT_TO_FIRST_UPPERCASE));
01170   text_options_list =
01171     g_list_append(text_options_list, GINT_TO_POINTER(SPLT_TO_WORD_FIRST_UPPERCASE));
01172 
01173   replace_underscore_by_space_check_box =
01174     gtk_check_button_new_with_mnemonic(_("_Replace underscores by spaces"));
01175   g_signal_connect(G_OBJECT(replace_underscore_by_space_check_box), "toggled",
01176       G_CALLBACK(save_preferences), NULL);
01177  
01178   wh_add_in_table(table, replace_underscore_by_space_check_box);
01179 
01180   artist_text_properties_combo = create_text_preferences_combo();
01181   wh_add_in_table_with_label(table, 
01182       _("Artist text properties:"), GTK_WIDGET(artist_text_properties_combo));
01183 
01184   album_text_properties_combo = create_text_preferences_combo();
01185   wh_add_in_table_with_label(table,
01186       _("Album text properties:"), GTK_WIDGET(album_text_properties_combo));
01187 
01188   title_text_properties_combo = create_text_preferences_combo();
01189   wh_add_in_table_with_label(table,
01190       _("Title text properties:"), GTK_WIDGET(title_text_properties_combo));
01191 
01192   comment_text_properties_combo = create_text_preferences_combo();
01193   wh_add_in_table_with_label(table,
01194       _("Comment text properties:"), GTK_WIDGET(comment_text_properties_combo));
01195 
01196   genre_combo = create_genre_combo();
01197   wh_add_in_table_with_label(table, _("Genre tag:"), GTK_WIDGET(genre_combo));
01198 
01199   comment_tag_entry = wh_new_entry(save_preferences);
01200   wh_add_in_table_with_label_expand(table, _("Comment tag:"), comment_tag_entry);
01201 
01202   GtkWidget *test_regex_expander = gtk_expander_new(_("Regular expression test"));
01203   gtk_container_add(GTK_CONTAINER(test_regex_expander), create_test_regex_table());
01204   wh_add_in_table(table, test_regex_expander);
01205 
01206   return wh_put_in_new_hbox_with_margin_level(GTK_WIDGET(table), 3);
01207 }
01208 
01209 static GtkWidget *create_test_regex_table()
01210 {
01211   GtkWidget *table = wh_new_table();
01212 
01213   GtkWidget *sample_test_hbox = gtk_hbox_new(FALSE, 0);
01214   test_regex_fname_entry = wh_new_entry(save_preferences);
01215   gtk_box_pack_start(GTK_BOX(sample_test_hbox), test_regex_fname_entry, TRUE, TRUE, 0);
01216 
01217   GtkWidget *test_regex_button = wh_new_button(_("_Test"));
01218   gtk_box_pack_start(GTK_BOX(sample_test_hbox), test_regex_button, FALSE, FALSE, 5);
01219   g_signal_connect(G_OBJECT(test_regex_button), "clicked",
01220       G_CALLBACK(test_regex_event), NULL);
01221 
01222   wh_add_in_table_with_label_expand(table, _("Sample filename:"), sample_test_hbox);
01223 
01224   sample_result_label = gtk_label_new("");
01225   gtk_misc_set_alignment(GTK_MISC(sample_result_label), 0.0, 0.5);
01226   wh_add_in_table_with_label_expand(table, _("Sample result:"), sample_result_label);
01227 
01228   return wh_put_in_new_hbox_with_margin_level(GTK_WIDGET(table), 3);
01229 }
01230 
01232 GtkWidget *create_tags_version_box()
01233 {
01234   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
01235 
01236   tags_version_radio = 
01237     gtk_radio_button_new_with_label(NULL, _("ID3v1 & ID3v2 tags"));
01238   gtk_box_pack_start(GTK_BOX(vbox), tags_version_radio, FALSE, FALSE, 0);
01239   g_signal_connect(GTK_TOGGLE_BUTTON(tags_version_radio), "toggled", 
01240       G_CALLBACK(save_preferences), NULL);
01241 
01242   tags_version_radio = 
01243     gtk_radio_button_new_with_label_from_widget
01244     (GTK_RADIO_BUTTON(tags_version_radio), _("ID3v2 tags"));
01245   gtk_box_pack_start(GTK_BOX(vbox), tags_version_radio, FALSE, FALSE, 0);
01246   g_signal_connect(GTK_TOGGLE_BUTTON(tags_version_radio), "toggled", 
01247       G_CALLBACK(save_preferences), NULL);
01248 
01249   tags_version_radio = gtk_radio_button_new_with_label_from_widget
01250     (GTK_RADIO_BUTTON(tags_version_radio), _("ID3v1 tags"));
01251   g_signal_connect(GTK_TOGGLE_BUTTON(tags_version_radio), "toggled", 
01252       G_CALLBACK(save_preferences), NULL);
01253   gtk_box_pack_start(GTK_BOX(vbox), tags_version_radio, FALSE, FALSE, 0);
01254 
01255   tags_version_radio = gtk_radio_button_new_with_label_from_widget
01256     (GTK_RADIO_BUTTON (tags_version_radio),_("Same tags version as the input file"));
01257   g_signal_connect(GTK_TOGGLE_BUTTON(tags_version_radio), "toggled", 
01258       G_CALLBACK(save_preferences), NULL);
01259   gtk_box_pack_start(GTK_BOX(vbox), tags_version_radio, FALSE, FALSE, 0);
01260 
01261   return wh_set_title_and_get_vbox(vbox, _("<b>Tags version (mp3 only)</b>"));
01262 }
01263 
01265 GtkWidget *create_pref_tags_page()
01266 {
01267   GtkWidget *outside_vbox = gtk_vbox_new(FALSE, 0);;
01268   GtkWidget *inside_hbox = gtk_hbox_new(FALSE, 0);
01269 
01270   GtkWidget *scrolled_window = create_scrolled_window();
01271   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), 
01272                                         GTK_WIDGET(inside_hbox));
01273   gtk_box_pack_start(GTK_BOX(outside_vbox), scrolled_window, TRUE, TRUE, 0);
01274 
01275   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);;
01276   gtk_box_pack_start(GTK_BOX(inside_hbox), vbox, TRUE, TRUE, 5);
01277 
01278   GtkWidget *tags_version_box = create_tags_version_box();
01279   gtk_box_pack_start(GTK_BOX(vbox), tags_version_box, FALSE, FALSE, 2);
01280 
01281   GtkWidget *tags_opts_box = create_tags_options_box();
01282   gtk_box_pack_start(GTK_BOX(vbox), tags_opts_box, FALSE, FALSE, 1);
01283   
01284   return outside_vbox;
01285 }
01286 
01288 GtkWidget *create_choose_preferences()
01289 {
01290   //our preferences vbox
01291   GtkWidget *pref_vbox = gtk_vbox_new(FALSE, 0);
01292 
01293   GtkWidget *notebook = gtk_notebook_new();
01294   gtk_box_pack_start(GTK_BOX(pref_vbox), notebook, TRUE, TRUE, 0);
01295   
01296   gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
01297   gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), TRUE);
01298   gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
01299   gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
01300   
01301   /* split preferences */
01302   GtkWidget *splitpoints_prefs = (GtkWidget *)create_pref_splitpoints_page();
01303   GtkWidget *notebook_label = gtk_label_new(_("Split"));
01304   gtk_notebook_append_page(GTK_NOTEBOOK(notebook), splitpoints_prefs,
01305                            (GtkWidget *)notebook_label);
01306 
01307   /* tags preferences */
01308   GtkWidget *tags_prefs = (GtkWidget *)create_pref_tags_page();
01309   notebook_label = gtk_label_new(_("Tags"));
01310   gtk_notebook_append_page(GTK_NOTEBOOK(notebook), tags_prefs,
01311                            (GtkWidget *)notebook_label);
01312 
01313   /* output preferences */
01314   GtkWidget *output_prefs = (GtkWidget *)create_pref_output_page();
01315   notebook_label = gtk_label_new(_("Output"));
01316   gtk_notebook_append_page(GTK_NOTEBOOK(notebook), output_prefs,
01317                            (GtkWidget *)notebook_label);
01318   
01319   /* player preferences */
01320   GtkWidget *player_prefs = (GtkWidget *)create_pref_player_page();
01321   notebook_label = gtk_label_new(_("Player"));
01322   gtk_notebook_append_page(GTK_NOTEBOOK(notebook), player_prefs,
01323                            (GtkWidget *)notebook_label);
01324 
01325   /* language preferences page */
01326 #ifdef __WIN32__
01327   GtkWidget *language_prefs = (GtkWidget *)create_pref_language_page();
01328   notebook_label = gtk_label_new(_("Language"));
01329   gtk_notebook_append_page(GTK_NOTEBOOK(notebook), language_prefs,
01330                            (GtkWidget *)notebook_label);
01331 #endif
01332   
01333   return pref_vbox;
01334 }