43static gboolean check_if_splitpoint_does_not_exists(gint minutes, gint seconds, gint hundr_secs,
46 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
49 if (!gtk_tree_model_get_iter_first(model, &iter))
60 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
61 COL_MINUTES, &tree_minutes,
62 COL_SECONDS, &tree_seconds,
63 COL_HUNDR_SECS, &tree_hundr_secs,
66 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
67 gint i = gtk_tree_path_get_indices (path)[0];
69 if ((minutes == tree_minutes) &&
70 (seconds == tree_seconds) &&
71 (hundr_secs == tree_hundr_secs) &&
74 gtk_tree_path_free(path);
78 gtk_tree_path_free(path);
80 if (!gtk_tree_model_iter_next(model, &iter))
94static void update_add_button(
ui_state *ui)
97 if (check_if_splitpoint_does_not_exists(status->spin_mins, status->spin_secs, status->spin_hundr_secs,-1, ui))
99 gtk_widget_set_sensitive(GTK_WIDGET(ui->gui->add_button), TRUE);
103 gtk_widget_set_sensitive(GTK_WIDGET(ui->gui->add_button), FALSE);
110 ui->status->spin_mins = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ui->gui->spinner_minutes));
111 update_add_button(ui);
117 ui->status->spin_secs = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ui->gui->spinner_seconds));
118 update_add_button(ui);
124 ui->status->spin_hundr_secs = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ui->gui->spinner_hundr_secs));
125 update_add_button(ui);
129static GtkTreeModel *create_model()
131 GtkListStore * model = gtk_list_store_new(NUM_COLUMNS,
149 return GTK_TREE_MODEL(model);
153static void recompute_length_column(
ui_state *ui)
155 gint line_mins, line_secs, line_hundr;
156 gint line1_mins, line1_secs, line1_hundr;
158 gchar new_length_string[30];
160 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
163 for (number = 0;number < ui->infos->splitnumber; number++)
165 GtkTreePath *path = gtk_tree_path_new_from_indices(number ,-1);
167 gtk_tree_model_get_iter(model, &iter, path);
169 if (number != ui->infos->splitnumber-1)
171 GtkTreePath *path2 = gtk_tree_path_new_from_indices (number+1 ,-1);
173 gtk_tree_model_get_iter(model, &iter2, path2);
175 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
176 COL_MINUTES, &line_mins,
177 COL_SECONDS, &line_secs,
178 COL_HUNDR_SECS, &line_hundr,
180 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter2,
181 COL_MINUTES, &line1_mins,
182 COL_SECONDS, &line1_secs,
183 COL_HUNDR_SECS, &line1_hundr,
186 gint result_secs = 0,result_hundr = 0;
187 gint result_mins = line1_mins - line_mins;
188 if ((result_secs = line1_secs - line_secs) < 0)
190 result_secs = 60 - line_secs + line1_secs;
194 if ((result_hundr = line1_hundr - line_hundr) < 0)
196 result_hundr = 100 - line_hundr + line1_hundr;
205 g_snprintf(new_length_string, 30,
"%d:%02d:%02d", result_mins, result_secs, result_hundr);
207 gtk_tree_path_free(path2);
211 g_snprintf(new_length_string, 30,
"%s",
"-");
214 gtk_tree_path_free(path);
216 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_NUMBER, new_length_string, -1);
227static gboolean check_if_description_exists(gchar *descr, gint number,
ui_state *ui)
229 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
232 if (!gtk_tree_model_get_iter_first(model, &iter))
240 gchar *description = NULL;
241 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
242 COL_DESCRIPTION, &description,
245 if (description != NULL && strcmp(descr, description) == 0 && count != number)
253 if (!gtk_tree_model_iter_next(model, &iter))
265 gint splitpoint_selected = -1;
267 GtkTreeModel *model = gtk_tree_view_get_model(gui->tree_view);
268 GtkTreeSelection *selection = gtk_tree_view_get_selection(gui->tree_view);
270 GList *selected_list =
271 gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), &model);
273 if (g_list_length(selected_list) > 0)
275 GList *current_element = g_list_first(selected_list);
276 GtkTreePath *path = current_element->data;
277 splitpoint_selected = gtk_tree_path_get_indices (path)[0];
279 g_list_foreach(selected_list, (GFunc)gtk_tree_path_free, NULL);
280 g_list_free(selected_list);
283 return splitpoint_selected;
287static void row_selection_event(GtkTreeSelection *selection,
ui_state *ui)
289 gtk_widget_set_sensitive(ui->gui->remove_row_button, TRUE);
302static void update_current_description(gchar *descr, gint number,
ui_state *ui)
306 gchar *current_description = ui->status->current_description;
308 g_snprintf(current_description, 255,
"%s", descr);
310 while (ll < ui->infos->splitnumber)
312 if (check_if_description_exists(current_description, number, ui))
320 gchar *t = current_description;
321 while ((t = strstr(t, _(
"_part"))) != NULL)
331 gchar *temp = g_strdup(current_description);
332 g_snprintf(current_description, 255, _(
"%s_part%d"), temp, ll + 2);
344 gint *time_secs,gint *time_mins)
346 *time_hundr = time_pos % 100;
347 time_pos = time_pos / 100;
348 *time_secs = time_pos % 60;
349 time_pos = time_pos / 60;
350 *time_mins = time_pos;
356 GtkTreeSelection *selection = gtk_tree_view_get_selection(gui->tree_view);
357 GtkTreeModel *model = gtk_tree_view_get_model(gui->tree_view);
358 GtkTreePath *path = gtk_tree_path_new_from_indices(index ,-1);
361 gtk_tree_model_get_iter(model, &iter, path);
362 gtk_tree_selection_unselect_all(selection);
363 gtk_tree_selection_select_iter(selection, &iter);
365 gtk_tree_path_free(path);
370static void order_all_splitpoints_from_table(
const char *current_description_base,
374 if (!gtk_tree_model_get_iter_first(model, &iter))
379 int description_base_length = strlen(current_description_base);
382 gint description_counter = 0;
383 while (i < ui->infos->splitnumber)
385 gchar *description = NULL;
386 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
387 COL_DESCRIPTION, &description,
390 int length = strlen(description);
391 if (length >= description_base_length)
393 if (strncmp(description, current_description_base, description_base_length) == 0)
395 GString *new_description = g_string_new(
"");
396 g_string_append_printf(new_description,
"%s_part%d", current_description_base,
398 gchar *new_desc = g_string_free(new_description, FALSE);
400 gtk_list_store_set(GTK_LIST_STORE(model),
402 COL_DESCRIPTION, new_desc,
406 description_counter++;
412 gtk_tree_model_iter_next(model, &iter);
423 g_array_remove_index(ui->splitpoints, index);
425 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
426 GtkTreePath *path = gtk_tree_path_new_from_indices (index ,-1);
429 gtk_tree_model_get_iter(model, &iter, path);
432 if (((index == ui->status->preview_start_splitpoint) && stop_preview) ||
433 ((index == get_quick_preview_end_splitpoint_safe(ui)) &&
434 (get_quick_preview_end_splitpoint_safe(ui) == (ui->infos->splitnumber-1)) && stop_preview))
440 if (index < ui->status->preview_start_splitpoint)
442 ui->status->preview_start_splitpoint--;
443 set_quick_preview_end_splitpoint_safe(ui->status->preview_start_splitpoint + 1, ui);
446 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
447 gtk_tree_path_free(path);
449 ui->infos->splitnumber--;
453 gtk_widget_set_sensitive(ui->gui->remove_row_button, FALSE);
456 if (ui->infos->splitnumber == 0)
458 gtk_widget_set_sensitive(ui->gui->remove_all_button, FALSE);
463 order_all_splitpoints_from_table(ui->status->current_description, model, ui);
466 recompute_length_column(ui);
468 update_add_button(ui);
470 refresh_drawing_area(ui->gui, ui->infos);
472 export_cue_file_in_configuration_directory(ui);
482 gint reorder_names, gchar *old_description)
484 gchar *current_description_base = g_strdup(ui->status->current_description);
486 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
488 if (check_if_splitpoint_does_not_exists(my_split_point.mins,
489 my_split_point.secs, my_split_point.hundr_secs,-1, ui))
493 update_current_description(current_description_base, -1, ui);
496 if (gtk_tree_model_get_iter_first(model, &iter))
498 while (k < ui->infos->splitnumber)
502 gint tree_hundr_secs;
503 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
504 COL_MINUTES, &tree_minutes,
505 COL_SECONDS, &tree_seconds,
506 COL_HUNDR_SECS, &tree_hundr_secs,
509 if (my_split_point.mins < tree_minutes)
513 else if (my_split_point.mins == tree_minutes)
515 if (my_split_point.secs < tree_seconds)
519 else if (my_split_point.secs == tree_seconds)
521 if (my_split_point.hundr_secs < tree_hundr_secs)
528 gtk_tree_model_iter_next(model, &iter);
532 gtk_list_store_insert(GTK_LIST_STORE(model), &iter,k--);
533 g_array_insert_val(ui->splitpoints, k+1, my_split_point);
537 gtk_list_store_append(GTK_LIST_STORE(model), &iter);
538 g_array_append_val(ui->splitpoints, my_split_point);
541 ui->infos->splitnumber++;
544 if ((ui->status->first_splitpoint_selected == old_index) &&
547 GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
548 gtk_tree_view_set_cursor(ui->gui->tree_view, path, NULL, FALSE);
549 gtk_tree_path_free(path);
552 if (ui->status->quick_preview)
556 if (old_index == ui->status->preview_start_splitpoint)
558 if (ui->infos->current_time <
get_splitpoint_time(ui->status->preview_start_splitpoint, ui))
571 if ((old_index < ui->status->preview_start_splitpoint))
573 if ((k+1) >= ui->status->preview_start_splitpoint)
575 ui->status->preview_start_splitpoint--;
576 set_quick_preview_end_splitpoint_safe(ui->status->preview_start_splitpoint + 1, ui);
582 if ((old_index > ui->status->preview_start_splitpoint))
584 if ((k+1) <= ui->status->preview_start_splitpoint)
586 ui->status->preview_start_splitpoint++;
587 set_quick_preview_end_splitpoint_safe(ui->status->preview_start_splitpoint + 1, ui);
593 if (old_index == ui->status->preview_start_splitpoint)
595 if ((k+1) > ui->status->preview_start_splitpoint)
597 ui->status->preview_start_splitpoint += (k+1) - ui->status->preview_start_splitpoint;
598 set_quick_preview_end_splitpoint_safe(ui->status->preview_start_splitpoint + 1, ui);
603 if ((k+1) < ui->status->preview_start_splitpoint)
605 ui->status->preview_start_splitpoint -= ui->status->preview_start_splitpoint - (k + 1);
606 set_quick_preview_end_splitpoint_safe(ui->status->preview_start_splitpoint + 1, ui);
613 if (ui->status->preview_start_splitpoint == (ui->infos->splitnumber-1))
622 if ((k+1) <= ui->status->preview_start_splitpoint)
624 ui->status->preview_start_splitpoint++;
625 set_quick_preview_end_splitpoint_safe(ui->status->preview_start_splitpoint + 1, ui);
631 gtk_list_store_set(GTK_LIST_STORE(model),
633 COL_CHECK, my_split_point.checked,
634 COL_DESCRIPTION, ui->status->current_description,
635 COL_MINUTES, my_split_point.mins,
636 COL_SECONDS, my_split_point.secs,
637 COL_HUNDR_SECS, my_split_point.hundr_secs,
640 gtk_widget_set_sensitive(ui->gui->remove_all_button, TRUE);
642 recompute_length_column(ui);
654 order_all_splitpoints_from_table(old_description, model, ui);
658 order_all_splitpoints_from_table(current_description_base, model, ui);
662 if (old_description) { g_free(old_description); }
663 if (current_description_base) { g_free(current_description_base); }
665 if (gtk_toggle_button_get_active(ui->gui->names_from_filename))
671 g_snprintf(ui->status->current_description, 255,
"%s", _(
"description here"));
674 update_add_button(ui);
675 refresh_drawing_area(ui->gui, ui->infos);
678 export_cue_file_in_configuration_directory(ui);
692 int splitpoint_does_not_exists =
693 check_if_splitpoint_does_not_exists(new_point.mins, new_point.secs, new_point.hundr_secs,-1, ui);
697 if (splitpoint_does_not_exists ||
698 (old_point.checked != new_point.checked))
700 ui->status->lock_cue_export = SPLT_TRUE;
704 gchar *old_description = g_strdup(ui->status->current_description);
707 g_snprintf(ui->status->current_description, 255,
"%s", description);
711 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
712 GtkTreePath *path = gtk_tree_path_new_from_indices(index ,-1);
714 gtk_tree_model_get_iter(model, &iter, path);
716 gint year = 0, track = 0;
717 gchar *title = NULL, *artist = NULL, *album = NULL, *genre = NULL, *comment = NULL;
718 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
723 COL_COMMENT, &comment,
729 add_splitpoint(new_point, index, ui, TRUE, old_description);
732 gtk_tree_model_get_iter(model, &iter, path);
733 gtk_tree_path_free(path);
735 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_TITLE, title, -1);
736 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_ARTIST, artist, -1);
737 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_ALBUM, album, -1);
738 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_GENRE, genre, -1);
739 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_COMMENT, comment, -1);
740 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_YEAR, year, -1);
741 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_TRACK, track, -1);
742 free(title); free(artist); free(album); free(genre); free(comment);
744 ui->status->lock_cue_export = SPLT_FALSE;
746 export_cue_file_in_configuration_directory(ui);
752 if ((new_point.mins == old_point.mins) &&
753 (new_point.secs == old_point.secs) &&
754 (new_point.hundr_secs == old_point.hundr_secs))
773 new_point.checked = old_point.checked;
786 old_point.checked ^= 1;
790void clear_current_description(
ui_state *ui)
792 update_current_description(_(
"description here"), -1, ui);
795void copy_filename_to_current_description(
const gchar *fname,
ui_state *ui)
797 if (strcmp(fname,
"") == 0)
799 clear_current_description(ui);
802 gchar *temp = g_strdup(g_path_get_basename(fname));
803 gchar *tmp = strrchr(temp,
'.');
804 if (tmp != NULL) { *tmp =
'\0'; }
806 g_snprintf(ui->status->current_description, 255,
"%s", temp);
811static void cell_edited_event(GtkCellRendererText *cell, gchar *path_string, gchar *new_text,
ui_state *ui)
813 GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
814 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
816 gint col = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell),
"col"));
819 gtk_tree_model_get_iter(model, &iter, path);
820 gint i = gtk_tree_path_get_indices (path)[0];
824 new_point.checked = old_point.checked;
828 case COL_DESCRIPTION:
829 update_current_description(new_text, i, ui);
832 gtk_list_store_set(GTK_LIST_STORE(model), &iter,
833 col, ui->status->current_description,
836 if (gtk_toggle_button_get_active(ui->gui->names_from_filename))
842 g_snprintf(ui->status->current_description, 255,
"%s", _(
"description here"));
847 new_point.mins = old_point.mins;
848 new_point.secs = atoi(new_text);
849 new_point.hundr_secs = old_point.hundr_secs;
851 if (new_point.secs < 0)
855 if (new_point.secs > 59)
864 new_point.mins = atoi(new_text);
865 new_point.secs = old_point.secs;
866 new_point.hundr_secs = old_point.hundr_secs;
868 if (new_point.mins < 0)
872 if (new_point.mins > INT_MAX/6000)
874 new_point.mins = INT_MAX/6000;
881 new_point.mins = old_point.mins;
882 new_point.secs = old_point.secs;
883 new_point.hundr_secs = atoi(new_text);
885 if (new_point.hundr_secs < 0)
887 new_point.hundr_secs = 0;
889 if (new_point.hundr_secs > 99)
891 new_point.hundr_secs = 99;
899 gint value = (gint) atoi(new_text);
900 if (value < 0) { value = 0; }
901 gtk_list_store_set(GTK_LIST_STORE(model), &iter, col, value, -1);
904 gtk_list_store_set(GTK_LIST_STORE(model), &iter, col, new_text, -1);
908 gtk_tree_path_free(path);
910 export_cue_file_in_configuration_directory(ui);
913void add_splitpoint_from_player(GtkWidget *widget,
ui_state *ui)
915 if (!ui->status->timer_active)
921 my_split_point.mins = ui->infos->player_minutes;
922 my_split_point.secs = ui->infos->player_seconds;
923 my_split_point.hundr_secs = ui->infos->player_hundr_secs;
924 my_split_point.checked = TRUE;
926 add_splitpoint(my_split_point, -1, ui, TRUE, NULL);
935 my_split_point.mins = status->spin_mins;
936 my_split_point.secs = status->spin_secs;
937 my_split_point.hundr_secs = status->spin_hundr_secs;
938 my_split_point.checked = checked;
940 add_splitpoint(my_split_point, -1, ui, FALSE, NULL);
943static void add_row_clicked(GtkWidget *button,
ui_state *ui)
948 my_split_point.mins = status->spin_mins;
949 my_split_point.secs = status->spin_secs;
950 my_split_point.hundr_secs = status->spin_hundr_secs;
951 my_split_point.checked = TRUE;
953 add_splitpoint(my_split_point, -1, ui, TRUE, NULL);
956static gboolean detect_silence_and_set_splitpoints_end(
ui_with_err *ui_err)
958 gint err = ui_err->err;
961 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_PRETEND_TO_SPLIT, SPLT_FALSE);
962 mp3splt_set_split_filename_function(ui->mp3splt_state, lmanager_put_split_filename, ui);
971 gtk_widget_set_sensitive(ui->gui->cancel_button, FALSE);
972 gtk_widget_set_sensitive(ui->gui->scan_silence_button, TRUE);
973 gtk_widget_set_sensitive(ui->gui->scan_silence_button_player, TRUE);
974 gtk_widget_set_sensitive(ui->gui->scan_trim_silence_button, TRUE);
975 gtk_widget_set_sensitive(ui->gui->scan_trim_silence_button_player, TRUE);
977 set_is_splitting_safe(FALSE, ui);
979 set_process_in_progress_and_wait_safe(FALSE, ui);
983 export_cue_file_in_configuration_directory(ui);
990static gpointer detect_silence_and_set_splitpoints(
ui_for_split *ui_fs)
994 set_process_in_progress_and_wait_safe(TRUE, ui);
996 set_is_splitting_safe(TRUE, ui);
998 mp3splt_set_float_option(ui->mp3splt_state, SPLT_OPT_PARAM_THRESHOLD, ui_fs->single_silence_threshold);
999 mp3splt_set_float_option(ui->mp3splt_state, SPLT_OPT_PARAM_OFFSET, ui_fs->single_silence_offset);
1000 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_PARAM_NUMBER_TRACKS, ui_fs->single_silence_number);
1001 mp3splt_set_float_option(ui->mp3splt_state, SPLT_OPT_PARAM_MIN_LENGTH,
1002 ui_fs->single_silence_minimum_length);
1003 mp3splt_set_float_option(ui->mp3splt_state, SPLT_OPT_PARAM_MIN_TRACK_LENGTH,
1004 ui_fs->single_silence_minimum_track_length);
1005 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_PARAM_REMOVE_SILENCE,
1006 ui_fs->single_silence_remove);
1009 if (ui_fs->is_checked_output_radio_box == 0)
1011 err = mp3splt_set_oformat(ui->mp3splt_state, ui_fs->output_format);
1013 print_status_bar_confirmation_in_idle(err, ui);
1015 err = mp3splt_erase_all_splitpoints(ui->mp3splt_state);
1016 print_status_bar_confirmation_in_idle(err, ui);
1018 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_PRETEND_TO_SPLIT, SPLT_TRUE);
1019 mp3splt_set_split_filename_function(ui->mp3splt_state, NULL, ui);
1020 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_TAGS, SPLT_TAGS_ORIGINAL_FILE);
1023 int old_split_mode = mp3splt_get_int_option(ui->mp3splt_state, SPLT_OPT_SPLIT_MODE, &err);
1024 int old_tags_option = mp3splt_get_int_option(ui->mp3splt_state, SPLT_OPT_TAGS, &err);
1026 if (ui_fs->should_trim)
1028 err = mp3splt_set_trim_silence_points(ui->mp3splt_state);
1032 mp3splt_set_silence_points(ui->mp3splt_state, &err);
1034 print_status_bar_confirmation_in_idle(err, ui);
1036 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_TAGS, old_tags_option);
1037 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_SPLIT_MODE, old_split_mode);
1039 free_ui_for_split(ui_fs);
1045 add_idle(G_PRIORITY_HIGH_IDLE,
1046 (GSourceFunc)detect_silence_and_set_splitpoints_end, ui_err, NULL);
1051static void detect_silence_and_set_splitpoints_action(
ui_state *ui, gboolean should_trim)
1053 gtk_widget_set_sensitive(ui->gui->scan_silence_button, FALSE);
1054 gtk_widget_set_sensitive(ui->gui->scan_silence_button_player, FALSE);
1055 gtk_widget_set_sensitive(ui->gui->scan_trim_silence_button, FALSE);
1056 gtk_widget_set_sensitive(ui->gui->scan_trim_silence_button_player, FALSE);
1057 gtk_widget_set_sensitive(ui->gui->cancel_button, TRUE);
1060 ui_fs->should_trim = should_trim;
1062 create_thread_and_unref((GThreadFunc)detect_silence_and_set_splitpoints,
1063 (gpointer) ui_fs, ui,
"detect_silence");
1067static void detect_silence_and_add_splitpoints_start_thread(
ui_state *ui)
1069 detect_silence_and_set_splitpoints_action(ui, FALSE);
1072static void detect_silence_and_add_trim_splitpoints_start_thread(
ui_state *ui)
1074 detect_silence_and_set_splitpoints_action(ui, TRUE);
1078static void update_silence_parameters(GtkWidget *widget,
ui_state *ui)
1083 infos->silence_threshold_value =
1084 gtk_spin_button_get_value(GTK_SPIN_BUTTON(gui->spinner_silence_threshold));
1085 if (gui->spinner_silence_offset != NULL)
1087 infos->silence_offset_value =
1088 gtk_spin_button_get_value(GTK_SPIN_BUTTON(gui->spinner_silence_offset));
1090 if (gui->spinner_silence_number_tracks != NULL)
1092 infos->silence_number_of_tracks =
1093 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(gui->spinner_silence_number_tracks));
1095 if (gui->spinner_silence_minimum != NULL)
1097 infos->silence_minimum_length =
1098 gtk_spin_button_get_value(GTK_SPIN_BUTTON(gui->spinner_silence_minimum));
1100 if (gui->spinner_silence_minimum_track != NULL)
1102 infos->silence_minimum_track_length =
1103 gtk_spin_button_get_value(GTK_SPIN_BUTTON(gui->spinner_silence_minimum_track));
1105 if (gui->silence_remove_silence != NULL)
1107 infos->silence_remove_silence_between_tracks =
1108 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gui->silence_remove_silence));
1113static void silence_remove_silence_checked(GtkToggleButton *button,
ui_state *ui)
1115 update_silence_parameters(GTK_WIDGET(button), ui);
1118void create_trim_silence_window(GtkWidget *button,
ui_state *ui)
1120 GtkWidget *silence_detection_window =
1121 gtk_dialog_new_with_buttons(_(
"Set trim splitpoints using silence detection"),
1122 GTK_WINDOW(ui->gui->window),
1123 GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
1127 GTK_RESPONSE_CANCEL,
1130 gtk_widget_set_size_request(silence_detection_window, 300, 90);
1132 GtkWidget *general_inside_vbox = wh_vbox_new();
1134 GtkWidget *horiz_fake = wh_hbox_new();
1135 gtk_box_pack_start(GTK_BOX(general_inside_vbox), horiz_fake, FALSE, FALSE, 10);
1138 GtkWidget *param_vbox = wh_vbox_new();
1139 gtk_box_pack_start(GTK_BOX(horiz_fake), param_vbox, FALSE, FALSE, 25);
1142 horiz_fake = wh_hbox_new();
1143 gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
1146 GtkWidget *label = gtk_label_new(_(
"Threshold level (dB):"));
1147 gtk_box_pack_start(GTK_BOX(horiz_fake), label, FALSE, FALSE, 0);
1150 GtkAdjustment *adj = (GtkAdjustment *) gtk_adjustment_new(0.0, -96.0, 0.0, 0.5, 10.0, 0.0);
1151 GtkWidget *spinner_silence_threshold = gtk_spin_button_new(adj, 0.5, 2);
1152 ui->gui->spinner_silence_threshold = spinner_silence_threshold;
1153 gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_silence_threshold, FALSE, FALSE, 6);
1154 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_silence_threshold), ui->infos->silence_threshold_value);
1155 g_signal_connect(G_OBJECT(spinner_silence_threshold),
"value_changed",
1156 G_CALLBACK(update_silence_parameters), ui);
1158 gtk_widget_show_all(general_inside_vbox);
1159 gtk_container_add(GTK_CONTAINER(
1160 gtk_dialog_get_content_area(GTK_DIALOG(silence_detection_window))), general_inside_vbox);
1162 gint result = gtk_dialog_run(GTK_DIALOG(silence_detection_window));
1164 gtk_widget_destroy(silence_detection_window);
1166 if (result != GTK_RESPONSE_YES) {
return; }
1168 detect_silence_and_add_trim_splitpoints_start_thread(ui);
1177 GtkWidget *silence_detection_window =
1178 gtk_dialog_new_with_buttons(_(
"Set splitpoints from silence detection"),
1179 GTK_WINDOW(gui->window),
1180 GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
1184 GTK_RESPONSE_CANCEL,
1187 GtkWidget *general_inside_vbox = wh_vbox_new();
1188 GtkWidget *horiz_fake = wh_hbox_new();
1189 gtk_box_pack_start(GTK_BOX(general_inside_vbox), horiz_fake, FALSE, FALSE, 10);
1192 GtkWidget *param_vbox = wh_vbox_new();
1193 gtk_box_pack_start(GTK_BOX(horiz_fake), param_vbox, FALSE, FALSE, 25);
1196 horiz_fake = wh_hbox_new();
1197 gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
1200 GtkWidget *label = gtk_label_new(_(
"Threshold level (dB):"));
1201 gtk_box_pack_start(GTK_BOX(horiz_fake), label, FALSE, FALSE, 0);
1204 GtkAdjustment *adj = (GtkAdjustment *) gtk_adjustment_new(0.0, -96.0, 0.0, 0.5, 10.0, 0.0);
1205 GtkWidget *spinner_silence_threshold = gtk_spin_button_new(adj, 0.5, 2);
1206 gui->spinner_silence_threshold = spinner_silence_threshold;
1207 gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_silence_threshold, FALSE, FALSE, 6);
1210 horiz_fake = wh_hbox_new();
1211 gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
1214 label = gtk_label_new(_(
"Cutpoint offset (0 is the begin of silence,"
1215 "and 1 the end):"));
1216 gtk_box_pack_start(GTK_BOX(horiz_fake), label, FALSE, FALSE, 0);
1219 adj = (GtkAdjustment *) gtk_adjustment_new(0.0, -2, 2, 0.05, 10.0, 0.0);
1220 GtkWidget *spinner_silence_offset = gtk_spin_button_new(adj, 0.05, 2);
1221 gui->spinner_silence_offset = spinner_silence_offset;
1222 gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_silence_offset, FALSE, FALSE, 6);
1225 horiz_fake = wh_hbox_new();
1226 gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
1228 label = gtk_label_new(_(
"Number of tracks (0 means all tracks):"));
1229 gtk_box_pack_start(GTK_BOX(horiz_fake), label, FALSE, FALSE, 0);
1231 adj = (GtkAdjustment *)gtk_adjustment_new(0.0, 0, 2000, 1, 10.0, 0.0);
1232 GtkWidget *spinner_silence_number_tracks = gtk_spin_button_new(adj, 1, 0);
1233 gui->spinner_silence_number_tracks = spinner_silence_number_tracks;
1234 gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_silence_number_tracks, FALSE, FALSE, 6);
1237 horiz_fake = wh_hbox_new();
1238 gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
1240 label = gtk_label_new(_(
"Minimum silence length (seconds):"));
1241 gtk_box_pack_start(GTK_BOX(horiz_fake), label, FALSE, FALSE, 0);
1243 adj = (GtkAdjustment *)gtk_adjustment_new(0.0, 0, 2000, 0.5, 10.0, 0.0);
1244 GtkWidget *spinner_silence_minimum = gtk_spin_button_new(adj, 1, 2);
1245 gui->spinner_silence_minimum = spinner_silence_minimum;
1246 gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_silence_minimum, FALSE, FALSE, 6);
1249 horiz_fake = wh_hbox_new();
1250 gtk_box_pack_start(GTK_BOX(param_vbox), horiz_fake, FALSE, FALSE, 0);
1252 label = gtk_label_new(_(
"Minimum track length (seconds):"));
1253 gtk_box_pack_start(GTK_BOX(horiz_fake), label, FALSE, FALSE, 0);
1255 adj = (GtkAdjustment *)gtk_adjustment_new(0.0, 0, 2000, 0.5, 10.0, 0.0);
1256 GtkWidget *spinner_silence_minimum_track = gtk_spin_button_new(adj, 1, 2);
1257 gui->spinner_silence_minimum_track = spinner_silence_minimum_track;
1258 gtk_box_pack_start(GTK_BOX(horiz_fake), spinner_silence_minimum_track, FALSE, FALSE, 6);
1262 GtkWidget *silence_remove_silence = gtk_check_button_new_with_mnemonic(_(
"_Remove silence between tracks"));
1263 gui->silence_remove_silence = silence_remove_silence;
1264 gtk_box_pack_start(GTK_BOX(param_vbox), silence_remove_silence, FALSE, FALSE, 0);
1267 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_silence_threshold),
1268 infos->silence_threshold_value);
1269 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_silence_offset),
1270 infos->silence_offset_value);
1271 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_silence_number_tracks),
1272 infos->silence_number_of_tracks);
1273 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_silence_minimum),
1274 infos->silence_minimum_length);
1275 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner_silence_minimum_track),
1276 infos->silence_minimum_track_length);
1277 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(silence_remove_silence),
1278 infos->silence_remove_silence_between_tracks);
1281 g_signal_connect(G_OBJECT(spinner_silence_threshold),
"value_changed",
1282 G_CALLBACK(update_silence_parameters), ui);
1283 g_signal_connect(G_OBJECT(spinner_silence_offset),
"value_changed",
1284 G_CALLBACK(update_silence_parameters), ui);
1285 g_signal_connect(G_OBJECT(spinner_silence_number_tracks),
"value_changed",
1286 G_CALLBACK(update_silence_parameters), ui);
1287 g_signal_connect(G_OBJECT(spinner_silence_minimum),
"value_changed",
1288 G_CALLBACK(update_silence_parameters), ui);
1289 g_signal_connect(G_OBJECT(spinner_silence_minimum_track),
"value_changed",
1290 G_CALLBACK(update_silence_parameters), ui);
1291 g_signal_connect(G_OBJECT(silence_remove_silence),
"toggled",
1292 G_CALLBACK(silence_remove_silence_checked), ui);
1294 gtk_widget_show_all(general_inside_vbox);
1295 gtk_container_add(GTK_CONTAINER(
1296 gtk_dialog_get_content_area(GTK_DIALOG(silence_detection_window))),
1297 general_inside_vbox);
1299 gint result = gtk_dialog_run(GTK_DIALOG(silence_detection_window));
1301 gtk_widget_destroy(silence_detection_window);
1303 if (result != GTK_RESPONSE_YES) {
return; }
1305 detect_silence_and_add_splitpoints_start_thread(ui);
1309static void remove_row(GtkWidget *widget,
ui_state *ui)
1311 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
1312 GtkTreeSelection *selection = gtk_tree_view_get_selection(ui->gui->tree_view);
1314 GList *selected_list = gtk_tree_selection_get_selected_rows(selection, &model);
1316 while ((g_list_length(selected_list) > 0) && (ui->infos->splitnumber > 0))
1318 GList *current_element = g_list_last(selected_list);
1319 GtkTreePath *path = current_element->data;
1320 gint i = gtk_tree_path_get_indices (path)[0];
1324 selected_list = g_list_remove(selected_list, path);
1326 gtk_tree_path_free(path);
1329 g_list_foreach(selected_list, (GFunc)gtk_tree_path_free, NULL);
1330 g_list_free(selected_list);
1336 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
1338 while (ui->infos->splitnumber > 0)
1341 gtk_tree_model_get_iter_first(model, &iter);
1342 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
1343 g_array_remove_index(ui->splitpoints, (ui->infos->splitnumber-1));
1344 ui->infos->splitnumber--;
1347 gtk_widget_set_sensitive(ui->gui->remove_all_button, FALSE);
1348 gtk_widget_set_sensitive(ui->gui->remove_row_button, FALSE);
1352 update_add_button(ui);
1353 refresh_drawing_area(ui->gui, ui->infos);
1356 export_cue_file_in_configuration_directory(ui);
1360static GtkWidget *create_init_spinner(GtkWidget *bottomhbox1, gint min, gint max,
1361 gchar *label_text, gint type,
ui_state *ui)
1363 GtkWidget *spinner_box = wh_vbox_new();
1364 GtkWidget *label = gtk_label_new(label_text);
1365 gtk_box_pack_start(GTK_BOX(spinner_box), label, TRUE, FALSE, 0);
1367 GtkAdjustment *adj = (GtkAdjustment *) gtk_adjustment_new(0.0, min, max, 1.0, 10.0, 0.0);
1368 GtkWidget *spinner = gtk_spin_button_new(adj, 0, 0);
1369 gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spinner), TRUE);
1373 g_signal_connect(G_OBJECT(spinner),
"value_changed",
1378 g_signal_connect(G_OBJECT(spinner),
"value_changed",
1383 g_signal_connect(G_OBJECT(spinner),
"value_changed",
1387 gtk_box_pack_start(GTK_BOX(spinner_box), spinner, TRUE, FALSE, 0);
1388 gtk_box_pack_start(GTK_BOX(bottomhbox1), spinner_box, FALSE, FALSE, 5);
1394static GtkWidget *create_init_spinners_buttons(
ui_state *ui)
1396 GtkWidget *hbox = wh_hbox_new();
1397 gtk_container_set_border_width(GTK_CONTAINER(hbox), 0);
1400 ui->gui->spinner_minutes = create_init_spinner(hbox, 0, INT_MAX/6000, _(
"Minutes:"), 0, ui);
1402 ui->gui->spinner_seconds = create_init_spinner(hbox, 0, 59, _(
"Seconds:"), 1, ui);
1404 ui->gui->spinner_hundr_secs = create_init_spinner(hbox, 0, 99, _(
"Hundredths:"), 2, ui);
1407 GtkWidget *add_button = wh_create_cool_button(
"list-add", _(
"_Add"), FALSE);
1408 ui->gui->add_button = add_button;
1410 gtk_button_set_relief(GTK_BUTTON(add_button), GTK_RELIEF_NONE);
1411 gtk_widget_set_sensitive(add_button, TRUE);
1412 g_signal_connect(G_OBJECT(add_button),
"clicked", G_CALLBACK(add_row_clicked), ui);
1413 gtk_box_pack_start(GTK_BOX(hbox), add_button, FALSE, FALSE, 5);
1414 gtk_widget_set_tooltip_text(add_button,_(
"Add splitpoint"));
1417 GtkWidget *remove_row_button = wh_create_cool_button(
"list-remove", _(
"_Remove"), FALSE);
1418 ui->gui->remove_row_button = remove_row_button;
1420 gtk_button_set_relief(GTK_BUTTON(remove_row_button), GTK_RELIEF_NONE);
1421 gtk_widget_set_sensitive(remove_row_button, FALSE);
1422 g_signal_connect(G_OBJECT(remove_row_button),
"clicked", G_CALLBACK(remove_row), ui);
1423 gtk_box_pack_start(GTK_BOX(hbox), remove_row_button, FALSE, FALSE, 5);
1424 gtk_widget_set_tooltip_text(remove_row_button, _(
"Remove selected splitpoints"));
1427 GtkWidget *remove_all_button = wh_create_cool_button(
"edit-clear", _(
"R_emove all"), FALSE);
1428 ui->gui->remove_all_button = remove_all_button;
1430 gtk_button_set_relief(GTK_BUTTON(remove_all_button), GTK_RELIEF_NONE);
1431 gtk_widget_set_sensitive(remove_all_button, FALSE);
1432 g_signal_connect(G_OBJECT(remove_all_button),
"clicked", G_CALLBACK(
remove_all_rows), ui);
1433 gtk_box_pack_start(GTK_BOX(hbox), remove_all_button, FALSE, FALSE, 5);
1434 gtk_widget_set_tooltip_text(remove_all_button, _(
"Remove all splitpoints"));
1440static void create_init_special_buttons(
ui_state *ui)
1443 GtkWidget *scan_trim_silence_button =
1444 wh_create_cool_button(
"edit-find", _(
"_Trim splitpoints"), FALSE);
1445 ui->gui->scan_trim_silence_button = scan_trim_silence_button;
1446 gtk_widget_set_sensitive(scan_trim_silence_button, TRUE);
1447 g_signal_connect(G_OBJECT(scan_trim_silence_button),
"clicked",
1448 G_CALLBACK(create_trim_silence_window), ui);
1449 gtk_widget_set_tooltip_text(scan_trim_silence_button,
1450 _(
"Set trim splitpoints using silence detection"));
1453 GtkWidget *scan_silence_button =
1454 wh_create_cool_button(
"edit-find-replace", _(
"_Silence detection"), FALSE);
1455 ui->gui->scan_silence_button = scan_silence_button;
1456 gtk_widget_set_sensitive(scan_silence_button, TRUE);
1457 g_signal_connect(G_OBJECT(scan_silence_button),
"clicked",
1459 gtk_widget_set_tooltip_text(scan_silence_button,
1460 _(
"Set splitpoints from silence detection"));
1469 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
1471 gchar *description = NULL;
1474 if (!gtk_tree_model_get_iter_first(model, &iter))
1486 GtkTreePath *path = gtk_tree_path_new_from_indices(index ,-1);
1487 gtk_tree_model_get_iter(model, &iter, path);
1488 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
1489 COL_DESCRIPTION, &description,
1491 gtk_tree_path_free(path);
1500 if (splitpoint_index < 0 ||
1501 splitpoint_index >= ui->splitpoints->len)
1507 return point.mins * 6000 + point.secs * 100 + point.hundr_secs;
1510static gboolean split_preview_end(
ui_with_err *ui_err)
1512 set_process_in_progress_and_wait_safe(FALSE, ui_err->ui);
1514 gint err = ui_err->err;
1520 if (split_file != NULL && err > 0)
1533 gtk_progress_bar_set_fraction(ui->gui->percent_progress_bar, 1.0);
1534 gtk_progress_bar_set_text(ui->gui->percent_progress_bar, _(
" finished"));
1546 set_process_in_progress_and_wait_safe(TRUE, ui);
1548 int err = mp3splt_erase_all_splitpoints(ui->mp3splt_state);
1549 print_status_bar_confirmation_in_idle(err, ui);
1551 err = mp3splt_erase_all_tags(ui->mp3splt_state);
1552 print_status_bar_confirmation_in_idle(err, ui);
1554 splt_point *splitpoint = mp3splt_point_new(get_preview_start_position_safe(ui), NULL);
1555 mp3splt_point_set_name(splitpoint,
"preview");
1556 mp3splt_point_set_type(splitpoint, SPLT_SPLITPOINT);
1557 mp3splt_append_splitpoint(ui->mp3splt_state, splitpoint);
1559 splitpoint = mp3splt_point_new(
1561 mp3splt_point_set_type(splitpoint, SPLT_SKIPPOINT);
1562 mp3splt_append_splitpoint(ui->mp3splt_state, splitpoint);
1564 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_OUTPUT_FILENAMES, SPLT_OUTPUT_CUSTOM);
1565 mp3splt_set_int_option(ui->mp3splt_state, SPLT_OPT_SPLIT_MODE, SPLT_OPTION_NORMAL_MODE);
1570 fname_path[strlen(fname_path) - 18] =
'\0';
1571 mp3splt_set_path_of_split(ui->mp3splt_state, fname_path);
1572 if (fname_path) { g_free(fname_path); }
1574 err = mp3splt_split(ui->mp3splt_state);
1576 free_ui_for_split(ui_fs);
1582 add_idle(G_PRIORITY_HIGH_IDLE, (GSourceFunc)split_preview_end, ui_err, NULL);
1587static void split_preview_action(
ui_state *ui)
1593 create_thread_and_unref((GThreadFunc)split_preview, (gpointer) ui_fs, ui,
"split_preview");
1597static void preview_song(GtkTreeView *tree_view, GtkTreePath *path,
1598 GtkTreeViewColumn *col,
ui_state *ui)
1600 gint number = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(col),
"col"));
1601 if (number != COL_PREVIEW && number != COL_SPLIT_PREVIEW)
1606 if (!ui->status->timer_active)
1613 gint preview_row = gtk_tree_path_get_indices(path)[0];
1614 ui->status->preview_row = preview_row;
1615 if (number == COL_PREVIEW)
1619 else if (number == COL_SPLIT_PREVIEW)
1622 set_quick_preview_end_splitpoint_safe(preview_row + 1, ui);
1624 if (ui->status->preview_row + 1 == ui->infos->splitnumber)
1630 split_preview_action(ui);
1635static void toggled_splitpoint_event(GtkCellRendererToggle *cell,
1638 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
1639 GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
1640 gboolean checked = FALSE;
1643 gtk_tree_model_get_iter(model, &iter, path);
1644 gtk_tree_model_get(model, &iter, COL_CHECK, &checked, -1);
1650 gint index = gtk_tree_path_get_indices (path)[0];
1655 old_point = g_array_index(ui->splitpoints,
Split_point, index);
1656 new_point.mins = old_point.mins;
1657 new_point.secs = old_point.secs;
1658 new_point.hundr_secs = old_point.hundr_secs;
1659 new_point.checked = checked;
1663 gtk_tree_path_free(path);
1666static void clone_tag(
ui_state *ui, gint column)
1670 GtkTreeModel *model = gtk_tree_view_get_model(gui->tree_view);
1671 GtkTreeSelection *selection = gtk_tree_view_get_selection(gui->tree_view);
1673 GList *selected_list =
1674 gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), &model);
1676 if (g_list_length(selected_list) <= 0)
1681 GList *current_element = g_list_first(selected_list);
1682 GtkTreePath *path = current_element->data;
1684 gtk_tree_model_get_iter(model, &iter, path);
1686 gchar *value = NULL;
1688 if (column == COL_YEAR || column == COL_TRACK)
1690 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, column, &int_value, -1);
1694 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, column, &value, -1);
1698 for (number = 0;number < ui->infos->splitnumber; number++)
1700 GtkTreePath *path2 = gtk_tree_path_new_from_indices(number ,-1);
1702 gtk_tree_model_get_iter(model, &iter2, path2);
1703 gtk_tree_path_free(path2);
1705 if (column == COL_YEAR || column == COL_TRACK)
1707 gtk_list_store_set(GTK_LIST_STORE(model), &iter2, column, int_value, -1);
1711 gtk_list_store_set(GTK_LIST_STORE(model), &iter2, column, value, -1);
1715 if (value) { g_free(value); }
1717 g_list_foreach(selected_list, (GFunc)gtk_tree_path_free, NULL);
1718 g_list_free(selected_list);
1721static void clone_all_event(GtkMenuItem *menuitem,
ui_state *ui)
1723 clone_tag(ui, COL_TITLE);
1724 clone_tag(ui, COL_ARTIST);
1725 clone_tag(ui, COL_ALBUM);
1726 clone_tag(ui, COL_GENRE);
1727 clone_tag(ui, COL_YEAR);
1728 clone_tag(ui, COL_TRACK);
1729 clone_tag(ui, COL_COMMENT);
1731 export_cue_file_in_configuration_directory(ui);
1734static void clone_title_event(GtkMenuItem *menuitem,
ui_state *ui)
1736 clone_tag(ui, COL_TITLE);
1737 export_cue_file_in_configuration_directory(ui);
1740static void clone_artist_event(GtkMenuItem *menuitem,
ui_state *ui)
1742 clone_tag(ui, COL_ARTIST);
1743 export_cue_file_in_configuration_directory(ui);
1746static void clone_album_event(GtkMenuItem *menuitem,
ui_state *ui)
1748 clone_tag(ui, COL_ALBUM);
1749 export_cue_file_in_configuration_directory(ui);
1752static void clone_genre_event(GtkMenuItem *menuitem,
ui_state *ui)
1754 clone_tag(ui, COL_GENRE);
1755 export_cue_file_in_configuration_directory(ui);
1758static void clone_year_event(GtkMenuItem *menuitem,
ui_state *ui)
1760 clone_tag(ui, COL_YEAR);
1761 export_cue_file_in_configuration_directory(ui);
1764static void clone_track_event(GtkMenuItem *menuitem,
ui_state *ui)
1766 clone_tag(ui, COL_TRACK);
1767 export_cue_file_in_configuration_directory(ui);
1770static void clone_comment_event(GtkMenuItem *menuitem,
ui_state *ui)
1772 clone_tag(ui, COL_COMMENT);
1773 export_cue_file_in_configuration_directory(ui);
1776static void auto_increment_track_event(GtkMenuItem *menuitem,
ui_state *ui)
1778 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
1781 for (number = 0;number < ui->infos->splitnumber; number++)
1783 GtkTreePath *path2 = gtk_tree_path_new_from_indices(number ,-1);
1785 gtk_tree_model_get_iter(model, &iter2, path2);
1786 gtk_tree_path_free(path2);
1787 gtk_list_store_set(GTK_LIST_STORE(model), &iter2, COL_TRACK, GINT_TO_POINTER(number + 1), -1);
1790 export_cue_file_in_configuration_directory(ui);
1793static void build_and_show_popup_menu(GtkWidget *treeview, GdkEventButton *event,
ui_state *ui)
1795 GtkWidget *menu = gtk_menu_new();
1797 GtkWidget *item = gtk_menu_item_new_with_label(_(
"Clone all tags"));
1798 g_signal_connect(item,
"activate", G_CALLBACK(clone_all_event), ui);
1799 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1801 gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
1803 item = gtk_menu_item_new_with_label(_(
"Clone title"));
1804 g_signal_connect(item,
"activate", G_CALLBACK(clone_title_event), ui);
1805 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1807 item = gtk_menu_item_new_with_label(_(
"Clone artist"));
1808 g_signal_connect(item,
"activate", G_CALLBACK(clone_artist_event), ui);
1809 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1811 item = gtk_menu_item_new_with_label(_(
"Clone album"));
1812 g_signal_connect(item,
"activate", G_CALLBACK(clone_album_event), ui);
1813 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1815 item = gtk_menu_item_new_with_label(_(
"Clone genre"));
1816 g_signal_connect(item,
"activate", G_CALLBACK(clone_genre_event), ui);
1817 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1819 item = gtk_menu_item_new_with_label(_(
"Clone year"));
1820 g_signal_connect(item,
"activate", G_CALLBACK(clone_year_event), ui);
1821 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1823 item = gtk_menu_item_new_with_label(_(
"Clone track"));
1824 g_signal_connect(item,
"activate", G_CALLBACK(clone_track_event), ui);
1825 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1827 item = gtk_menu_item_new_with_label(_(
"Clone comment"));
1828 g_signal_connect(item,
"activate", G_CALLBACK(clone_comment_event), ui);
1829 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1831 gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
1833 item = gtk_menu_item_new_with_label(_(
"Auto-increment track"));
1834 g_signal_connect(item,
"activate", G_CALLBACK(auto_increment_track_event), ui);
1835 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
1837 gtk_widget_show_all(menu);
1839 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
1840 (event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent*)event));
1843static gboolean show_popup(GtkWidget *treeview,
ui_state *ui)
1845 build_and_show_popup_menu(treeview, NULL, ui);
1849static gboolean select_and_show_popup(GtkWidget *treeview, GdkEventButton *event,
ui_state *ui)
1851 if (event->type != GDK_BUTTON_PRESS || event->button != 3)
1856 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
1857 if (gtk_tree_selection_count_selected_rows(selection) <= 1)
1860 if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview),
1861 (gint) event->x, (gint) event->y, &path, NULL, NULL, NULL))
1863 gtk_tree_selection_unselect_all(selection);
1864 gtk_tree_selection_select_path(selection, path);
1865 gtk_tree_path_free(path);
1873 build_and_show_popup_menu(treeview, event, ui);
1879static void create_columns(
ui_state *ui)
1883 GtkTreeView *tree_view = gui->tree_view;
1885 GtkCellRendererText *renderer;
1886 GtkCellRendererPixbuf *renderer_pix;
1887 GtkCellRendererToggle *renderer_toggle;
1889 GtkTreeViewColumn *column_number;
1890 GtkTreeViewColumn *column_check = NULL;
1891 GtkTreeViewColumn *column_description;
1892 GtkTreeViewColumn *column_hundr_secs;
1893 GtkTreeViewColumn *column_minutes;
1894 GtkTreeViewColumn *column_seconds;
1895 GtkTreeViewColumn *column_preview;
1896 GtkTreeViewColumn *column_split_preview;
1899 renderer_toggle = GTK_CELL_RENDERER_TOGGLE(gtk_cell_renderer_toggle_new());
1900 g_signal_connect(renderer_toggle,
"toggled", G_CALLBACK(toggled_splitpoint_event), ui);
1901 g_object_set_data(G_OBJECT(renderer_toggle),
"col", GINT_TO_POINTER(COL_CHECK));
1902 column_check = gtk_tree_view_column_new_with_attributes
1903 (_(
"Keep"), GTK_CELL_RENDERER(renderer_toggle),
"active", COL_CHECK, NULL);
1906 renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
1907 g_signal_connect(renderer,
"edited", G_CALLBACK(cell_edited_event), ui);
1908 g_object_set(renderer,
"editable", TRUE, NULL);
1909 g_object_set_data(G_OBJECT(renderer),
"col", GINT_TO_POINTER(COL_DESCRIPTION));
1910 column_description = gtk_tree_view_column_new_with_attributes
1911 (_(
"Filename"), GTK_CELL_RENDERER(renderer),
"text", COL_DESCRIPTION, NULL);
1914 renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
1915 g_signal_connect(renderer,
"edited", G_CALLBACK(cell_edited_event), ui);
1916 g_object_set(renderer,
"editable", TRUE, NULL);
1917 g_object_set_data(G_OBJECT(renderer),
"col", GINT_TO_POINTER(COL_SECONDS));
1918 column_seconds = gtk_tree_view_column_new_with_attributes
1919 (_(
"Secs"), GTK_CELL_RENDERER(renderer),
"text", COL_SECONDS, NULL);
1922 renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
1923 g_signal_connect(renderer,
"edited", G_CALLBACK(cell_edited_event), ui);
1924 g_object_set(renderer,
"editable", TRUE, NULL);
1925 g_object_set_data(G_OBJECT(renderer),
"col", GINT_TO_POINTER(COL_MINUTES));
1926 column_minutes = gtk_tree_view_column_new_with_attributes
1927 (_(
"Mins"), GTK_CELL_RENDERER(renderer),
"text", COL_MINUTES, NULL);
1930 renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
1931 g_signal_connect(renderer,
"edited", G_CALLBACK(cell_edited_event), ui);
1932 g_object_set(renderer,
"editable", TRUE, NULL);
1933 g_object_set_data(G_OBJECT(renderer),
"col", GINT_TO_POINTER(COL_HUNDR_SECS));
1934 column_hundr_secs = gtk_tree_view_column_new_with_attributes
1935 (_(
"Hundr"), GTK_CELL_RENDERER(renderer),
"text", COL_HUNDR_SECS, NULL);
1939 renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
1940 g_object_set(G_OBJECT (renderer),
"xalign", 1.0, NULL);
1941 g_object_set_data(G_OBJECT(renderer),
"col", GINT_TO_POINTER(COL_NUMBER));
1942 column_number = gtk_tree_view_column_new_with_attributes
1943 (_(
"Length"), GTK_CELL_RENDERER(renderer),
"text", COL_NUMBER, NULL);
1946 renderer_pix = GTK_CELL_RENDERER_PIXBUF(gtk_cell_renderer_pixbuf_new());
1947 g_object_set(renderer_pix,
"icon-name",
"media-playback-start",
1948 "stock-size", GTK_ICON_SIZE_MENU, NULL);
1949 column_preview = gtk_tree_view_column_new_with_attributes
1950 (_(
"LiveP"), GTK_CELL_RENDERER(renderer_pix), NULL);
1951 g_object_set_data(G_OBJECT(column_preview),
"col", GINT_TO_POINTER(COL_PREVIEW));
1954 renderer_pix = GTK_CELL_RENDERER_PIXBUF(gtk_cell_renderer_pixbuf_new());
1955 g_object_set(renderer_pix,
"icon-name",
"media-playback-start",
1956 "stock-size", GTK_ICON_SIZE_MENU, NULL);
1957 column_split_preview = gtk_tree_view_column_new_with_attributes
1958 (_(
"SplitP"), GTK_CELL_RENDERER(renderer_pix), NULL);
1959 g_object_set_data(G_OBJECT(column_split_preview),
"col", GINT_TO_POINTER(COL_SPLIT_PREVIEW));
1961 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_check, COL_CHECK);
1962 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_description, COL_DESCRIPTION);
1963 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_minutes, COL_MINUTES);
1964 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_seconds, COL_SECONDS);
1965 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_hundr_secs, COL_HUNDR_SECS);
1966 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_number, COL_NUMBER);
1967 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_preview, COL_PREVIEW);
1968 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), column_split_preview, COL_SPLIT_PREVIEW);
1970 gtk_tree_view_column_set_alignment(column_check, 0.5);
1971 gtk_tree_view_column_set_alignment(column_description, 0.5);
1972 gtk_tree_view_column_set_alignment(column_minutes, 0.5);
1973 gtk_tree_view_column_set_alignment(column_seconds, 0.5);
1974 gtk_tree_view_column_set_alignment(column_hundr_secs, 0.5);
1975 gtk_tree_view_column_set_alignment(column_number, 0.5);
1976 gtk_tree_view_column_set_alignment(column_preview, 0.5);
1977 gtk_tree_view_column_set_alignment(column_split_preview, 0.5);
1979 gtk_tree_view_column_set_sizing(column_check, GTK_TREE_VIEW_COLUMN_FIXED);
1980 gtk_tree_view_column_set_fixed_width(column_check, 70);
1982 gtk_tree_view_column_set_resizable(column_description, TRUE);
1984 gtk_tree_view_column_set_reorderable(column_check, TRUE);
1985 gtk_tree_view_column_set_reorderable(column_description, TRUE);
1986 gtk_tree_view_column_set_reorderable(column_minutes, TRUE);
1987 gtk_tree_view_column_set_reorderable(column_seconds, TRUE);
1988 gtk_tree_view_column_set_reorderable(column_hundr_secs, TRUE);
1989 gtk_tree_view_column_set_reorderable(column_number, TRUE);
1990 gtk_tree_view_column_set_reorderable(column_preview, TRUE);
1991 gtk_tree_view_column_set_reorderable(column_split_preview, TRUE);
1993 gtk_tree_view_column_set_expand(column_description, TRUE);
1996 for (i = COL_TITLE;i < NUM_COLUMNS;i++)
1998 renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
1999 g_signal_connect(renderer,
"edited", G_CALLBACK(cell_edited_event), ui);
2000 g_object_set(renderer,
"editable", TRUE, NULL);
2001 g_object_set_data(G_OBJECT(renderer),
"col", GINT_TO_POINTER(i));
2003 gchar column_name[255] = {
'\0' };
2004 gint minimum_width = 100;
2008 g_snprintf(column_name, 255, _(
"Title"));
2011 g_snprintf(column_name, 255, _(
"Artist"));
2014 g_snprintf(column_name, 255, _(
"Album"));
2017 g_snprintf(column_name, 255, _(
"Genre"));
2021 g_snprintf(column_name, 255, _(
"Comment"));
2024 g_snprintf(column_name, 255, _(
"Year"));
2028 g_snprintf(column_name, 255, _(
"Track"));
2033 GtkTreeViewColumn *tag_column = gtk_tree_view_column_new_with_attributes
2034 (column_name, GTK_CELL_RENDERER(renderer),
"text", i, NULL);
2036 gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view), tag_column, i);
2037 gtk_tree_view_column_set_alignment(tag_column, 0.5);
2038 gtk_tree_view_column_set_resizable(tag_column, TRUE);
2039 gtk_tree_view_column_set_reorderable(tag_column, TRUE);
2040 gtk_tree_view_column_set_min_width(tag_column, minimum_width);
2045static void create_tree_view(
ui_state *ui)
2047 GtkTreeView *tree_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(create_model()));
2048 dnd_add_drag_data_received_to_widget(GTK_WIDGET(tree_view), DND_DATA_FILES, ui);
2050 ui->gui->tree_view = tree_view;
2052 g_signal_connect(tree_view,
"row-activated", G_CALLBACK(preview_song), ui);
2054 GtkTreeSelection *selection = gtk_tree_view_get_selection(tree_view);
2055 g_signal_connect(selection,
"changed", G_CALLBACK(row_selection_event), ui);
2067 create_tree_view(ui);
2070 GtkWidget *choose_splitpoints_vbox = wh_vbox_new();
2071 gtk_container_set_border_width(GTK_CONTAINER(choose_splitpoints_vbox), 0);
2074 GtkWidget *spinners_buttons_hbox = create_init_spinners_buttons(ui);
2075 gtk_box_pack_start(GTK_BOX(choose_splitpoints_vbox), spinners_buttons_hbox, FALSE, FALSE, 3);
2078 GtkWidget *tree_hbox = wh_hbox_new();
2079 gtk_box_pack_start(GTK_BOX(choose_splitpoints_vbox), tree_hbox, TRUE, TRUE, 0);
2082 GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
2083 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_NONE);
2084 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
2085 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2086 gtk_box_pack_start(GTK_BOX(tree_hbox), scrolled_window, TRUE, TRUE, 0);
2088 GtkTreeSelection *selection = gtk_tree_view_get_selection(gui->tree_view);
2089 gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
2091 gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(gui->tree_view));
2093 g_signal_connect(gui->tree_view,
"popup-menu", G_CALLBACK(show_popup), ui);
2094 g_signal_connect(gui->tree_view,
"button-press-event", G_CALLBACK(select_and_show_popup), ui);
2097 create_init_special_buttons(ui);
2099 return choose_splitpoints_vbox;
2102static void garray_to_array(GArray *spltpoints, glong *hundredth,
ui_state *ui)
2105 for(i = 0; i < ui->infos->splitnumber; i++ )
2108 if (point.mins >= (INT_MAX-1)/6000)
2110 hundredth[i] = LONG_MAX;
2114 hundredth[i] = point.mins * 6000 +
2115 point.secs * 100 + point.hundr_secs;
2124 glong hundr[ui->infos->splitnumber];
2125 garray_to_array(ui->splitpoints, hundr, ui);
2127 GtkTreeModel *model = gtk_tree_view_get_model(ui->gui->tree_view);
2130 for (i = 0; i < ui->infos->splitnumber; i++)
2132 GtkTreePath *path = gtk_tree_path_new_from_indices(i ,-1);
2134 gtk_tree_model_get_iter(model, &iter, path);
2135 gtk_tree_path_free(path);
2137 gchar *description = NULL;
2138 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, COL_DESCRIPTION, &description, -1);
2142 gint splitpoint_type = SPLT_SPLITPOINT;
2144 if (point.checked == FALSE)
2146 splitpoint_type = SPLT_SKIPPOINT;
2149 splt_point *splitpoint = mp3splt_point_new(hundr[i], NULL);
2150 mp3splt_point_set_name(splitpoint, description);
2151 g_free(description);
2152 mp3splt_point_set_type(splitpoint, splitpoint_type);
2153 append_point_to_pat(splitpoint, pat);
2155 gint year = 0, track = 0;
2156 gchar *title = NULL, *artist = NULL, *album = NULL, *genre = NULL, *comment = NULL;
2158 gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
2160 COL_ARTIST, &artist,
2163 COL_COMMENT, &comment,
2168 splt_tags *tags = mp3splt_tags_new(NULL);
2172 gchar year_str[10] = {
'\0' };
2173 g_snprintf(year_str, 10,
"%d", year);
2174 mp3splt_tags_set(tags, SPLT_TAGS_YEAR, year_str, 0);
2177 if (track <= 0) { track = -2; }
2178 gchar track_str[10] = {
'\0' };
2179 g_snprintf(track_str, 10,
"%d", track);
2180 mp3splt_tags_set(tags, SPLT_TAGS_TRACK, track_str, 0);
2182 mp3splt_tags_set(tags,
2183 SPLT_TAGS_TITLE, title,
2184 SPLT_TAGS_ARTIST, artist,
2185 SPLT_TAGS_ALBUM, album,
2186 SPLT_TAGS_GENRE, genre,
2187 SPLT_TAGS_COMMENT, comment,
2189 append_tags_to_pat(tags, pat);
2191 free(title); free(artist); free(album); free(genre); free(comment);
void update_splitpoints_from_mp3splt_state(ui_state *ui)
updates the current splitpoints in ui->mp3splt_state
void print_status_bar_confirmation(gint error, ui_state *ui)
Output an error message from libmp3splt to the status bar.
void remove_status_message(gui_state *gui)
Removes status bar message.
gchar * get_input_filename(gui_state *gui)
Get the name of the input file.
void put_status_message(const gchar *text, ui_state *ui)
Output a info message to the status message bar.
void put_options_from_preferences(ui_for_split *ui_fs)
Update the ui->mp3splt_state structure.
void change_current_filename(const gchar *fname, ui_state *ui)
Change the name of the song that is to be cut and played.
void player_quick_preview(gint splitpoint_to_preview, ui_state *ui)
makes a preview of the song
void check_update_down_progress_bar(ui_state *ui)
updates bottom progress bar
void connect_button_event(GtkWidget *widget, ui_state *ui)
play button event
void cancel_quick_preview(gui_status *status)
cancels preview
void cancel_quick_preview_all(ui_state *ui)
full cancel of the preview
void connect_to_player_with_song(gint i, ui_state *ui)
connects to player with the song from the filename entry
gchar * get_preferences_filename()
Get the name of the preferences file.
gchar * get_filename_from_split_files(gint number, gui_state *gui)
return the n_th filename from the split files
void remove_all_split_rows(ui_state *ui)
removes all rows from the split files table
void update_minutes_from_spinner(GtkWidget *widget, ui_state *ui)
updates the minutes from the spinner
void update_seconds_from_spinner(GtkWidget *widget, ui_state *ui)
updates the seconds from the spinner
void select_splitpoint(gint index, gui_state *gui)
selects a splitpoint
void create_detect_silence_and_add_splitpoints_window(GtkWidget *button, ui_state *ui)
event for clicking the 'detect silence and add splitpoints' button
void update_splitpoint_from_time(gint index, gdouble time, ui_state *ui)
Set a splitpoint's time value.
void update_splitpoint_check(gint index, ui_state *ui)
Toggles a splitpoint's "Keep" flag.
void get_hundr_secs_mins_time(gint time_pos, gint *time_hundr, gint *time_secs, gint *time_mins)
returns secs, mins, hundr of secs from a time
void remove_all_rows(GtkWidget *widget, ui_state *ui)
removes all rows from the table
void update_hundr_secs_from_spinner(GtkWidget *widget, ui_state *ui)
updates the hundredth of seconds for the spinner
GtkWidget * create_splitpoints_frame(ui_state *ui)
creates the choose splitpoints frame
gint get_first_splitpoint_selected(gui_state *gui)
Gets the number of the first splitpoint with selected "Keep" checkbox.
void add_row(gboolean checked, ui_state *ui)
adds a row to the table
gint get_splitpoint_time(gint splitpoint_index, ui_state *ui)
returns a splitpoint from the table
void update_splitpoint(gint index, Split_point new_point, ui_state *ui)
Set all values of a split point.
gchar * get_splitpoint_name(gint index, ui_state *ui)
returns the name of the splitpoint
void remove_splitpoint(gint index, gint stop_preview, ui_state *ui)
removes a splitpoint