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
 617         g_debug("default toggled");
 618         tp = gtk_tree_path_new_from_string (path);
 619         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 620         g_return_if_fail(tv != NULL);
 621         tm = gtk_tree_view_get_model(tv);
 622         g_return_if_fail(tm != NULL);
 623         gtk_tree_model_get_iter(tm, &ti, tp);
 624         gtk_tree_model_get(tm, &ti, 3, &active, -1);
 625         active ^= 1;
 626
 627         // Get the row number
 628         indices = gtk_tree_path_get_indices (tp);
 629         row = indices[0];
 630         gtk_tree_path_free(tp);
 631
 632         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 633         count = ghb_array_len(subtitle_list);
 634         if (row < 0 || row >= count)
 635                 return;
 636
 637         settings = ghb_array_get_nth(subtitle_list, row);
 638         if (active && mustBurn(ud, settings))
 639                 return;
 640
 641         ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", active);
 642         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, active, -1);
 643
 644         if (active)
 645         {
 646                 ghb_settings_set_boolean(settings, "SubtitleBurned", !active);
 647                 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, !active, -1);
 648         }
 649         // allow only one default
 650         ghb_subtitle_exclusive_default(ud, row);
 651         ghb_live_reset(ud);
 652 }
 653
 654 static const char*
 655 subtitle_source_name(gint source)
 656 {
 657         const gchar * name;
 658
 659         switch (source)
 660         {
 661                 case VOBSUB:
 662                         name = "Bitmap";
 663                         break;
 664                 case CC708SUB:
 665                 case CC608SUB:
 666                         name = "Text";
 667                         break;
 668                 case SRTSUB:
 669                         name = "SRT";
 670                         break;
 671                 default:
 672                         name = "Unknown";
 673                         break;
 674         }
 675         return name;
 676 }
 677
 678 static void
 679 subtitle_list_refresh_selected(signal_user_data_t *ud)
 680 {
 681         GtkTreeView *treeview;
 682         GtkTreePath *treepath;
 683         GtkTreeSelection *selection;
 684         GtkTreeModel *store;
 685         GtkTreeIter iter;
 686         gint *indices;
 687         gint row;
 688         GValue *settings = NULL;
 689         const GValue *subtitle_list;
 690
 691         g_debug("subtitle_list_refresh_selected ()");
 692         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 693         selection = gtk_tree_view_get_selection (treeview);
 694         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 695         {
 696                 gchar *track, *source;
 697                 gboolean forced, burned, def;
 698                 gchar *s_track;
 699                 gint offset = 0;
 700
 701                 // Get the row number
 702                 treepath = gtk_tree_model_get_path (store, &iter);
 703                 indices = gtk_tree_path_get_indices (treepath);
 704                 row = indices[0];
 705                 gtk_tree_path_free(treepath);
 706                 if (row < 0) return;
 707                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 708                 if (row >= ghb_array_len(subtitle_list))
 709                         return;
 710                 settings = ghb_array_get_nth(subtitle_list, row);
 711
 712                 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 713
 714                 gint i_source;
 715                 i_source = ghb_settings_get_int(settings, "SubtitleSource");
 716                 if (i_source != VOBSUB)
 717                 {
 718                         // Force and burn only apply to VOBSUBS
 719                         forced = FALSE;
 720                         burned = FALSE;
 721                         ghb_settings_set_boolean(settings, "SubtitleForced", forced);
 722                         ghb_settings_set_boolean(settings, "SubtitleBurned", burned);
 723                 }
 724
 725                 if (i_source == SRTSUB)
 726                 {
 727                         const gchar *lang;
 728                         gchar *code;
 729
 730                         lang = ghb_settings_combo_option(settings, "SrtLanguage");
 731                         code = ghb_settings_get_string(settings, "SrtCodeset");
 732                         track = g_strdup_printf("%s (%s)", lang, code);
 733                         g_free(code);
 734
 735                         s_track = ghb_settings_get_string(settings, "SrtFile");
 736                         if (g_file_test(s_track, G_FILE_TEST_IS_REGULAR))
 737                         {
 738                                 gchar *basename;
 739
 740                                 basename = g_path_get_basename(s_track);
 741                                 source = g_strdup_printf("SRT (%s)", basename);
 742                                 g_free(basename);
 743                         }
 744                         else
 745                         {
 746                                 source = g_strdup_printf("SRT (none)");
 747                         }
 748                         offset = ghb_settings_get_int(settings, "SrtOffset");
 749
 750                         forced = FALSE;
 751                         burned = FALSE;
 752                 }
 753                 else
 754                 {
 755                         track = g_strdup(
 756                                 ghb_settings_combo_option(settings, "SubtitleTrack"));
 757                         source = g_strdup(subtitle_source_name(i_source));
 758                         s_track = ghb_settings_get_string(settings, "SubtitleTrack");
 759
 760                         forced = ghb_settings_get_boolean(settings, "SubtitleForced");
 761                         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 762                 }
 763
 764                 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 765                         // These are displayed in list
 766                         0, track,
 767                         1, forced,
 768                         2, burned,
 769                         3, def,
 770                         4, source,
 771                         5, offset,
 772                         // These are used to set combo box values when a list item is selected
 773                         6, s_track,
 774                         7, i_source,
 775                         -1);
 776                 g_free(track);
 777                 g_free(source);
 778                 g_free(s_track);
 779                 if (burned)
 780                         ghb_subtitle_exclusive_burn(ud, row);
 781         }
 782 }
 783
 784 G_MODULE_EXPORT void
 785 subtitle_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 786 {
 787         GValue *settings;
 788
 789         g_debug("subtitle_track_changed_cb ()");
 790         ghb_check_dependency(ud, widget, NULL);
 791         ghb_widget_to_setting(ud->settings, widget);
 792         settings = ghb_selected_subtitle_settings(ud);
 793         if (settings != NULL)
 794         {
 795                 const gchar *track, *lang;
 796                 gint tt, source;
 797
 798                 ghb_widget_to_setting(settings, widget);
 799                 track = ghb_settings_combo_option(settings, "SubtitleTrack");
 800                 ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
 801                 tt = ghb_settings_get_int(settings, "SubtitleTrack");
 802                 source = ghb_subtitle_track_source(ud, tt);
 803                 ghb_settings_set_int(settings, "SubtitleSource", source);
 804                 lang = ghb_settings_combo_string(settings, "SubtitleTrack");
 805                 ghb_settings_set_string(settings, "SubtitleLanguage", lang);
 806                 subtitle_list_refresh_selected(ud);
 807                 ghb_live_reset(ud);
 808         }
 809         ghb_live_reset(ud);
 810 }
 811
 812 G_MODULE_EXPORT void
 813 srt_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 814 {
 815         GValue *settings;
 816
 817         g_debug("srt_changed_cb ()");
 818         ghb_check_dependency(ud, widget, NULL);
 819         ghb_widget_to_setting(ud->settings, widget);
 820         settings = ghb_selected_subtitle_settings(ud);
 821         if (settings != NULL)
 822         {
 823                 ghb_widget_to_setting(settings, widget);
 824                 subtitle_list_refresh_selected(ud);
 825
 826                 ghb_live_reset(ud);
 827         }
 828 }
 829
 830 G_MODULE_EXPORT void
 831 srt_file_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 832 {
 833         GValue *settings;
 834
 835         g_debug("srt_file_changed_cb ()");
 836         ghb_check_dependency(ud, widget, NULL);
 837         ghb_widget_to_setting(ud->settings, widget);
 838         settings = ghb_selected_subtitle_settings(ud);
 839         if (settings != NULL)
 840         {
 841                 gchar *filename, *dirname;
 842
 843                 ghb_widget_to_setting(settings, widget);
 844                 subtitle_list_refresh_selected(ud);
 845
 846                 ghb_live_reset(ud);
 847
 848                 filename = ghb_settings_get_string(settings, "SrtFile");
 849                 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
 850                 {
 851                         ghb_settings_set_string(ud->settings, "SrtDir", filename);
 852                 }
 853                 else
 854                 {
 855                         dirname = g_path_get_dirname(filename);
 856                         ghb_settings_set_string(ud->settings, "SrtDir", dirname);
 857                         g_free(dirname);
 858                 }
 859                 ghb_pref_save(ud->settings, "SrtDir");
 860                 g_free(filename);
 861         }
 862 }
 863
 864 G_MODULE_EXPORT void
 865 srt_lang_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 866 {
 867         GValue *settings;
 868
 869         g_debug("srt_lang_changed_cb ()");
 870         ghb_check_dependency(ud, widget, NULL);
 871         ghb_widget_to_setting(ud->settings, widget);
 872         settings = ghb_selected_subtitle_settings(ud);
 873         if (settings != NULL)
 874         {
 875                 const gchar *lang;
 876
 877                 ghb_widget_to_setting(settings, widget);
 878                 subtitle_list_refresh_selected(ud);
 879
 880                 ghb_live_reset(ud);
 881
 882                 lang = ghb_settings_combo_option(settings, "SrtLanguage");
 883                 ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
 884         }
 885 }
 886
 887 void
 888 ghb_clear_subtitle_list(signal_user_data_t *ud)
 889 {
 890         GtkTreeView *treeview;
 891         GtkListStore *store;
 892         GValue *subtitle_list;
 893
 894         g_debug("clear_subtitle_list ()");
 895         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 896         if (subtitle_list == NULL)
 897         {
 898                 subtitle_list = ghb_array_value_new(8);
 899                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 900         }
 901         else
 902                 ghb_array_value_reset(subtitle_list, 8);
 903         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 904         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 905         gtk_list_store_clear (store);
 906 }
 907
 908 static void
 909 add_to_subtitle_list(
 910         signal_user_data_t *ud,
 911         GValue *settings)
 912 {
 913         GtkTreeView *treeview;
 914         GtkTreeIter iter;
 915         GtkListStore *store;
 916         GtkTreeSelection *selection;
 917         const gchar *track, *source;
 918         gboolean forced, burned, def;
 919         gchar *s_track;
 920         gint i_source;
 921
 922         g_debug("add_to_subtitle_list ()");
 923         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 924         selection = gtk_tree_view_get_selection (treeview);
 925         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 926
 927         track = ghb_settings_combo_option(settings, "SubtitleTrack");
 928         forced = ghb_settings_get_boolean(settings, "SubtitleForced");
 929         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 930         def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 931
 932         s_track = ghb_settings_get_string(settings, "SubtitleTrack");
 933         i_source = ghb_settings_get_int(settings, "SubtitleSource");
 934         source = subtitle_source_name(i_source);
 935
 936         gtk_list_store_append(store, &iter);
 937         gtk_list_store_set(store, &iter,
 938                 // These are displayed in list
 939                 0, track,
 940                 1, forced,
 941                 2, burned,
 942                 3, def,
 943                 4, source,
 944                 // These are used to set combo box values when a list item is selected
 945                 6, s_track,
 946                 7, i_source,
 947                 8, TRUE,
 948                 9, TRUE,
 949                 10, FALSE,
 950                 -1);
 951         gtk_tree_selection_select_iter(selection, &iter);
 952         g_free(s_track);
 953 }
 954
 955 static void
 956 add_to_srt_list(
 957         signal_user_data_t *ud,
 958         GValue *settings)
 959 {
 960         GtkTreeView *treeview;
 961         GtkTreeIter iter;
 962         GtkListStore *store;
 963         GtkTreeSelection *selection;
 964         const gchar *lang;
 965         gboolean forced, burned, def;
 966         gchar *filename, *code, *track, *source;
 967         gint i_source, offset;
 968
 969         g_debug("add_to_srt_list ()");
 970         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 971         selection = gtk_tree_view_get_selection (treeview);
 972         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 973
 974         lang = ghb_settings_combo_option(settings, "SrtLanguage");
 975         code = ghb_settings_get_string(settings, "SrtCodeset");
 976         track = g_strdup_printf("%s (%s)", lang, code);
 977         forced = FALSE;
 978         burned = FALSE;
 979         def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 980
 981         filename = ghb_settings_get_string(settings, "SrtFile");
 982         if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
 983         {
 984                 gchar *basename;
 985
 986                 basename = g_path_get_basename(filename);
 987                 source = g_strdup_printf("SRT (%s)", basename);
 988                 g_free(basename);
 989         }
 990         else
 991         {
 992                 source = g_strdup_printf("SRT (none)");
 993         }
 994         i_source = SRTSUB;
 995         offset = ghb_settings_get_int(settings, "SrtOffset");
 996
 997         gtk_list_store_append(store, &iter);
 998         gtk_list_store_set(store, &iter,
 999                 // These are displayed in list
1000                 0, track,
1001                 1, forced,
1002                 2, burned,
1003                 3, def,
1004                 4, source,
1005                 5, offset,
1006                 // These are used to set combo box values when a list item is selected
1007                 6, filename,
1008                 7, i_source,
1009                 8, FALSE,
1010                 9, FALSE,
1011                 10, TRUE,
1012                 -1);
1013         gtk_tree_selection_select_iter(selection, &iter);
1014         g_free(code);
1015         g_free(track);
1016         g_free(filename);
1017         g_free(source);
1018 }
1019
1020 G_MODULE_EXPORT void
1021 subtitle_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
1022 {
1023         GtkTreeModel *store;
1024         GtkTreeIter iter;
1025         GtkWidget *widget;
1026
1027         g_debug("subtitle_list_selection_changed_cb ()");
1028         if (gtk_tree_selection_get_selected(selection, &store, &iter))
1029         {
1030                 gint source;
1031                 GtkTreePath *treepath;
1032                 gint *indices, row;
1033                 GValue *subtitle_list, *settings;
1034
1035                 treepath = gtk_tree_model_get_path (store, &iter);
1036                 indices = gtk_tree_path_get_indices (treepath);
1037                 row = indices[0];
1038                 gtk_tree_path_free(treepath);
1039
1040                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1041                 if (row >= ghb_array_len(subtitle_list))
1042                         return;
1043
1044                 settings = ghb_array_get_nth(subtitle_list, row);
1045
1046                 source = ghb_settings_get_int(settings, "SubtitleSource");
1047                 if (source == SRTSUB)
1048                 {
1049                         gchar *str;
1050                         gint offset;
1051
1052                         str = ghb_settings_get_string(settings, "SrtLanguage");
1053                         ghb_ui_update(ud, "SrtLanguage", ghb_string_value(str));
1054                         g_free(str);
1055
1056                         str = ghb_settings_get_string(settings, "SrtCodeset");
1057                         ghb_ui_update(ud, "SrtCodeset", ghb_string_value(str));
1058                         g_free(str);
1059
1060                         str = ghb_settings_get_string(settings, "SrtFile");
1061                         ghb_ui_update(ud, "SrtFile", ghb_string_value(str));
1062                         g_free(str);
1063
1064                         offset = ghb_settings_get_int(settings, "SrtOffset");
1065                         ghb_ui_update(ud, "SrtOffset", ghb_int_value(offset));
1066
1067                         widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1068                         gtk_widget_hide(widget);
1069                         widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1070                         gtk_widget_hide(widget);
1071                         widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1072                         gtk_widget_show(widget);
1073                         widget = GHB_WIDGET(ud->builder, "srt_code_label");
1074                         gtk_widget_show(widget);
1075                         widget = GHB_WIDGET(ud->builder, "srt_file_label");
1076                         gtk_widget_show(widget);
1077                         widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1078                         gtk_widget_show(widget);
1079                         widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1080                         gtk_widget_show(widget);
1081                         widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1082                         gtk_widget_show(widget);
1083                         widget = GHB_WIDGET(ud->builder, "SrtFile");
1084                         gtk_widget_show(widget);
1085                         widget = GHB_WIDGET(ud->builder, "SrtOffset");
1086                         gtk_widget_show(widget);
1087                 }
1088                 else
1089                 {
1090                         gchar *track;
1091
1092                         track = ghb_settings_get_string(settings, "SubtitleTrack");
1093                         ghb_ui_update(ud, "SubtitleTrack", ghb_string_value(track));
1094                         g_free(track);
1095
1096                         widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1097                         gtk_widget_hide(widget);
1098                         widget = GHB_WIDGET(ud->builder, "srt_code_label");
1099                         gtk_widget_hide(widget);
1100                         widget = GHB_WIDGET(ud->builder, "srt_file_label");
1101                         gtk_widget_hide(widget);
1102                         widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1103                         gtk_widget_hide(widget);
1104                         widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1105                         gtk_widget_hide(widget);
1106                         widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1107                         gtk_widget_hide(widget);
1108                         widget = GHB_WIDGET(ud->builder, "SrtFile");
1109                         gtk_widget_hide(widget);
1110                         widget = GHB_WIDGET(ud->builder, "SrtOffset");
1111                         gtk_widget_hide(widget);
1112                         widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1113                         gtk_widget_show(widget);
1114                         widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1115                         gtk_widget_show(widget);
1116                 }
1117                 widget = GHB_WIDGET (ud->builder, "subtitle_remove");
1118                 gtk_widget_set_sensitive(widget, TRUE);
1119         }
1120         else
1121         {
1122                 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1123                 gtk_widget_hide(widget);
1124                 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1125                 gtk_widget_hide(widget);
1126                 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1127                 gtk_widget_hide(widget);
1128                 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1129                 gtk_widget_hide(widget);
1130                 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1131                 gtk_widget_hide(widget);
1132                 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1133                 gtk_widget_hide(widget);
1134                 widget = GHB_WIDGET(ud->builder, "SrtFile");
1135                 gtk_widget_hide(widget);
1136                 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1137                 gtk_widget_hide(widget);
1138                 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1139                 gtk_widget_show(widget);
1140                 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1141                 gtk_widget_show(widget);
1142         }
1143 }
1144
1145 G_MODULE_EXPORT void
1146 srt_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1147 {
1148         // Add the current subtitle settings to the list.
1149         GValue *settings;
1150         gchar *dir, *filename;
1151
1152         g_debug("subtitle_add_clicked_cb ()");
1153
1154         settings = ghb_dict_value_new();
1155         ghb_settings_set_int(settings, "SubtitleSource", SRTSUB);
1156         ghb_settings_set_string(settings, "SrtLanguage", "und");
1157         ghb_settings_set_string(settings, "SrtCodeset", "UTF-8");
1158
1159         dir = ghb_settings_get_string(ud->settings, "SrtDir");
1160         filename = g_strdup_printf("%s/none", dir);
1161         ghb_settings_set_string(settings, "SrtFile", filename);
1162         g_free(dir);
1163         g_free(filename);
1164
1165         ghb_settings_set_int(settings, "SrtOffset", 0);
1166         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1167                                                         ghb_boolean_value_new(FALSE));
1168
1169         ghb_add_srt(ud, settings);
1170 }
1171
1172 G_MODULE_EXPORT void
1173 subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1174 {
1175         // Add the current subtitle settings to the list.
1176         GValue *settings;
1177         gboolean burned = FALSE;
1178         gint track, source;
1179
1180         g_debug("subtitle_add_clicked_cb ()");
1181
1182         track = ghb_settings_get_int(ud->settings, "SubtitleTrack");
1183
1184         settings = ghb_dict_value_new();
1185         ghb_settings_set_int(settings, "SubtitleTrack", track);
1186         source = ghb_subtitle_track_source(ud, track);
1187         ghb_settings_set_int(settings, "SubtitleSource", source);
1188         if (mustBurn(ud, settings))
1189         {
1190                 burned = TRUE;
1191         }
1192         ghb_settings_take_value(settings, "SubtitleForced",
1193                                                         ghb_boolean_value_new(FALSE));
1194         ghb_settings_take_value(settings, "SubtitleBurned",
1195                                                         ghb_boolean_value_new(burned));
1196         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1197                                                         ghb_boolean_value_new(FALSE));
1198
1199         ghb_add_subtitle(ud, settings);
1200 }
1201
1202 G_MODULE_EXPORT void
1203 subtitle_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
1204 {
1205         GtkTreeView *treeview;
1206         GtkTreePath *treepath;
1207         GtkTreeSelection *selection;
1208         GtkTreeModel *store;
1209         GtkTreeIter iter, nextIter;
1210         gint *indices;
1211         gint row;
1212         GValue *subtitle_list;
1213
1214         g_debug("subtitle_remove_clicked_cb ()");
1215         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1216         selection = gtk_tree_view_get_selection (treeview);
1217         if (gtk_tree_selection_get_selected(selection, &store, &iter))
1218         {
1219                 nextIter = iter;
1220                 if (!gtk_tree_model_iter_next(store, &nextIter))
1221                 {
1222                         nextIter = iter;
1223                         if (gtk_tree_model_get_iter_first(store, &nextIter))
1224                         {
1225                                 gtk_tree_selection_select_iter (selection, &nextIter);
1226                         }
1227                 }
1228                 else
1229                 {
1230                         gtk_tree_selection_select_iter (selection, &nextIter);
1231                 }
1232                 // Get the row number
1233                 treepath = gtk_tree_model_get_path (store, &iter);
1234                 indices = gtk_tree_path_get_indices (treepath);
1235                 row = indices[0];
1236                 gtk_tree_path_free(treepath);
1237                 // Remove the selected item
1238                 gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
1239                 // remove from subtitle settings list
1240                 if (row < 0) return;
1241                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
1242                 gtk_widget_set_sensitive(widget, TRUE);
1243                 widget = GHB_WIDGET (ud->builder, "srt_add");
1244                 gtk_widget_set_sensitive(widget, TRUE);
1245                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1246                 if (row >= ghb_array_len(subtitle_list))
1247                         return;
1248                 GValue *old = ghb_array_get_nth(subtitle_list, row);
1249                 ghb_value_free(old);
1250                 ghb_array_remove(subtitle_list, row);
1251                 ghb_live_reset(ud);
1252         }
1253 }
1254
1255 void
1256 ghb_subtitle_prune(signal_user_data_t *ud)
1257 {
1258         GtkTreeView  *tv;
1259         GtkTreeModel *tm;
1260         GtkTreeIter   ti;
1261         GValue *subtitle_list;
1262         gint count, ii;
1263         gint first_track = 0, one_burned = 0;
1264
1265         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1266         if (subtitle_list == NULL)
1267                 return;
1268         count = ghb_array_len(subtitle_list);
1269
1270         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1271         g_return_if_fail(tv != NULL);
1272         tm = gtk_tree_view_get_model(tv);
1273         for (ii = count-1; ii >= 0; ii--)
1274         {
1275                 gboolean burned;
1276                 GValue *settings;
1277
1278                 settings = ghb_array_get_nth(subtitle_list, ii);
1279                 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
1280                 if (!burned && mustBurn(ud, settings))
1281                 {
1282                         gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
1283                         gtk_list_store_remove (GTK_LIST_STORE(tm), &ti);
1284                         ghb_array_remove(subtitle_list, ii);
1285                 }
1286                 if (burned)
1287                 {
1288                         first_track = ii;
1289                         one_burned++;
1290                 }
1291         }
1292         if (one_burned)
1293         {
1294                 ghb_subtitle_exclusive_burn(ud, first_track);
1295         }
1296 }
1297
1298 void
1299 ghb_reset_subtitles(signal_user_data_t *ud, GValue *settings)
1300 {
1301         GValue *slist;
1302         GValue *subtitle;
1303         gint count, ii;
1304         gint titleindex;
1305
1306         g_debug("ghb_reset_subtitles");
1307         ghb_clear_subtitle_list(ud);
1308         titleindex = ghb_settings_combo_int(ud->settings, "title");
1309         if (titleindex < 0)
1310                 return;
1311
1312         slist = ghb_settings_get_value(settings, "subtitle_list");
1313         count = ghb_array_len(slist);
1314         for (ii = 0; ii < count; ii++)
1315         {
1316                 int source;
1317
1318                 subtitle = ghb_value_dup(ghb_array_get_nth(slist, ii));
1319                 source = ghb_settings_get_int(subtitle, "SubtitleSource");
1320                 if (source == SRTSUB)
1321                         ghb_add_srt(ud, subtitle);
1322                 else
1323                         ghb_add_subtitle(ud, subtitle);
1324         }
1325 }
1326