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