X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=gtk%2Fsrc%2Fsubtitlehandler.c;h=938323ea449aab8adac013378cbc8338137724b8;hb=9b9e605f16338e7f9f9f43ebf9ac5949d649a86b;hp=fd7c52c6b0f350089fe9ed3e62e548be9d53171d;hpb=c8fd41085882c99882260b7af3a6045b7f1f9ad6;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/gtk/src/subtitlehandler.c b/gtk/src/subtitlehandler.c index fd7c52c6..938323ea 100644 --- a/gtk/src/subtitlehandler.c +++ b/gtk/src/subtitlehandler.c @@ -23,6 +23,7 @@ #include "subtitlehandler.h" static void add_to_subtitle_list(signal_user_data_t *ud, GValue *settings); +static void add_to_srt_list(signal_user_data_t *ud, GValue *settings); static void free_subtitle_index_list(gpointer data) @@ -123,16 +124,77 @@ ghb_subtitle_exclusive_default(signal_user_data_t *ud, gint index) } void +ghb_add_srt(signal_user_data_t *ud, GValue *settings) +{ + // Add the current subtitle settings to the list. + GValue *subtitle_list; + gint count; + const gchar *lang; + + g_debug("ghb_add_srt ()"); + + // Add the long track description so the queue can access it + // when a different title is selected. + lang = ghb_settings_combo_option(settings, "SrtLanguage"); + ghb_settings_set_string(settings, "SubtitleTrackDescription", lang); + + ghb_settings_set_int(settings, "SubtitleSource", SRTSUB); + + subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list"); + if (subtitle_list == NULL) + { + subtitle_list = ghb_array_value_new(8); + ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list); + } + count = ghb_array_len(subtitle_list); + + // Don't allow more than 99 + // This is a had limit imposed by libhb/sync.c:GetFifoForId() + if (count >= 99) + { + ghb_value_free(settings); + return; + } + + ghb_array_append(subtitle_list, settings); + add_to_srt_list(ud, settings); + + if (count == 98) + { + GtkWidget *widget; + widget = GHB_WIDGET (ud->builder, "subtitle_add"); + gtk_widget_set_sensitive(widget, FALSE); + widget = GHB_WIDGET (ud->builder, "srt_add"); + gtk_widget_set_sensitive(widget, FALSE); + } + ghb_live_reset(ud); +} + +void ghb_add_subtitle(signal_user_data_t *ud, GValue *settings) { // Add the current subtitle settings to the list. GValue *subtitle_list; gint count; gboolean burned; + const gchar *track; + const gchar *lang; + gint tt, source; g_debug("ghb_add_subtitle ()"); - // Only allow up to 8 subtitle entries + // Add the long track description so the queue can access it + // when a different title is selected. + track = ghb_settings_combo_option(settings, "SubtitleTrack"); + ghb_settings_set_string(settings, "SubtitleTrackDescription", track); + + lang = ghb_settings_combo_string(settings, "SubtitleTrack"); + ghb_settings_set_string(settings, "SubtitleLanguage", lang); + + tt = ghb_settings_get_int(settings, "SubtitleTrack"); + source = ghb_subtitle_track_source(ud, tt); + ghb_settings_set_int(settings, "SubtitleSource", source); + subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list"); if (subtitle_list == NULL) { @@ -140,12 +202,30 @@ ghb_add_subtitle(signal_user_data_t *ud, GValue *settings) ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list); } count = ghb_array_len(subtitle_list); + + // Don't allow more than 99 + // This is a had limit imposed by libhb/sync.c:GetFifoForId() + if (count >= 99) + { + ghb_value_free(settings); + return; + } + ghb_array_append(subtitle_list, settings); add_to_subtitle_list(ud, settings); burned = ghb_settings_get_boolean(settings, "SubtitleBurned"); if (burned) ghb_subtitle_exclusive_burn(ud, count); + if (count == 98) + { + GtkWidget *widget; + widget = GHB_WIDGET (ud->builder, "subtitle_add"); + gtk_widget_set_sensitive(widget, FALSE); + widget = GHB_WIDGET (ud->builder, "srt_add"); + gtk_widget_set_sensitive(widget, FALSE); + } + ghb_live_reset(ud); } static void @@ -198,7 +278,7 @@ ghb_set_pref_subtitle(gint titleindex, signal_user_data_t *ud) // chosen Preferred Language AND the Preferred Language is NOT Any (und). // audio_lang = ghb_get_user_audio_lang(ud, titleindex, 0); - pref_lang = ghb_settings_get_string(ud->settings, "SourceAudioLang"); + pref_lang = ghb_settings_get_string(ud->settings, "PreferredLanguage"); if (audio_lang != NULL && pref_lang != NULL && (strcmp(audio_lang, pref_lang) == 0 || strcmp("und", pref_lang) == 0)) @@ -368,7 +448,7 @@ subtitle_forced_toggled_cb( GtkTreePath *tp; gint *indices; GValue *subtitle_list, *settings; - gint source, track; + gint source; g_debug("forced toggled"); tp = gtk_tree_path_new_from_string (path); @@ -391,14 +471,14 @@ subtitle_forced_toggled_cb( return; settings = ghb_array_get_nth(subtitle_list, row); - track = ghb_settings_combo_int(settings, "SubtitleTrack"); - source = ghb_subtitle_track_source(ud, track); + source = ghb_settings_get_int(settings, "SubtitleSource"); if (source != VOBSUB) return; ghb_settings_set_boolean(settings, "SubtitleForced", active); gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 1, active, -1); + ghb_live_reset(ud); } G_MODULE_EXPORT void @@ -439,12 +519,12 @@ subtitle_burned_toggled_cb( return; settings = ghb_array_get_nth(subtitle_list, row); - track = ghb_settings_combo_int(settings, "SubtitleTrack"); - source = ghb_subtitle_track_source(ud, track); + source = ghb_settings_get_int(settings, "SubtitleSource"); if (source != VOBSUB) return; + track = ghb_settings_combo_int(settings, "SubtitleTrack"); if (!active && mustBurn(ud, track)) return; @@ -454,6 +534,7 @@ subtitle_burned_toggled_cb( // Unburn the rest if (active) ghb_subtitle_exclusive_burn(ud, row); + ghb_live_reset(ud); } G_MODULE_EXPORT void @@ -470,7 +551,7 @@ subtitle_default_toggled_cb( gint row; gint *indices; GValue *subtitle_list; - gint count, track; + gint count; GValue *settings; g_debug("default toggled"); @@ -494,13 +575,37 @@ subtitle_default_toggled_cb( return; settings = ghb_array_get_nth(subtitle_list, row); - track = ghb_settings_combo_int(settings, "SubtitleTrack"); ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", active); gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, active, -1); // allow only one default ghb_subtitle_exclusive_default(ud, row); + ghb_live_reset(ud); +} + +static const char* +subtitle_source_name(gint source) +{ + const gchar * name; + + switch (source) + { + case VOBSUB: + name = "Bitmap"; + break; + case CC708SUB: + case CC608SUB: + name = "Text"; + break; + case SRTSUB: + name = "SRT"; + break; + default: + name = "Unknown"; + break; + } + return name; } static void @@ -521,10 +626,10 @@ subtitle_list_refresh_selected(signal_user_data_t *ud) selection = gtk_tree_view_get_selection (treeview); if (gtk_tree_selection_get_selected(selection, &store, &iter)) { - const gchar *track, *source; + gchar *track, *source; gboolean forced, burned, def; gchar *s_track; - gint i_track; + gint offset = 0; // Get the row number treepath = gtk_tree_model_get_path (store, &iter); @@ -538,17 +643,10 @@ subtitle_list_refresh_selected(signal_user_data_t *ud) return; settings = ghb_array_get_nth(subtitle_list, row); - track = ghb_settings_combo_option(settings, "SubtitleTrack"); - forced = ghb_settings_get_boolean(settings, "SubtitleForced"); - burned = ghb_settings_get_boolean(settings, "SubtitleBurned"); def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack"); - s_track = ghb_settings_get_string(settings, "SubtitleTrack"); - i_track = ghb_settings_get_int(settings, "SubtitleTrack"); - source = ghb_subtitle_track_source_name(ud, i_track); - gint i_source; - i_source = ghb_subtitle_track_source(ud, i_track); + i_source = ghb_settings_get_int(settings, "SubtitleSource"); if (i_source != VOBSUB) { // Force and burn only apply to VOBSUBS @@ -558,6 +656,45 @@ subtitle_list_refresh_selected(signal_user_data_t *ud) ghb_settings_set_boolean(settings, "SubtitleBurned", burned); } + if (i_source == SRTSUB) + { + const gchar *lang; + gchar *code; + + lang = ghb_settings_combo_option(settings, "SrtLanguage"); + code = ghb_settings_get_string(settings, "SrtCodeset"); + track = g_strdup_printf("%s (%s)", lang, code); + g_free(code); + + s_track = ghb_settings_get_string(settings, "SrtFile"); + if (g_file_test(s_track, G_FILE_TEST_IS_REGULAR)) + { + gchar *basename; + + basename = g_path_get_basename(s_track); + source = g_strdup_printf("SRT (%s)", basename); + g_free(basename); + } + else + { + source = g_strdup_printf("SRT (none)"); + } + offset = ghb_settings_get_int(settings, "SrtOffset"); + + forced = FALSE; + burned = FALSE; + } + else + { + track = g_strdup( + ghb_settings_combo_option(settings, "SubtitleTrack")); + source = g_strdup(subtitle_source_name(i_source)); + s_track = ghb_settings_get_string(settings, "SubtitleTrack"); + + forced = ghb_settings_get_boolean(settings, "SubtitleForced"); + burned = ghb_settings_get_boolean(settings, "SubtitleBurned"); + } + gtk_list_store_set(GTK_LIST_STORE(store), &iter, // These are displayed in list 0, track, @@ -565,9 +702,13 @@ subtitle_list_refresh_selected(signal_user_data_t *ud) 2, burned, 3, def, 4, source, + 5, offset, // These are used to set combo box values when a list item is selected - 5, s_track, + 6, s_track, + 7, i_source, -1); + g_free(track); + g_free(source); g_free(s_track); if (burned) ghb_subtitle_exclusive_burn(ud, row); @@ -581,15 +722,102 @@ subtitle_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud) g_debug("subtitle_track_changed_cb ()"); ghb_check_dependency(ud, widget); + ghb_widget_to_setting(ud->settings, widget); settings = ghb_selected_subtitle_settings(ud); if (settings != NULL) { + const gchar *track, *lang; + gint tt, source; + ghb_widget_to_setting(settings, widget); subtitle_list_refresh_selected(ud); + track = ghb_settings_combo_option(settings, "SubtitleTrack"); + ghb_settings_set_string(settings, "SubtitleTrackDescription", track); + tt = ghb_settings_get_int(settings, "SubtitleTrack"); + source = ghb_subtitle_track_source(ud, tt); + ghb_settings_set_int(settings, "SubtitleSource", source); + lang = ghb_settings_combo_string(settings, "SubtitleTrack"); + ghb_settings_set_string(settings, "SubtitleLanguage", lang); + ghb_live_reset(ud); } ghb_live_reset(ud); } +G_MODULE_EXPORT void +srt_changed_cb(GtkWidget *widget, signal_user_data_t *ud) +{ + GValue *settings; + + g_debug("srt_changed_cb ()"); + ghb_check_dependency(ud, widget); + ghb_widget_to_setting(ud->settings, widget); + settings = ghb_selected_subtitle_settings(ud); + if (settings != NULL) + { + ghb_widget_to_setting(settings, widget); + subtitle_list_refresh_selected(ud); + + ghb_live_reset(ud); + } +} + +G_MODULE_EXPORT void +srt_file_changed_cb(GtkWidget *widget, signal_user_data_t *ud) +{ + GValue *settings; + + g_debug("srt_changed_cb ()"); + ghb_check_dependency(ud, widget); + ghb_widget_to_setting(ud->settings, widget); + settings = ghb_selected_subtitle_settings(ud); + if (settings != NULL) + { + gchar *filename, *dirname; + + ghb_widget_to_setting(settings, widget); + subtitle_list_refresh_selected(ud); + + ghb_live_reset(ud); + + filename = ghb_settings_get_string(settings, "SrtFile"); + if (g_file_test(filename, G_FILE_TEST_IS_DIR)) + { + ghb_settings_set_string(ud->settings, "SrtDir", filename); + } + else + { + dirname = g_path_get_dirname(filename); + ghb_settings_set_string(ud->settings, "SrtDir", dirname); + g_free(dirname); + } + ghb_pref_save(ud->settings, "SrtDir"); + g_free(filename); + } +} + +G_MODULE_EXPORT void +srt_lang_changed_cb(GtkWidget *widget, signal_user_data_t *ud) +{ + GValue *settings; + + g_debug("srt_lang_changed_cb ()"); + ghb_check_dependency(ud, widget); + ghb_widget_to_setting(ud->settings, widget); + settings = ghb_selected_subtitle_settings(ud); + if (settings != NULL) + { + const gchar *lang; + + ghb_widget_to_setting(settings, widget); + subtitle_list_refresh_selected(ud); + + ghb_live_reset(ud); + + lang = ghb_settings_combo_option(settings, "SrtLanguage"); + ghb_settings_set_string(settings, "SubtitleTrackDescription", lang); + } +} + void ghb_clear_subtitle_list(signal_user_data_t *ud) { @@ -623,7 +851,7 @@ add_to_subtitle_list( const gchar *track, *source; gboolean forced, burned, def; gchar *s_track; - gint i_track; + gint i_source; g_debug("add_to_subtitle_list ()"); treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list")); @@ -636,8 +864,8 @@ add_to_subtitle_list( def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack"); s_track = ghb_settings_get_string(settings, "SubtitleTrack"); - i_track = ghb_settings_get_int(settings, "SubtitleTrack"); - source = ghb_subtitle_track_source_name(ud, i_track); + i_source = ghb_settings_get_int(settings, "SubtitleSource"); + source = subtitle_source_name(i_source); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, @@ -648,12 +876,81 @@ add_to_subtitle_list( 3, def, 4, source, // These are used to set combo box values when a list item is selected - 5, s_track, + 6, s_track, + 7, i_source, + 8, TRUE, + 9, TRUE, + 10, FALSE, -1); gtk_tree_selection_select_iter(selection, &iter); g_free(s_track); } +static void +add_to_srt_list( + signal_user_data_t *ud, + GValue *settings) +{ + GtkTreeView *treeview; + GtkTreeIter iter; + GtkListStore *store; + GtkTreeSelection *selection; + const gchar *lang; + gboolean forced, burned, def; + gchar *filename, *code, *track, *source; + gint i_source, offset; + + g_debug("add_to_srt_list ()"); + treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list")); + selection = gtk_tree_view_get_selection (treeview); + store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview)); + + lang = ghb_settings_combo_option(settings, "SrtLanguage"); + code = ghb_settings_get_string(settings, "SrtCodeset"); + track = g_strdup_printf("%s (%s)", lang, code); + forced = FALSE; + burned = FALSE; + def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack"); + + filename = ghb_settings_get_string(settings, "SrtFile"); + if (g_file_test(filename, G_FILE_TEST_IS_REGULAR)) + { + gchar *basename; + + basename = g_path_get_basename(filename); + source = g_strdup_printf("SRT (%s)", basename); + g_free(basename); + } + else + { + source = g_strdup_printf("SRT (none)"); + } + i_source = SRTSUB; + offset = ghb_settings_get_int(settings, "SrtOffset"); + + gtk_list_store_append(store, &iter); + gtk_list_store_set(store, &iter, + // These are displayed in list + 0, track, + 1, forced, + 2, burned, + 3, def, + 4, source, + 5, offset, + // These are used to set combo box values when a list item is selected + 6, filename, + 7, i_source, + 8, FALSE, + 9, FALSE, + 10, TRUE, + -1); + gtk_tree_selection_select_iter(selection, &iter); + g_free(code); + g_free(track); + g_free(filename); + g_free(source); +} + G_MODULE_EXPORT void subtitle_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud) { @@ -664,41 +961,165 @@ subtitle_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data g_debug("subtitle_list_selection_changed_cb ()"); if (gtk_tree_selection_get_selected(selection, &store, &iter)) { - const gchar *track; + gint source; + GtkTreePath *treepath; + gint *indices, row; + GValue *subtitle_list, *settings; - gtk_tree_model_get(store, &iter, 5, &track, -1); - ghb_ui_update(ud, "SubtitleTrack", ghb_string_value(track)); + treepath = gtk_tree_model_get_path (store, &iter); + indices = gtk_tree_path_get_indices (treepath); + row = indices[0]; + gtk_tree_path_free(treepath); + + subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list"); + if (row >= ghb_array_len(subtitle_list)) + return; + + settings = ghb_array_get_nth(subtitle_list, row); + source = ghb_settings_get_int(settings, "SubtitleSource"); + if (source == SRTSUB) + { + gchar *str; + gint offset; + + str = ghb_settings_get_string(settings, "SrtLanguage"); + ghb_ui_update(ud, "SrtLanguage", ghb_string_value(str)); + g_free(str); + + str = ghb_settings_get_string(settings, "SrtCodeset"); + ghb_ui_update(ud, "SrtCodeset", ghb_string_value(str)); + g_free(str); + + str = ghb_settings_get_string(settings, "SrtFile"); + ghb_ui_update(ud, "SrtFile", ghb_string_value(str)); + g_free(str); + + offset = ghb_settings_get_int(settings, "SrtOffset"); + ghb_ui_update(ud, "SrtOffset", ghb_int_value(offset)); + + widget = GHB_WIDGET(ud->builder, "subtitle_track_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SubtitleTrack"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "srt_lang_label"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "srt_code_label"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "srt_file_label"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "srt_offset_label"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "SrtLanguage"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "SrtCodeset"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "SrtFile"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "SrtOffset"); + gtk_widget_show(widget); + } + else + { + gchar *track; + + track = ghb_settings_get_string(settings, "SubtitleTrack"); + ghb_ui_update(ud, "SubtitleTrack", ghb_string_value(track)); + g_free(track); + + widget = GHB_WIDGET(ud->builder, "srt_lang_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "srt_code_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "srt_file_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "srt_offset_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SrtLanguage"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SrtCodeset"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SrtFile"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SrtOffset"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "subtitle_track_label"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "SubtitleTrack"); + gtk_widget_show(widget); + } widget = GHB_WIDGET (ud->builder, "subtitle_remove"); gtk_widget_set_sensitive(widget, TRUE); } + else + { + widget = GHB_WIDGET(ud->builder, "srt_lang_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "srt_code_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "srt_file_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "srt_offset_label"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SrtLanguage"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SrtCodeset"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SrtFile"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "SrtOffset"); + gtk_widget_hide(widget); + widget = GHB_WIDGET(ud->builder, "subtitle_track_label"); + gtk_widget_show(widget); + widget = GHB_WIDGET(ud->builder, "SubtitleTrack"); + gtk_widget_show(widget); + } } G_MODULE_EXPORT void -subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) +srt_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { // Add the current subtitle settings to the list. GValue *settings; - gint count; - GValue *subtitle_list; gboolean burned = FALSE; gint track; + gchar *dir, *filename; g_debug("subtitle_add_clicked_cb ()"); - subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list"); - if (subtitle_list == NULL) + + track = ghb_settings_get_int(ud->settings, "SubtitleTrack"); + if (mustBurn(ud, track)) { - subtitle_list = ghb_array_value_new(8); - ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list); + burned = TRUE; } - count = ghb_array_len(subtitle_list); - // Don't allow more than 99 - // This is a had limit imposed by libhb/sync.c:GetFifoForId() - if (count >= 99) - return; + settings = ghb_dict_value_new(); + ghb_settings_set_string(settings, "SrtLanguage", "und"); + ghb_settings_set_string(settings, "SrtCodeset", "UTF-8"); - track = ghb_settings_get_int(ud->settings, "SubtitleTrack"); + dir = ghb_settings_get_string(ud->settings, "SrtDir"); + filename = g_strdup_printf("%s/none", dir); + ghb_settings_set_string(settings, "SrtFile", filename); + g_free(dir); + g_free(filename); + + ghb_settings_set_int(settings, "SrtOffset", 0); + ghb_settings_take_value(settings, "SubtitleDefaultTrack", + ghb_boolean_value_new(FALSE)); + + ghb_add_srt(ud, settings); +} + +G_MODULE_EXPORT void +subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) +{ + // Add the current subtitle settings to the list. + GValue *settings; + gboolean burned = FALSE; + gint track; + + g_debug("subtitle_add_clicked_cb ()"); + track = ghb_settings_get_int(ud->settings, "SubtitleTrack"); if (mustBurn(ud, track)) { burned = TRUE; @@ -712,16 +1133,7 @@ subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) ghb_settings_take_value(settings, "SubtitleDefaultTrack", ghb_boolean_value_new(FALSE)); - ghb_array_append(subtitle_list, settings); - add_to_subtitle_list(ud, settings); - if (burned) - ghb_subtitle_exclusive_burn(ud, count); - if (count == 98) - { - GtkWidget *widget; - widget = GHB_WIDGET (ud->builder, "subtitle_add"); - gtk_widget_set_sensitive(widget, FALSE); - } + ghb_add_subtitle(ud, settings); } G_MODULE_EXPORT void @@ -765,12 +1177,15 @@ subtitle_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud) if (row < 0) return; widget = GHB_WIDGET (ud->builder, "subtitle_add"); gtk_widget_set_sensitive(widget, TRUE); + widget = GHB_WIDGET (ud->builder, "srt_add"); + gtk_widget_set_sensitive(widget, TRUE); subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list"); if (row >= ghb_array_len(subtitle_list)) return; GValue *old = ghb_array_get_nth(subtitle_list, row); ghb_value_free(old); ghb_array_remove(subtitle_list, row); + ghb_live_reset(ud); } }