gtk/src/subtitlehandler.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * subtitlehandler.c
   4  * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
   5  *
   6  * subtitlehandler.c is free software.
   7  *
   8  * You may redistribute it and/or modify it under the terms of the
   9  * GNU General Public License, as published by the Free Software
  10  * Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  */
  13
  14 #include <gtk/gtk.h>
  15 #include "hb.h"
  16 #include "settings.h"
  17 #include "hb-backend.h"
  18 #include "values.h"
  19 #include "callbacks.h"
  20 #include "preview.h"
  21 #include "presets.h"
  22 #include "audiohandler.h"
  23 #include "subtitlehandler.h"
  24
  25 static void add_to_subtitle_list(signal_user_data_t *ud, GValue *settings);
  26 static void add_to_srt_list(signal_user_data_t *ud, GValue *settings);
  27
  28 static void
  29 free_subtitle_index_list(gpointer data)
  30 {
  31         g_free(data);
  32 }
  33
  34 static void
  35 free_subtitle_key(gpointer data)
  36 {
  37         if (data != NULL)
  38                 g_free(data);
  39 }
  40
  41 static gboolean
  42 mustBurn(signal_user_data_t *ud, GValue *settings)
  43 {
  44         if (ghb_settings_combo_int(ud->settings, "FileFormat") == HB_MUX_MP4)
  45         {
  46                 // MP4 can only handle burned vobsubs.  make sure there isn't
  47                 // already something burned in the list
  48                 if (ghb_settings_get_int(settings, "SubtitleSource") == VOBSUB)
  49                 {
  50                         return TRUE;
  51                 }
  52         }
  53         return FALSE;
  54 }
  55
  56 gboolean
  57 ghb_soft_in_subtitle_list(GValue *subtitle_list)
  58 {
  59         gint count, ii;
  60         GValue *settings;
  61
  62         count = ghb_array_len(subtitle_list);
  63         for (ii = 0; ii < count; ii++)
  64         {
  65                 settings = ghb_array_get_nth(subtitle_list, ii);
  66                 if (!ghb_settings_get_boolean(settings, "SubtitleBurned"))
  67                 {
  68                         return TRUE;
  69                 }
  70         }
  71         return FALSE;
  72 }
  73
  74 void
  75 ghb_subtitle_exclusive_burn(signal_user_data_t *ud, gint index)
  76 {
  77         GValue *subtitle_list;
  78         GValue *settings;
  79         gint ii, count;
  80         GtkTreeView  *tv;
  81         GtkTreeModel *tm;
  82         GtkTreeIter   ti;
  83         gboolean burned;
  84
  85         g_debug("ghb_subtitle_exclusive_burn");
  86         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
  87         count = ghb_array_len(subtitle_list);
  88         for (ii = 0; ii < count; ii++)
  89         {
  90                 settings = ghb_array_get_nth(subtitle_list, ii);
  91                 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
  92
  93                 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
  94                 g_return_if_fail(tv != NULL);
  95                 tm = gtk_tree_view_get_model(tv);
  96                 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
  97                 if (burned && ii != index && !mustBurn(ud, settings))
  98                 {
  99                         ghb_settings_set_boolean(settings, "SubtitleBurned", FALSE);
 100                         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, FALSE, -1);
 101                 }
 102         }
 103 }
 104
 105 void
 106 ghb_subtitle_exclusive_default(signal_user_data_t *ud, gint index)
 107 {
 108         GValue *subtitle_list;
 109         GValue *settings;
 110         gint ii, count;
 111         GtkTreeView  *tv;
 112         GtkTreeModel *tm;
 113         GtkTreeIter   ti;
 114         gboolean def;
 115
 116         g_debug("ghb_subtitle_exclusive_default");
 117         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 118         count = ghb_array_len(subtitle_list);
 119         for (ii = 0; ii < count; ii++)
 120         {
 121                 settings = ghb_array_get_nth(subtitle_list, ii);
 122                 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 123
 124                 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 125                 g_return_if_fail(tv != NULL);
 126                 tm = gtk_tree_view_get_model(tv);
 127                 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
 128                 if (def && ii != index)
 129                 {
 130
 131                         ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", FALSE);
 132                         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, FALSE, -1);
 133                 }
 134         }
 135 }
 136
 137 void
 138 ghb_add_srt(signal_user_data_t *ud, GValue *settings)
 139 {
 140         // Add the current subtitle settings to the list.
 141         GValue *subtitle_list;
 142         gint count;
 143         const gchar *lang;
 144
 145         g_debug("ghb_add_srt ()");
 146
 147         ghb_settings_set_boolean(settings, "SubtitleBurned", FALSE);
 148         // Add the long track description so the queue can access it
 149         // when a different title is selected.
 150         lang = ghb_settings_combo_option(settings, "SrtLanguage");
 151         ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
 152
 153         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 154         if (subtitle_list == NULL)
 155         {
 156                 subtitle_list = ghb_array_value_new(8);
 157                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 158         }
 159         count = ghb_array_len(subtitle_list);
 160
 161         // Don't allow more than 99
 162         // This is a had limit imposed by libhb/sync.c:GetFifoForId()
 163         if (count >= 99)
 164         {
 165                 ghb_value_free(settings);
 166                 return;
 167         }
 168
 169         ghb_array_append(subtitle_list, settings);
 170         add_to_srt_list(ud, settings);
 171
 172         if (count == 98)
 173         {
 174                 GtkWidget *widget;
 175                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
 176                 gtk_widget_set_sensitive(widget, FALSE);
 177                 widget = GHB_WIDGET (ud->builder, "srt_add");
 178                 gtk_widget_set_sensitive(widget, FALSE);
 179         }
 180         ghb_update_destination_extension(ud);
 181         ghb_live_reset(ud);
 182 }
 183
 184 void
 185 ghb_add_subtitle(signal_user_data_t *ud, GValue *settings)
 186 {
 187         // Add the current subtitle settings to the list.
 188         GValue *subtitle_list;
 189         gint count;
 190         gboolean burned;
 191         const gchar *track;
 192         const gchar *lang;
 193
 194         g_debug("ghb_add_subtitle ()");
 195
 196         // Add the long track description so the queue can access it
 197         // when a different title is selected.
 198         track = ghb_settings_combo_option(settings, "SubtitleTrack");
 199         ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
 200
 201         lang = ghb_settings_combo_string(settings, "SubtitleTrack");
 202         ghb_settings_set_string(settings, "SubtitleLanguage", lang);
 203
 204         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 205         if (subtitle_list == NULL)
 206         {
 207                 subtitle_list = ghb_array_value_new(8);
 208                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 209         }
 210         count = ghb_array_len(subtitle_list);
 211
 212         // Don't allow more than 99
 213         // This is a had limit imposed by libhb/sync.c:GetFifoForId()
 214         if (count >= 99)
 215         {
 216                 ghb_value_free(settings);
 217                 return;
 218         }
 219
 220         ghb_array_append(subtitle_list, settings);
 221         add_to_subtitle_list(ud, settings);
 222
 223         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 224         if (burned)
 225                 ghb_subtitle_exclusive_burn(ud, count);
 226         if (count == 98)
 227         {
 228                 GtkWidget *widget;
 229                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
 230                 gtk_widget_set_sensitive(widget, FALSE);
 231                 widget = GHB_WIDGET (ud->builder, "srt_add");
 232                 gtk_widget_set_sensitive(widget, FALSE);
 233         }
 234         ghb_update_destination_extension(ud);
 235         ghb_live_reset(ud);
 236 }
 237
 238 static void
 239 add_all_pref_subtitles(signal_user_data_t *ud)
 240 {
 241         const GValue *pref_subtitle;
 242         GValue *subtitle;
 243         gint count, ii, track;
 244         char *lang;
 245
 246         pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
 247         count = ghb_array_len(pref_subtitle);
 248         for (ii = 0; ii < count; ii++)
 249         {
 250                 subtitle = ghb_value_dup(ghb_array_get_nth(pref_subtitle, ii));
 251                 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
 252                 // If there are multiple subtitles using the same language, then
 253                 // select sequential tracks for each.  The hash keeps track
 254                 // of the tracks used for each language.
 255                 track = ghb_find_pref_subtitle_track(lang);
 256                 g_free(lang);
 257                 if (track >= -1)
 258                 {
 259                         int source;
 260
 261                         // Add to subtitle list
 262                         ghb_settings_set_int(subtitle, "SubtitleTrack", track);
 263                         source = ghb_subtitle_track_source(ud, track);
 264                         ghb_settings_set_int(subtitle, "SubtitleSource", source);
 265                         ghb_add_subtitle(ud, subtitle);
 266                 }
 267         }
 268 }
 269
 270 void
 271 ghb_set_pref_subtitle(gint titleindex, signal_user_data_t *ud)
 272 {
 273         gint track;
 274         GHashTable *track_indices;
 275         gchar *lang, *pref_lang = NULL;
 276         gchar *audio_lang;
 277         gint foreign_lang_index = -1;
 278         gboolean found_cc = FALSE;
 279
 280         const GValue *pref_subtitle;
 281         GValue *subtitle;
 282         gint count, ii, jj;
 283
 284         g_debug("ghb_set_pref_subtitle %d", titleindex);
 285
 286         // Check to see if we need to add a subtitle track for foreign audio
 287         // language films. A subtitle track will be added if:
 288         //
 289         // The first (default) audio track language does NOT match the users
 290         // chosen Preferred Language AND the Preferred Language is NOT Any (und).
 291         //
 292         audio_lang = ghb_get_user_audio_lang(ud, titleindex, 0);
 293         pref_lang = ghb_settings_get_string(ud->settings, "PreferredLanguage");
 294
 295         if (audio_lang != NULL && pref_lang != NULL &&
 296                 (strcmp(audio_lang, pref_lang) == 0 || strcmp("und", pref_lang) == 0))
 297         {
 298                 g_free(pref_lang);
 299                 pref_lang = NULL;
 300         }
 301
 302         track_indices = g_hash_table_new_full(g_str_hash, g_str_equal,
 303                                                                                         free_subtitle_key, free_subtitle_index_list);
 304
 305         ghb_ui_update(ud, "SubtitleTrack", ghb_int_value(0));
 306
 307         // Clear the subtitle list
 308         ghb_clear_subtitle_list(ud);
 309         if (titleindex < 0)
 310         {
 311                 add_all_pref_subtitles(ud);
 312                 return;
 313         }
 314
 315         // Find "best" subtitle based on subtitle preferences
 316         pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
 317
 318         count = ghb_array_len(pref_subtitle);
 319         jj = 0;
 320         for (ii = 0; ii < count; ii++)
 321         {
 322                 gint source;
 323                 gboolean force, burn;
 324
 325                 subtitle = ghb_array_get_nth(pref_subtitle, ii);
 326                 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
 327                 source = ghb_settings_get_int(subtitle, "SubtitleSource");
 328                 burn = ghb_settings_get_boolean(subtitle, "SubtitleBurned");
 329                 force = ghb_settings_get_boolean(subtitle, "SubtitleForced");
 330                 // If there are multiple subtitles using the same language, then
 331                 // select sequential tracks for each.  The hash keeps track
 332                 // of the tracks used for each language.
 333                 track = ghb_find_subtitle_track(titleindex, lang, burn,
 334                                                                                 force, source, track_indices);
 335                 g_free(lang);
 336                 if (track >= -1)
 337                 {
 338                         GValue *dup = ghb_value_dup(subtitle);
 339                         lang = ghb_subtitle_track_lang(ud, track);
 340                         ghb_settings_set_int(dup, "SubtitleTrack", track);
 341                         if (foreign_lang_index < 0 && pref_lang != NULL &&
 342                                 strcmp(lang, pref_lang) == 0)
 343                         {
 344                                 foreign_lang_index = jj;
 345                                 ghb_settings_take_value(dup, "SubtitleForced",
 346                                                                 ghb_boolean_value_new(FALSE));
 347                                 ghb_settings_take_value(dup, "SubtitleDefaultTrack",
 348                                                                 ghb_boolean_value_new(TRUE));
 349                         }
 350                         source = ghb_subtitle_track_source(ud, track);
 351                         ghb_settings_set_int(dup, "SubtitleSource", source);
 352                         if (source == CC608SUB || source == CC708SUB)
 353                                 found_cc = TRUE;
 354                         ghb_add_subtitle(ud, dup);
 355                         jj++;
 356                         g_free(lang);
 357                 }
 358         }
 359         if (foreign_lang_index < 0 && pref_lang != NULL)
 360         {
 361                 // Subtitle for foreign language audio not added yet
 362                 GValue *settings;
 363                 gboolean burn;
 364
 365                 track = ghb_find_subtitle_track(titleindex, pref_lang, FALSE, FALSE, VOBSUB, track_indices);
 366                 if (track >= -1)
 367                 {
 368                         int source;
 369
 370                         settings = ghb_dict_value_new();
 371                         ghb_settings_set_int(settings, "SubtitleTrack", track);
 372                         source = ghb_subtitle_track_source(ud, track);
 373                         ghb_settings_set_int(settings, "SubtitleSource", source);
 374                         burn = mustBurn(ud, settings);
 375                         ghb_settings_take_value(settings, "SubtitleForced",
 376                                                         ghb_boolean_value_new(FALSE));
 377                         ghb_settings_take_value(settings, "SubtitleBurned",
 378                                                         ghb_boolean_value_new(burn));
 379                         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
 380                                                         ghb_boolean_value_new(TRUE));
 381
 382                         ghb_add_subtitle(ud, settings);
 383                         foreign_lang_index = jj;
 384                 }
 385         }
 386         if (foreign_lang_index >= 0)
 387         {
 388                 GValue *subtitle_list;
 389                 gboolean burn, def;
 390
 391                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 392                 subtitle = ghb_array_get_nth(subtitle_list, foreign_lang_index);
 393
 394                 burn = ghb_settings_get_boolean(subtitle, "SubtitleBurned");
 395                 def = ghb_settings_get_boolean(subtitle, "SubtitleDefaultTrack");
 396                 if (burn)
 397                         ghb_subtitle_exclusive_burn(ud, foreign_lang_index);
 398                 if (def)
 399                         ghb_subtitle_exclusive_default(ud, foreign_lang_index);
 400                 ghb_log("adding subtitle for foreign language audio: %s", audio_lang);
 401         }
 402         if (ghb_settings_get_boolean(ud->settings, "AddCC") && !found_cc)
 403         {
 404                 // Subtitle for foreign language audio not added yet
 405                 GValue *settings;
 406
 407                 track = ghb_find_cc_track(titleindex);
 408                 if (track >= 0)
 409                 {
 410                         int source;
 411
 412                         settings = ghb_dict_value_new();
 413                         ghb_settings_set_int(settings, "SubtitleTrack", track);
 414                         source = ghb_subtitle_track_source(ud, track);
 415                         ghb_settings_set_int(settings, "SubtitleSource", source);
 416                         ghb_settings_take_value(settings, "SubtitleForced",
 417                                                         ghb_boolean_value_new(FALSE));
 418                         ghb_settings_take_value(settings, "SubtitleBurned",
 419                                                         ghb_boolean_value_new(FALSE));
 420                         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
 421                                                         ghb_boolean_value_new(FALSE));
 422
 423                         ghb_add_subtitle(ud, settings);
 424                         ghb_log("adding Closed Captions: %s", audio_lang);
 425                 }
 426         }
 427         if (pref_lang != NULL)
 428                 g_free(pref_lang);
 429         if (audio_lang != NULL)
 430                 g_free(audio_lang);
 431         g_hash_table_destroy(track_indices);
 432 }
 433
 434 gint
 435 ghb_selected_subtitle_row(signal_user_data_t *ud)
 436 {
 437         GtkTreeView *treeview;
 438         GtkTreePath *treepath;
 439         GtkTreeSelection *selection;
 440         GtkTreeModel *store;
 441         GtkTreeIter iter;
 442         gint *indices;
 443         gint row = -1;
 444
 445         g_debug("ghb_selected_subtitle_row ()");
 446         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 447         selection = gtk_tree_view_get_selection (treeview);
 448         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 449         {
 450                 // Get the row number
 451                 treepath = gtk_tree_model_get_path (store, &iter);
 452                 indices = gtk_tree_path_get_indices (treepath);
 453                 row = indices[0];
 454                 gtk_tree_path_free(treepath);
 455         }
 456         return row;
 457 }
 458
 459 GValue*
 460 ghb_selected_subtitle_settings(signal_user_data_t *ud)
 461 {
 462         GtkTreeView *treeview;
 463         GtkTreePath *treepath;
 464         GtkTreeSelection *selection;
 465         GtkTreeModel *store;
 466         GtkTreeIter iter;
 467         gint *indices;
 468         gint row;
 469         GValue *settings = NULL;
 470         const GValue *subtitle_list;
 471
 472         g_debug("get_selected_settings ()");
 473         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 474         selection = gtk_tree_view_get_selection (treeview);
 475         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 476         {
 477                 // Get the row number
 478                 treepath = gtk_tree_model_get_path (store, &iter);
 479                 indices = gtk_tree_path_get_indices (treepath);
 480                 row = indices[0];
 481                 gtk_tree_path_free(treepath);
 482                 // find subtitle settings
 483                 if (row < 0) return NULL;
 484                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 485                 if (row >= ghb_array_len(subtitle_list))
 486                         return NULL;
 487                 settings = ghb_array_get_nth(subtitle_list, row);
 488         }
 489         return settings;
 490 }
 491
 492 G_MODULE_EXPORT void
 493 subtitle_forced_toggled_cb(
 494         GtkCellRendererToggle *cell,
 495         gchar                 *path,
 496         signal_user_data_t    *ud)
 497 {
 498         GtkTreeView  *tv;
 499         GtkTreeModel *tm;
 500         GtkTreeIter   ti;
 501         gboolean      active;
 502         gint          row;
 503         GtkTreePath  *tp;
 504         gint *indices;
 505         GValue *subtitle_list, *settings;
 506         gint source;
 507
 508         g_debug("forced toggled");
 509         tp = gtk_tree_path_new_from_string (path);
 510         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 511         g_return_if_fail(tv != NULL);
 512         tm = gtk_tree_view_get_model(tv);
 513         g_return_if_fail(tm != NULL);
 514         gtk_tree_model_get_iter(tm, &ti, tp);
 515         gtk_tree_model_get(tm, &ti, 1, &active, -1);
 516         active ^= 1;
 517
 518         // Get the row number
 519         indices = gtk_tree_path_get_indices (tp);
 520         row = indices[0];
 521         gtk_tree_path_free(tp);
 522
 523         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 524
 525         if (row < 0 || row >= ghb_array_len(subtitle_list))
 526                 return;
 527
 528         settings = ghb_array_get_nth(subtitle_list, row);
 529
 530         source = ghb_settings_get_int(settings, "SubtitleSource");
 531         if (source != VOBSUB)
 532                 return;
 533
 534         ghb_settings_set_boolean(settings, "SubtitleForced", active);
 535         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 1, active, -1);
 536         ghb_live_reset(ud);
 537 }
 538
 539 G_MODULE_EXPORT void
 540 subtitle_burned_toggled_cb(
 541         GtkCellRendererToggle *cell,
 542         gchar                 *path,
 543         signal_user_data_t    *ud)
 544 {
 545         GtkTreeView  *tv;
 546         GtkTreeModel *tm;
 547         GtkTreeIter   ti;
 548         GtkTreePath  *tp;
 549         gboolean      active;
 550         gint          row;
 551         gint *indices;
 552         GValue *subtitle_list;
 553         gint count;
 554         GValue *settings;
 555         gint source;
 556
 557         g_debug("burned toggled");
 558         tp = gtk_tree_path_new_from_string (path);
 559         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 560         g_return_if_fail(tv != NULL);
 561         tm = gtk_tree_view_get_model(tv);
 562         g_return_if_fail(tm != NULL);
 563         gtk_tree_model_get_iter(tm, &ti, tp);
 564         gtk_tree_model_get(tm, &ti, 2, &active, -1);
 565         active ^= 1;
 566
 567         // Get the row number
 568         indices = gtk_tree_path_get_indices (tp);
 569         row = indices[0];
 570         gtk_tree_path_free(tp);
 571
 572         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 573         count = ghb_array_len(subtitle_list);
 574         if (row < 0 || row >= count)
 575                 return;
 576
 577         settings = ghb_array_get_nth(subtitle_list, row);
 578         source = ghb_settings_get_int(settings, "SubtitleSource");
 579         if (source != VOBSUB)
 580                 return;
 581         if (!active && mustBurn(ud, settings))
 582                 return;
 583
 584         ghb_settings_set_boolean(settings, "SubtitleBurned", active);
 585         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, active, -1);
 586
 587         if (active)
 588         {
 589                 ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", !active);
 590                 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, !active, -1);
 591         }
 592
 593         // Unburn the rest
 594         if (active)
 595                 ghb_subtitle_exclusive_burn(ud, row);
 596         ghb_update_destination_extension(ud);
 597         ghb_live_reset(ud);
 598 }
 599
 600 G_MODULE_EXPORT void
 601 subtitle_default_toggled_cb(
 602         GtkCellRendererToggle *cell,
 603         gchar                 *path,
 604         signal_user_data_t    *ud)
 605 {
 606         GtkTreeView  *tv;
 607         GtkTreeModel *tm;
 608         GtkTreeIter   ti;
 609         GtkTreePath  *tp;
 610         gboolean      active;
 611         gint          row;
 612         gint *indices;
 613         GValue *subtitle_list;
 614         gint count;
 615         GValue *settings;
 616         gboolean burned;
 617
 618         g_debug("default toggled");
 619         tp = gtk_tree_path_new_from_string (path);
 620         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 621         g_return_if_fail(tv != NULL);
 622         tm = gtk_tree_view_get_model(tv);
 623         g_return_if_fail(tm != NULL);
 624         gtk_tree_model_get_iter(tm, &ti, tp);
 625         gtk_tree_model_get(tm, &ti, 3, &active, -1);
 626         active ^= 1;
 627
 628         // Get the row number
 629         indices = gtk_tree_path_get_indices (tp);
 630         row = indices[0];
 631         gtk_tree_path_free(tp);
 632
 633         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 634         count = ghb_array_len(subtitle_list);
 635         if (row < 0 || row >= count)
 636                 return;
 637
 638         settings = ghb_array_get_nth(subtitle_list, row);
 639         if (active && mustBurn(ud, settings))
 640                 return;
 641
 642         ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", active);
 643         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, active, -1);
 644
 645         if (active)
 646         {
 647                 ghb_settings_set_boolean(settings, "SubtitleBurned", !active);
 648                 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, !active, -1);
 649         }
 650         // allow only one default
 651         ghb_subtitle_exclusive_default(ud, row);
 652         ghb_live_reset(ud);
 653 }
 654
 655 static const char*
 656 subtitle_source_name(gint source)
 657 {
 658         const gchar * name;
 659
 660         switch (source)
 661         {
 662                 case VOBSUB:
 663                         name = "Bitmap";
 664                         break;
 665                 case CC708SUB:
 666                 case CC608SUB:
 667                         name = "Text";
 668                         break;
 669                 case SRTSUB:
 670                         name = "SRT";
 671                         break;
 672                 default:
 673                         name = "Unknown";
 674                         break;
 675         }
 676         return name;
 677 }
 678
 679 static void
 680 subtitle_list_refresh_selected(signal_user_data_t *ud)
 681 {
 682         GtkTreeView *treeview;
 683         GtkTreePath *treepath;
 684         GtkTreeSelection *selection;
 685         GtkTreeModel *store;
 686         GtkTreeIter iter;
 687         gint *indices;
 688         gint row;
 689         GValue *settings = NULL;
 690         const GValue *subtitle_list;
 691
 692         g_debug("subtitle_list_refresh_selected ()");
 693         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 694         selection = gtk_tree_view_get_selection (treeview);
 695         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 696         {
 697                 gchar *track, *source;
 698                 gboolean forced, burned, def;
 699                 gchar *s_track;
 700                 gint offset = 0;
 701
 702                 // Get the row number
 703                 treepath = gtk_tree_model_get_path (store, &iter);
 704                 indices = gtk_tree_path_get_indices (treepath);
 705                 row = indices[0];
 706                 gtk_tree_path_free(treepath);
 707                 if (row < 0) return;
 708                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 709                 if (row >= ghb_array_len(subtitle_list))
 710                         return;
 711                 settings = ghb_array_get_nth(subtitle_list, row);
 712
 713                 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 714
 715                 gint i_source;
 716                 i_source = ghb_settings_get_int(settings, "SubtitleSource");
 717                 if (i_source != VOBSUB)
 718                 {
 719                         // Force and burn only apply to VOBSUBS
 720                         forced = FALSE;
 721                         burned = FALSE;
 722                         ghb_settings_set_boolean(settings, "SubtitleForced", forced);
 723                         ghb_settings_set_boolean(settings, "SubtitleBurned", burned);
 724                 }
 725
 726                 if (i_source == SRTSUB)
 727                 {
 728                         const gchar *lang;
 729                         gchar *code;
 730
 731                         lang = ghb_settings_combo_option(settings, "SrtLanguage");
 732                         code = ghb_settings_get_string(settings, "SrtCodeset");
 733                         track = g_strdup_printf("%s (%s)", lang, code);
 734                         g_free(code);
 735
 736                         s_track = ghb_settings_get_string(settings, "SrtFile");
 737                         if (g_file_test(s_track, G_FILE_TEST_IS_REGULAR))
 738                         {
 739                                 gchar *basename;
 740
 741                                 basename = g_path_get_basename(s_track);
 742                                 source = g_strdup_printf("SRT (%s)", basename);
 743                                 g_free(basename);
 744                         }
 745                         else
 746                         {
 747                                 source = g_strdup_printf("SRT (none)");
 748                         }
 749                         offset = ghb_settings_get_int(settings, "SrtOffset");
 750
 751                         forced = FALSE;
 752                         burned = FALSE;
 753                 }
 754                 else
 755                 {
 756                         track = g_strdup(
 757                                 ghb_settings_combo_option(settings, "SubtitleTrack"));
 758                         source = g_strdup(subtitle_source_name(i_source));
 759                         s_track = ghb_settings_get_string(settings, "SubtitleTrack");
 760
 761                         forced = ghb_settings_get_boolean(settings, "SubtitleForced");
 762                         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 763                 }
 764
 765                 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 766                         // These are displayed in list
 767                         0, track,
 768                         1, forced,
 769                         2, burned,
 770                         3, def,
 771                         4, source,
 772                         5, offset,
 773                         // These are used to set combo box values when a list item is selected
 774                         6, s_track,
 775                         7, i_source,
 776                         -1);
 777                 g_free(track);
 778                 g_free(source);
 779                 g_free(s_track);
 780                 if (burned)
 781                         ghb_subtitle_exclusive_burn(ud, row);
 782         }
 783 }
 784
 785 G_MODULE_EXPORT void
 786 subtitle_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 787 {
 788         GValue *settings;
 789
 790         g_debug("subtitle_track_changed_cb ()");
 791         ghb_check_dependency(ud, widget, NULL);
 792         ghb_widget_to_setting(ud->settings, widget);
 793         settings = ghb_selected_subtitle_settings(ud);
 794         if (settings != NULL)
 795         {
 796                 const gchar *track, *lang;
 797                 gint tt, source;
 798
 799                 ghb_widget_to_setting(settings, widget);
 800                 track = ghb_settings_combo_option(settings, "SubtitleTrack");
 801                 ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
 802                 tt = ghb_settings_get_int(settings, "SubtitleTrack");
 803                 source = ghb_subtitle_track_source(ud, tt);
 804                 ghb_settings_set_int(settings, "SubtitleSource", source);
 805                 lang = ghb_settings_combo_string(settings, "SubtitleTrack");
 806                 ghb_settings_set_string(settings, "SubtitleLanguage", lang);
 807                 subtitle_list_refresh_selected(ud);
 808                 ghb_live_reset(ud);
 809         }
 810         ghb_live_reset(ud);
 811 }
 812
 813 G_MODULE_EXPORT void
 814 srt_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 815 {
 816         GValue *settings;
 817
 818         g_debug("srt_changed_cb ()");
 819         ghb_check_dependency(ud, widget, NULL);
 820         ghb_widget_to_setting(ud->settings, widget);
 821         settings = ghb_selected_subtitle_settings(ud);
 822         if (settings != NULL)
 823         {
 824                 ghb_widget_to_setting(settings, widget);
 825                 subtitle_list_refresh_selected(ud);
 826
 827                 ghb_live_reset(ud);
 828         }
 829 }
 830
 831 G_MODULE_EXPORT void
 832 srt_file_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 833 {
 834         GValue *settings;
 835
 836         g_debug("srt_file_changed_cb ()");
 837         ghb_check_dependency(ud, widget, NULL);
 838         ghb_widget_to_setting(ud->settings, widget);
 839         settings = ghb_selected_subtitle_settings(ud);
 840         if (settings != NULL)
 841         {
 842                 gchar *filename, *dirname;
 843
 844                 ghb_widget_to_setting(settings, widget);
 845                 subtitle_list_refresh_selected(ud);
 846
 847                 ghb_live_reset(ud);
 848
 849                 filename = ghb_settings_get_string(settings, "SrtFile");
 850                 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
 851                 {
 852                         ghb_settings_set_string(ud->settings, "SrtDir", filename);
 853                 }
 854                 else
 855                 {
 856                         dirname = g_path_get_dirname(filename);
 857                         ghb_settings_set_string(ud->settings, "SrtDir", dirname);
 858                         g_free(dirname);
 859                 }
 860                 ghb_pref_save(ud->settings, "SrtDir");
 861                 g_free(filename);
 862         }
 863 }
 864
 865 G_MODULE_EXPORT void
 866 srt_lang_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 867 {
 868         GValue *settings;
 869
 870         g_debug("srt_lang_changed_cb ()");
 871         ghb_check_dependency(ud, widget, NULL);
 872         ghb_widget_to_setting(ud->settings, widget);
 873         settings = ghb_selected_subtitle_settings(ud);
 874         if (settings != NULL)
 875         {
 876                 const gchar *lang;
 877
 878                 ghb_widget_to_setting(settings, widget);
 879                 subtitle_list_refresh_selected(ud);
 880
 881                 ghb_live_reset(ud);
 882
 883                 lang = ghb_settings_combo_option(settings, "SrtLanguage");
 884                 ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
 885         }
 886 }
 887
 888 void
 889 ghb_clear_subtitle_list(signal_user_data_t *ud)
 890 {
 891         GtkTreeView *treeview;
 892         GtkListStore *store;
 893         GValue *subtitle_list;
 894
 895         g_debug("clear_subtitle_list ()");
 896         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 897         if (subtitle_list == NULL)
 898         {
 899                 subtitle_list = ghb_array_value_new(8);
 900                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 901         }
 902         else
 903                 ghb_array_value_reset(subtitle_list, 8);
 904         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 905         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 906         gtk_list_store_clear (store);
 907 }
 908
 909 static void
 910 add_to_subtitle_list(
 911         signal_user_data_t *ud,
 912         GValue *settings)
 913 {
 914         GtkTreeView *treeview;
 915         GtkTreeIter iter;
 916         GtkListStore *store;
 917         GtkTreeSelection *selection;
 918         const gchar *track, *source;
 919         gboolean forced, burned, def;
 920         gchar *s_track;
 921         gint i_source;
 922
 923         g_debug("add_to_subtitle_list ()");
 924         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 925         selection = gtk_tree_view_get_selection (treeview);
 926         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 927
 928         track = ghb_settings_combo_option(settings, "SubtitleTrack");
 929         forced = ghb_settings_get_boolean(settings, "SubtitleForced");
 930         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 931         def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 932
 933         s_track = ghb_settings_get_string(settings, "SubtitleTrack");
 934         i_source = ghb_settings_get_int(settings, "SubtitleSource");
 935         source = subtitle_source_name(i_source);
 936
 937         gtk_list_store_append(store, &iter);
 938         gtk_list_store_set(store, &iter,
 939                 // These are displayed in list
 940                 0, track,
 941                 1, forced,
 942                 2, burned,
 943                 3, def,
 944                 4, source,
 945                 // These are used to set combo box values when a list item is selected
 946                 6, s_track,
 947                 7, i_source,
 948                 8, TRUE,
 949                 9, TRUE,
 950                 10, FALSE,
 951                 -1);
 952         gtk_tree_selection_select_iter(selection, &iter);
 953         g_free(s_track);
 954 }
 955
 956 static void
 957 add_to_srt_list(
 958         signal_user_data_t *ud,
 959         GValue *settings)
 960 {
 961         GtkTreeView *treeview;
 962         GtkTreeIter iter;
 963         GtkListStore *store;
 964         GtkTreeSelection *selection;
 965         const gchar *lang;
 966         gboolean forced, burned, def;
 967         gchar *filename, *code, *track, *source;
 968         gint i_source, offset;
 969
 970         g_debug("add_to_srt_list ()");
 971         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 972         selection = gtk_tree_view_get_selection (treeview);
 973         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 974
 975         lang = ghb_settings_combo_option(settings, "SrtLanguage");
 976         code = ghb_settings_get_string(settings, "SrtCodeset");
 977         track = g_strdup_printf("%s (%s)", lang, code);
 978         forced = FALSE;
 979         burned = FALSE;
 980         def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 981
 982         filename = ghb_settings_get_string(settings, "SrtFile");
 983         if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
 984         {
 985                 gchar *basename;
 986
 987                 basename = g_path_get_basename(filename);
 988                 source = g_strdup_printf("SRT (%s)", basename);
 989                 g_free(basename);
 990         }
 991         else
 992         {
 993                 source = g_strdup_printf("SRT (none)");
 994         }
 995         i_source = SRTSUB;
 996         offset = ghb_settings_get_int(settings, "SrtOffset");
 997
 998         gtk_list_store_append(store, &iter);
 999         gtk_list_store_set(store, &iter,
1000                 // These are displayed in list
1001                 0, track,
1002                 1, forced,
1003                 2, burned,
1004                 3, def,
1005                 4, source,
1006                 5, offset,
1007                 // These are used to set combo box values when a list item is selected
1008                 6, filename,
1009                 7, i_source,
1010                 8, FALSE,
1011                 9, FALSE,
1012                 10, TRUE,
1013                 -1);
1014         gtk_tree_selection_select_iter(selection, &iter);
1015         g_free(code);
1016         g_free(track);
1017         g_free(filename);
1018         g_free(source);
1019 }
1020
1021 G_MODULE_EXPORT void
1022 subtitle_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
1023 {
1024         GtkTreeModel *store;
1025         GtkTreeIter iter;
1026         GtkWidget *widget;
1027
1028         g_debug("subtitle_list_selection_changed_cb ()");
1029         if (gtk_tree_selection_get_selected(selection, &store, &iter))
1030         {
1031                 gint source;
1032                 GtkTreePath *treepath;
1033                 gint *indices, row;
1034                 GValue *subtitle_list, *settings;
1035
1036                 treepath = gtk_tree_model_get_path (store, &iter);
1037                 indices = gtk_tree_path_get_indices (treepath);
1038                 row = indices[0];
1039                 gtk_tree_path_free(treepath);
1040
1041                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1042                 if (row >= ghb_array_len(subtitle_list))
1043                         return;
1044
1045                 settings = ghb_array_get_nth(subtitle_list, row);
1046
1047                 source = ghb_settings_get_int(settings, "SubtitleSource");
1048                 if (source == SRTSUB)
1049                 {
1050                         gchar *str;
1051                         gint offset;
1052
1053                         str = ghb_settings_get_string(settings, "SrtLanguage");
1054                         ghb_ui_update(ud, "SrtLanguage", ghb_string_value(str));
1055                         g_free(str);
1056
1057                         str = ghb_settings_get_string(settings, "SrtCodeset");
1058                         ghb_ui_update(ud, "SrtCodeset", ghb_string_value(str));
1059                         g_free(str);
1060
1061                         str = ghb_settings_get_string(settings, "SrtFile");
1062                         ghb_ui_update(ud, "SrtFile", ghb_string_value(str));
1063                         g_free(str);
1064
1065                         offset = ghb_settings_get_int(settings, "SrtOffset");
1066                         ghb_ui_update(ud, "SrtOffset", ghb_int_value(offset));
1067
1068                         widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1069                         gtk_widget_hide(widget);
1070                         widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1071                         gtk_widget_hide(widget);
1072                         widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1073                         gtk_widget_show(widget);
1074                         widget = GHB_WIDGET(ud->builder, "srt_code_label");
1075                         gtk_widget_show(widget);
1076                         widget = GHB_WIDGET(ud->builder, "srt_file_label");
1077                         gtk_widget_show(widget);
1078                         widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1079                         gtk_widget_show(widget);
1080                         widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1081                         gtk_widget_show(widget);
1082                         widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1083                         gtk_widget_show(widget);
1084                         widget = GHB_WIDGET(ud->builder, "SrtFile");
1085                         gtk_widget_show(widget);
1086                         widget = GHB_WIDGET(ud->builder, "SrtOffset");
1087                         gtk_widget_show(widget);
1088                 }
1089                 else
1090                 {
1091                         gchar *track;
1092
1093                         track = ghb_settings_get_string(settings, "SubtitleTrack");
1094                         ghb_ui_update(ud, "SubtitleTrack", ghb_string_value(track));
1095                         g_free(track);
1096
1097                         widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1098                         gtk_widget_hide(widget);
1099                         widget = GHB_WIDGET(ud->builder, "srt_code_label");
1100                         gtk_widget_hide(widget);
1101                         widget = GHB_WIDGET(ud->builder, "srt_file_label");
1102                         gtk_widget_hide(widget);
1103                         widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1104                         gtk_widget_hide(widget);
1105                         widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1106                         gtk_widget_hide(widget);
1107                         widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1108                         gtk_widget_hide(widget);
1109                         widget = GHB_WIDGET(ud->builder, "SrtFile");
1110                         gtk_widget_hide(widget);
1111                         widget = GHB_WIDGET(ud->builder, "SrtOffset");
1112                         gtk_widget_hide(widget);
1113                         widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1114                         gtk_widget_show(widget);
1115                         widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1116                         gtk_widget_show(widget);
1117                 }
1118                 widget = GHB_WIDGET (ud->builder, "subtitle_remove");
1119                 gtk_widget_set_sensitive(widget, TRUE);
1120         }
1121         else
1122         {
1123                 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1124                 gtk_widget_hide(widget);
1125                 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1126                 gtk_widget_hide(widget);
1127                 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1128                 gtk_widget_hide(widget);
1129                 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1130                 gtk_widget_hide(widget);
1131                 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1132                 gtk_widget_hide(widget);
1133                 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1134                 gtk_widget_hide(widget);
1135                 widget = GHB_WIDGET(ud->builder, "SrtFile");
1136                 gtk_widget_hide(widget);
1137                 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1138                 gtk_widget_hide(widget);
1139                 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1140                 gtk_widget_show(widget);
1141                 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1142                 gtk_widget_show(widget);
1143         }
1144 }
1145
1146 G_MODULE_EXPORT void
1147 srt_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1148 {
1149         // Add the current subtitle settings to the list.
1150         GValue *settings;
1151         gchar *dir, *filename;
1152
1153         g_debug("subtitle_add_clicked_cb ()");
1154
1155         settings = ghb_dict_value_new();
1156         ghb_settings_set_int(settings, "SubtitleSource", SRTSUB);
1157         ghb_settings_set_string(settings, "SrtLanguage", "und");
1158         ghb_settings_set_string(settings, "SrtCodeset", "UTF-8");
1159
1160         dir = ghb_settings_get_string(ud->settings, "SrtDir");
1161         filename = g_strdup_printf("%s/none", dir);
1162         ghb_settings_set_string(settings, "SrtFile", filename);
1163         g_free(dir);
1164         g_free(filename);
1165
1166         ghb_settings_set_int(settings, "SrtOffset", 0);
1167         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1168                                                         ghb_boolean_value_new(FALSE));
1169
1170         ghb_add_srt(ud, settings);
1171 }
1172
1173 G_MODULE_EXPORT void
1174 subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1175 {
1176         // Add the current subtitle settings to the list.
1177         GValue *settings;
1178         gboolean burned = FALSE;
1179         gint track, source;
1180
1181         g_debug("subtitle_add_clicked_cb ()");
1182
1183         track = ghb_settings_get_int(ud->settings, "SubtitleTrack");
1184
1185         settings = ghb_dict_value_new();
1186         ghb_settings_set_int(settings, "SubtitleTrack", track);
1187         source = ghb_subtitle_track_source(ud, track);
1188         ghb_settings_set_int(settings, "SubtitleSource", source);
1189         if (mustBurn(ud, settings))
1190         {
1191                 burned = TRUE;
1192         }
1193         ghb_settings_take_value(settings, "SubtitleForced",
1194                                                         ghb_boolean_value_new(FALSE));
1195         ghb_settings_take_value(settings, "SubtitleBurned",
1196                                                         ghb_boolean_value_new(burned));
1197         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1198                                                         ghb_boolean_value_new(FALSE));
1199
1200         ghb_add_subtitle(ud, settings);
1201 }
1202
1203 G_MODULE_EXPORT void
1204 subtitle_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
1205 {
1206         GtkTreeView *treeview;
1207         GtkTreePath *treepath;
1208         GtkTreeSelection *selection;
1209         GtkTreeModel *store;
1210         GtkTreeIter iter, nextIter;
1211         gint *indices;
1212         gint row;
1213         GValue *subtitle_list;
1214
1215         g_debug("subtitle_remove_clicked_cb ()");
1216         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1217         selection = gtk_tree_view_get_selection (treeview);
1218         if (gtk_tree_selection_get_selected(selection, &store, &iter))
1219         {
1220                 nextIter = iter;
1221                 if (!gtk_tree_model_iter_next(store, &nextIter))
1222                 {
1223                         nextIter = iter;
1224                         if (gtk_tree_model_get_iter_first(store, &nextIter))
1225                         {
1226                                 gtk_tree_selection_select_iter (selection, &nextIter);
1227                         }
1228                 }
1229                 else
1230                 {
1231                         gtk_tree_selection_select_iter (selection, &nextIter);
1232                 }
1233                 // Get the row number
1234                 treepath = gtk_tree_model_get_path (store, &iter);
1235                 indices = gtk_tree_path_get_indices (treepath);
1236                 row = indices[0];
1237                 gtk_tree_path_free(treepath);
1238                 // Remove the selected item
1239                 gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
1240                 // remove from subtitle settings list
1241                 if (row < 0) return;
1242                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
1243                 gtk_widget_set_sensitive(widget, TRUE);
1244                 widget = GHB_WIDGET (ud->builder, "srt_add");
1245                 gtk_widget_set_sensitive(widget, TRUE);
1246                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1247                 if (row >= ghb_array_len(subtitle_list))
1248                         return;
1249                 GValue *old = ghb_array_get_nth(subtitle_list, row);
1250                 ghb_value_free(old);
1251                 ghb_array_remove(subtitle_list, row);
1252                 ghb_live_reset(ud);
1253         }
1254 }
1255
1256 void
1257 ghb_subtitle_prune(signal_user_data_t *ud)
1258 {
1259         GtkTreeView  *tv;
1260         GtkTreeModel *tm;
1261         GtkTreeIter   ti;
1262         GValue *subtitle_list;
1263         gint count, ii;
1264         gint first_track = 0, one_burned = 0;
1265
1266         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1267         if (subtitle_list == NULL)
1268                 return;
1269         count = ghb_array_len(subtitle_list);
1270
1271         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1272         g_return_if_fail(tv != NULL);
1273         tm = gtk_tree_view_get_model(tv);
1274         for (ii = count-1; ii >= 0; ii--)
1275         {
1276                 gboolean burned;
1277                 GValue *settings;
1278
1279                 settings = ghb_array_get_nth(subtitle_list, ii);
1280                 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
1281                 if (!burned && mustBurn(ud, settings))
1282                 {
1283                         gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
1284                         gtk_list_store_remove (GTK_LIST_STORE(tm), &ti);
1285                         ghb_array_remove(subtitle_list, ii);
1286                 }
1287                 if (burned)
1288                 {
1289                         first_track = ii;
1290                         one_burned++;
1291                 }
1292         }
1293         if (one_burned)
1294         {
1295                 ghb_subtitle_exclusive_burn(ud, first_track);
1296         }
1297 }
1298
1299 void
1300 ghb_reset_subtitles(signal_user_data_t *ud, GValue *settings)
1301 {
1302         GValue *slist;
1303         GValue *subtitle;
1304         gint count, ii;
1305         gint titleindex;
1306
1307         g_debug("ghb_reset_subtitles");
1308         ghb_clear_subtitle_list(ud);
1309         titleindex = ghb_settings_combo_int(ud->settings, "title");
1310         if (titleindex < 0)
1311                 return;
1312
1313         slist = ghb_settings_get_value(settings, "subtitle_list");
1314         count = ghb_array_len(slist);
1315         for (ii = 0; ii < count; ii++)
1316         {
1317                 int source;
1318
1319                 subtitle = ghb_value_dup(ghb_array_get_nth(slist, ii));
1320                 source = ghb_settings_get_int(subtitle, "SubtitleSource");
1321                 if (source == SRTSUB)
1322                         ghb_add_srt(ud, subtitle);
1323                 else
1324                         ghb_add_subtitle(ud, subtitle);
1325         }
1326 }
1327