gtk/src/subtitlehandler.c

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