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