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 "subtitlehandler.h"
  23
  24 static void add_to_subtitle_list(signal_user_data_t *ud, GValue *settings);
  25
  26 void
  27 free_subtitle_index_list(gpointer data)
  28 {
  29         g_free(data);
  30 }
  31
  32 void
  33 free_subtitle_key(gpointer data)
  34 {
  35         if (data != NULL)
  36                 g_free(data);
  37 }
  38
  39 static gboolean
  40 mustBurn(signal_user_data_t *ud, gint track)
  41 {
  42         gint mux;
  43
  44         mux = ghb_settings_combo_int(ud->settings, "FileFormat");
  45         if (mux == HB_MUX_MP4)
  46         {
  47                 gint source;
  48
  49                 // MP4 can only handle burned vobsubs.  make sure there isn't
  50                 // already something burned in the list
  51                 source = ghb_subtitle_track_source(ud, track);
  52                 if (source == VOBSUB)
  53                 {
  54                         return TRUE;
  55                 }
  56         }
  57         return FALSE;
  58 }
  59
  60 void
  61 ghb_subtitle_exclusive_burn(signal_user_data_t *ud, gint index)
  62 {
  63         GValue *subtitle_list;
  64         GValue *settings;
  65         gint ii, count, tt;
  66         GtkTreeView  *tv;
  67         GtkTreeModel *tm;
  68         GtkTreeIter   ti;
  69         gboolean burned;
  70
  71         g_debug("ghb_subtitle_exclusive_burn");
  72         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
  73         count = ghb_array_len(subtitle_list);
  74         if (index != -1)
  75         {
  76                 burned = ghb_settings_get_boolean(ud->settings, "SubtitleForeignBurned");
  77                 if (burned && !mustBurn(ud, -1))
  78                         ghb_ui_update(ud, "SubtitleForeignBurned", ghb_boolean_value(FALSE));
  79         }
  80         for (ii = 0; ii < count; ii++)
  81         {
  82                 settings = ghb_array_get_nth(subtitle_list, ii);
  83                 tt = ghb_settings_combo_int(settings, "SubtitleTrack");
  84                 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
  85
  86                 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
  87                 g_return_if_fail(tv != NULL);
  88                 tm = gtk_tree_view_get_model(tv);
  89                 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
  90                 if (burned && ii != index && !mustBurn(ud, tt))
  91                 {
  92                         ghb_settings_set_boolean(settings, "SubtitleBurned", FALSE);
  93                         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, FALSE, -1);
  94                 }
  95         }
  96 }
  97
  98 void
  99 ghb_subtitle_exclusive_default(signal_user_data_t *ud, gint index)
 100 {
 101         GValue *subtitle_list;
 102         GValue *settings;
 103         gint ii, count;
 104         GtkTreeView  *tv;
 105         GtkTreeModel *tm;
 106         GtkTreeIter   ti;
 107         gboolean def;
 108
 109         g_debug("ghb_subtitle_exclusive_default");
 110         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 111         count = ghb_array_len(subtitle_list);
 112         if (index != -1)
 113         {
 114                 def = ghb_settings_get_boolean(ud->settings, "SubtitleForeignDefaultTrack");
 115                 if (def)
 116                         ghb_ui_update(ud, "SubtitleForeignDefaultTrack", ghb_boolean_value(FALSE));
 117         }
 118         for (ii = 0; ii < count; ii++)
 119         {
 120                 settings = ghb_array_get_nth(subtitle_list, ii);
 121                 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 122
 123                 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 124                 g_return_if_fail(tv != NULL);
 125                 tm = gtk_tree_view_get_model(tv);
 126                 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
 127                 if (def && ii != index)
 128                 {
 129
 130                         ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", FALSE);
 131                         def = FALSE;
 132                         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, FALSE, -1);
 133                 }
 134         }
 135 }
 136
 137 void
 138 ghb_add_subtitle(signal_user_data_t *ud, GValue *settings)
 139 {
 140         // Add the current subtitle settings to the list.
 141         GValue *subtitle_list;
 142         gint count;
 143         gboolean burned;
 144
 145         g_debug("ghb_add_subtitle ()");
 146
 147         // Only allow up to 8 subtitle entries
 148         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 149         if (subtitle_list == NULL)
 150         {
 151                 subtitle_list = ghb_array_value_new(8);
 152                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 153         }
 154         count = ghb_array_len(subtitle_list);
 155         ghb_array_append(subtitle_list, settings);
 156         add_to_subtitle_list(ud, settings);
 157
 158         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 159         if (burned)
 160                 ghb_subtitle_exclusive_burn(ud, count);
 161 }
 162
 163 static void
 164 add_all_pref_subtitles(signal_user_data_t *ud)
 165 {
 166         const GValue *pref_subtitle;
 167         GValue *subtitle;
 168         gint count, ii, track;
 169         char *lang;
 170
 171         pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
 172         count = ghb_array_len(pref_subtitle);
 173         for (ii = 0; ii < count; ii++)
 174         {
 175                 subtitle = ghb_value_dup(ghb_array_get_nth(pref_subtitle, ii));
 176                 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
 177                 // If there are multiple subtitles using the same language, then
 178                 // select sequential tracks for each.  The hash keeps track
 179                 // of the tracks used for each language.
 180                 track = ghb_find_pref_subtitle_track(lang);
 181                 g_free(lang);
 182                 if (track >= -1)
 183                 {
 184                         // Add to subtitle list
 185                         ghb_settings_set_int(subtitle, "SubtitleTrack", track);
 186                         ghb_add_subtitle(ud, subtitle);
 187                 }
 188         }
 189 }
 190
 191 void
 192 ghb_set_pref_subtitle(gint titleindex, signal_user_data_t *ud)
 193 {
 194         gint track;
 195         GHashTable *track_indices;
 196         char *lang;
 197
 198         const GValue *pref_subtitle;
 199         GValue *subtitle;
 200         gint count, ii;
 201
 202         g_debug("ghb_set_pref_subtitle %d", titleindex);
 203         track_indices = g_hash_table_new_full(g_str_hash, g_str_equal,
 204                                                                                         NULL, free_subtitle_index_list);
 205
 206         ghb_ui_update(ud, "SubtitleTrack", ghb_int_value(0));
 207
 208         // Clear the subtitle list
 209         ghb_clear_subtitle_list(ud);
 210         if (titleindex < 0)
 211         {
 212                 add_all_pref_subtitles(ud);
 213                 return;
 214         }
 215
 216         // Find "best" subtitle based on subtitle preferences
 217         pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
 218
 219         count = ghb_array_len(pref_subtitle);
 220         for (ii = 0; ii < count; ii++)
 221         {
 222                 subtitle = ghb_array_get_nth(pref_subtitle, ii);
 223                 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
 224                 // If there are multiple subtitles using the same language, then
 225                 // select sequential tracks for each.  The hash keeps track
 226                 // of the tracks used for each language.
 227                 track = ghb_find_subtitle_track(titleindex, lang, track_indices);
 228                 g_free(lang);
 229                 if (track >= -1)
 230                 {
 231                         GValue *dup = ghb_value_dup(subtitle);
 232                         ghb_settings_set_int(dup, "SubtitleTrack", track);
 233                         ghb_add_subtitle(ud, dup);
 234                 }
 235         }
 236         g_hash_table_destroy(track_indices);
 237 }
 238
 239 gint
 240 ghb_selected_subtitle_row(signal_user_data_t *ud)
 241 {
 242         GtkTreeView *treeview;
 243         GtkTreePath *treepath;
 244         GtkTreeSelection *selection;
 245         GtkTreeModel *store;
 246         GtkTreeIter iter;
 247         gint *indices;
 248         gint row = -1;
 249
 250         g_debug("ghb_selected_subtitle_row ()");
 251         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 252         selection = gtk_tree_view_get_selection (treeview);
 253         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 254         {
 255                 // Get the row number
 256                 treepath = gtk_tree_model_get_path (store, &iter);
 257                 indices = gtk_tree_path_get_indices (treepath);
 258                 row = indices[0];
 259                 gtk_tree_path_free(treepath);
 260         }
 261         return row;
 262 }
 263
 264 GValue*
 265 ghb_selected_subtitle_settings(signal_user_data_t *ud)
 266 {
 267         GtkTreeView *treeview;
 268         GtkTreePath *treepath;
 269         GtkTreeSelection *selection;
 270         GtkTreeModel *store;
 271         GtkTreeIter iter;
 272         gint *indices;
 273         gint row;
 274         GValue *settings = NULL;
 275         const GValue *subtitle_list;
 276
 277         g_debug("get_selected_settings ()");
 278         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 279         selection = gtk_tree_view_get_selection (treeview);
 280         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 281         {
 282                 // Get the row number
 283                 treepath = gtk_tree_model_get_path (store, &iter);
 284                 indices = gtk_tree_path_get_indices (treepath);
 285                 row = indices[0];
 286                 gtk_tree_path_free(treepath);
 287                 // find subtitle settings
 288                 if (row < 0) return NULL;
 289                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 290                 if (row >= ghb_array_len(subtitle_list))
 291                         return NULL;
 292                 settings = ghb_array_get_nth(subtitle_list, row);
 293         }
 294         return settings;
 295 }
 296
 297 G_MODULE_EXPORT void
 298 subtitle_forced_toggled_cb(
 299         GtkCellRendererToggle *cell,
 300         gchar                 *path,
 301         signal_user_data_t    *ud)
 302 {
 303         GtkTreeView  *tv;
 304         GtkTreeModel *tm;
 305         GtkTreeIter   ti;
 306         gboolean      active;
 307         gint          row;
 308         GtkTreePath  *tp;
 309         gint *indices;
 310         GValue *subtitle_list, *settings;
 311         gint source, track;
 312
 313         g_debug("forced toggled");
 314         tp = gtk_tree_path_new_from_string (path);
 315         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 316         g_return_if_fail(tv != NULL);
 317         tm = gtk_tree_view_get_model(tv);
 318         g_return_if_fail(tm != NULL);
 319         gtk_tree_model_get_iter(tm, &ti, tp);
 320         gtk_tree_model_get(tm, &ti, 1, &active, -1);
 321         active ^= 1;
 322
 323         // Get the row number
 324         indices = gtk_tree_path_get_indices (tp);
 325         row = indices[0];
 326         gtk_tree_path_free(tp);
 327
 328         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 329
 330         if (row < 0 || row >= ghb_array_len(subtitle_list))
 331                 return;
 332
 333         settings = ghb_array_get_nth(subtitle_list, row);
 334         track = ghb_settings_combo_int(settings, "SubtitleTrack");
 335
 336         source = ghb_subtitle_track_source(ud, track);
 337         if (source != VOBSUB)
 338                 return;
 339
 340         ghb_settings_set_boolean(settings, "SubtitleForced", active);
 341         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 1, active, -1);
 342 }
 343
 344 G_MODULE_EXPORT void
 345 subtitle_burned_toggled_cb(
 346         GtkCellRendererToggle *cell,
 347         gchar                 *path,
 348         signal_user_data_t    *ud)
 349 {
 350         GtkTreeView  *tv;
 351         GtkTreeModel *tm;
 352         GtkTreeIter   ti;
 353         GtkTreePath  *tp;
 354         gboolean      active;
 355         gint          row;
 356         gint *indices;
 357         GValue *subtitle_list;
 358         gint count, track, source;
 359         GValue *settings;
 360
 361         g_debug("burned toggled");
 362         tp = gtk_tree_path_new_from_string (path);
 363         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 364         g_return_if_fail(tv != NULL);
 365         tm = gtk_tree_view_get_model(tv);
 366         g_return_if_fail(tm != NULL);
 367         gtk_tree_model_get_iter(tm, &ti, tp);
 368         gtk_tree_model_get(tm, &ti, 2, &active, -1);
 369         active ^= 1;
 370
 371         // Get the row number
 372         indices = gtk_tree_path_get_indices (tp);
 373         row = indices[0];
 374         gtk_tree_path_free(tp);
 375
 376         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 377         count = ghb_array_len(subtitle_list);
 378         if (row < 0 || row >= count)
 379                 return;
 380
 381         settings = ghb_array_get_nth(subtitle_list, row);
 382         track = ghb_settings_combo_int(settings, "SubtitleTrack");
 383
 384         source = ghb_subtitle_track_source(ud, track);
 385         if (source != VOBSUB)
 386                 return;
 387
 388         if (!active && mustBurn(ud, track))
 389                 return;
 390
 391         ghb_settings_set_boolean(settings, "SubtitleBurned", active);
 392
 393         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, active, -1);
 394         // Unburn the rest
 395         if (active)
 396                 ghb_subtitle_exclusive_burn(ud, row);
 397 }
 398
 399 G_MODULE_EXPORT void
 400 subtitle_default_toggled_cb(
 401         GtkCellRendererToggle *cell,
 402         gchar                 *path,
 403         signal_user_data_t    *ud)
 404 {
 405         GtkTreeView  *tv;
 406         GtkTreeModel *tm;
 407         GtkTreeIter   ti;
 408         GtkTreePath  *tp;
 409         gboolean      active;
 410         gint          row;
 411         gint *indices;
 412         GValue *subtitle_list;
 413         gint count, track;
 414         GValue *settings;
 415
 416         g_debug("default toggled");
 417         tp = gtk_tree_path_new_from_string (path);
 418         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 419         g_return_if_fail(tv != NULL);
 420         tm = gtk_tree_view_get_model(tv);
 421         g_return_if_fail(tm != NULL);
 422         gtk_tree_model_get_iter(tm, &ti, tp);
 423         gtk_tree_model_get(tm, &ti, 3, &active, -1);
 424         active ^= 1;
 425
 426         // Get the row number
 427         indices = gtk_tree_path_get_indices (tp);
 428         row = indices[0];
 429         gtk_tree_path_free(tp);
 430
 431         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 432         count = ghb_array_len(subtitle_list);
 433         if (row < 0 || row >= count)
 434                 return;
 435
 436         settings = ghb_array_get_nth(subtitle_list, row);
 437         track = ghb_settings_combo_int(settings, "SubtitleTrack");
 438
 439         ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", active);
 440
 441         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, active, -1);
 442         // allow only one default
 443         ghb_subtitle_exclusive_default(ud, row);
 444 }
 445
 446 static void
 447 subtitle_list_refresh_selected(signal_user_data_t *ud)
 448 {
 449         GtkTreeView *treeview;
 450         GtkTreePath *treepath;
 451         GtkTreeSelection *selection;
 452         GtkTreeModel *store;
 453         GtkTreeIter iter;
 454         gint *indices;
 455         gint row;
 456         GValue *settings = NULL;
 457         const GValue *subtitle_list;
 458
 459         g_debug("subtitle_list_refresh_selected ()");
 460         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 461         selection = gtk_tree_view_get_selection (treeview);
 462         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 463         {
 464                 const gchar *track, *source;
 465                 gboolean forced, burned, def;
 466                 gchar *s_track;
 467                 gint i_track;
 468
 469                 // Get the row number
 470                 treepath = gtk_tree_model_get_path (store, &iter);
 471                 indices = gtk_tree_path_get_indices (treepath);
 472                 row = indices[0];
 473                 gtk_tree_path_free(treepath);
 474                 // find audio settings
 475                 if (row < 0) return;
 476                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 477                 if (row >= ghb_array_len(subtitle_list))
 478                         return;
 479                 settings = ghb_array_get_nth(subtitle_list, row);
 480
 481                 track = ghb_settings_combo_option(settings, "SubtitleTrack");
 482                 forced = ghb_settings_get_boolean(settings, "SubtitleForced");
 483                 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 484                 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 485
 486                 s_track = ghb_settings_get_string(settings, "SubtitleTrack");
 487                 i_track = ghb_settings_get_int(settings, "SubtitleTrack");
 488                 source = ghb_subtitle_track_source_name(ud, i_track);
 489
 490                 gint i_source;
 491                 i_source = ghb_subtitle_track_source(ud, i_track);
 492                 if (i_source != VOBSUB)
 493                 {
 494                         // Force and burn only apply to VOBSUBS
 495                         forced = FALSE;
 496                         burned = FALSE;
 497                         ghb_settings_set_boolean(settings, "SubtitleForced", forced);
 498                         ghb_settings_set_boolean(settings, "SubtitleBurned", burned);
 499                 }
 500
 501                 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 502                         // These are displayed in list
 503                         0, track,
 504                         1, forced,
 505                         2, burned,
 506                         3, def,
 507                         4, source,
 508                         // These are used to set combo box values when a list item is selected
 509                         5, s_track,
 510                         -1);
 511                 g_free(s_track);
 512                 if (burned)
 513                         ghb_subtitle_exclusive_burn(ud, row);
 514         }
 515 }
 516
 517 G_MODULE_EXPORT void
 518 subtitle_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 519 {
 520         GValue *settings;
 521
 522         g_debug("subtitle_track_changed_cb ()");
 523         ghb_check_dependency(ud, widget);
 524         settings = ghb_selected_subtitle_settings(ud);
 525         if (settings != NULL)
 526         {
 527                 ghb_widget_to_setting(settings, widget);
 528                 subtitle_list_refresh_selected(ud);
 529         }
 530         ghb_live_reset(ud);
 531 }
 532
 533 void
 534 ghb_clear_subtitle_list(signal_user_data_t *ud)
 535 {
 536         GtkTreeView *treeview;
 537         GtkListStore *store;
 538         GValue *subtitle_list;
 539
 540         g_debug("clear_subtitle_list ()");
 541         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 542         if (subtitle_list == NULL)
 543         {
 544                 subtitle_list = ghb_array_value_new(8);
 545                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 546         }
 547         else
 548                 ghb_array_value_reset(subtitle_list, 8);
 549         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 550         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 551         gtk_list_store_clear (store);
 552 }
 553
 554 static void
 555 add_to_subtitle_list(
 556         signal_user_data_t *ud,
 557         GValue *settings)
 558 {
 559         GtkTreeView *treeview;
 560         GtkTreeIter iter;
 561         GtkListStore *store;
 562         GtkTreeSelection *selection;
 563         const gchar *track, *source;
 564         gboolean forced, burned, def;
 565         gchar *s_track;
 566         gint i_track;
 567
 568         g_debug("add_to_subtitle_list ()");
 569         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 570         selection = gtk_tree_view_get_selection (treeview);
 571         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 572
 573         track = ghb_settings_combo_option(settings, "SubtitleTrack");
 574         forced = ghb_settings_get_boolean(settings, "SubtitleForced");
 575         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 576         def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 577
 578         s_track = ghb_settings_get_string(settings, "SubtitleTrack");
 579         i_track = ghb_settings_get_int(settings, "SubtitleTrack");
 580         source = ghb_subtitle_track_source_name(ud, i_track);
 581
 582         gtk_list_store_append(store, &iter);
 583         gtk_list_store_set(store, &iter,
 584                 // These are displayed in list
 585                 0, track,
 586                 1, forced,
 587                 2, burned,
 588                 3, def,
 589                 4, source,
 590                 // These are used to set combo box values when a list item is selected
 591                 5, s_track,
 592                 -1);
 593         gtk_tree_selection_select_iter(selection, &iter);
 594         g_free(s_track);
 595 }
 596
 597 G_MODULE_EXPORT void
 598 subtitle_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
 599 {
 600         GtkTreeModel *store;
 601         GtkTreeIter iter;
 602         GtkWidget *widget;
 603
 604         g_debug("subtitle_list_selection_changed_cb ()");
 605         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 606         {
 607                 const gchar *track;
 608
 609                 gtk_tree_model_get(store, &iter, 5, &track, -1);
 610                 ghb_ui_update(ud, "SubtitleTrack", ghb_string_value(track));
 611
 612                 widget = GHB_WIDGET (ud->builder, "subtitle_remove");
 613                 gtk_widget_set_sensitive(widget, TRUE);
 614         }
 615 }
 616
 617 G_MODULE_EXPORT void
 618 subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
 619 {
 620         // Add the current subtitle settings to the list.
 621         GValue *settings;
 622         gint count;
 623         GValue *subtitle_list;
 624         gboolean burned = FALSE;
 625         gint track;
 626
 627         g_debug("subtitle_add_clicked_cb ()");
 628         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 629         if (subtitle_list == NULL)
 630         {
 631                 subtitle_list = ghb_array_value_new(8);
 632                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 633         }
 634         count = ghb_array_len(subtitle_list);
 635         // Don't allow more than 99
 636         // This is a had limit imposed by libhb/sync.c:GetFifoForId()
 637         if (count >= 99)
 638                 return;
 639
 640         track = ghb_settings_get_int(ud->settings, "SubtitleTrack");
 641
 642         if (mustBurn(ud, track))
 643         {
 644                 burned = TRUE;
 645         }
 646         settings = ghb_dict_value_new();
 647         ghb_settings_set_int(settings, "SubtitleTrack", track);
 648         ghb_settings_take_value(settings, "SubtitleForced",
 649                                                         ghb_boolean_value_new(FALSE));
 650         ghb_settings_take_value(settings, "SubtitleBurned",
 651                                                         ghb_boolean_value_new(burned));
 652         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
 653                                                         ghb_boolean_value_new(FALSE));
 654
 655         ghb_array_append(subtitle_list, settings);
 656         add_to_subtitle_list(ud, settings);
 657         if (burned)
 658                 ghb_subtitle_exclusive_burn(ud, count);
 659         if (count == 98)
 660         {
 661                 GtkWidget *widget;
 662                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
 663                 gtk_widget_set_sensitive(widget, FALSE);
 664         }
 665 }
 666
 667 G_MODULE_EXPORT void
 668 subtitle_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
 669 {
 670         GtkTreeView *treeview;
 671         GtkTreePath *treepath;
 672         GtkTreeSelection *selection;
 673         GtkTreeModel *store;
 674         GtkTreeIter iter, nextIter;
 675         gint *indices;
 676         gint row;
 677         GValue *subtitle_list;
 678
 679         g_debug("subtitle_remove_clicked_cb ()");
 680         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 681         selection = gtk_tree_view_get_selection (treeview);
 682         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 683         {
 684                 nextIter = iter;
 685                 if (!gtk_tree_model_iter_next(store, &nextIter))
 686                 {
 687                         nextIter = iter;
 688                         if (gtk_tree_model_get_iter_first(store, &nextIter))
 689                         {
 690                                 gtk_tree_selection_select_iter (selection, &nextIter);
 691                         }
 692                 }
 693                 else
 694                 {
 695                         gtk_tree_selection_select_iter (selection, &nextIter);
 696                 }
 697                 // Get the row number
 698                 treepath = gtk_tree_model_get_path (store, &iter);
 699                 indices = gtk_tree_path_get_indices (treepath);
 700                 row = indices[0];
 701                 gtk_tree_path_free(treepath);
 702                 // Remove the selected item
 703                 gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
 704                 // remove from subtitle settings list
 705                 if (row < 0) return;
 706                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
 707                 gtk_widget_set_sensitive(widget, TRUE);
 708                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 709                 if (row >= ghb_array_len(subtitle_list))
 710                         return;
 711                 GValue *old = ghb_array_get_nth(subtitle_list, row);
 712                 ghb_value_free(old);
 713                 ghb_array_remove(subtitle_list, row);
 714         }
 715 }
 716
 717 void
 718 ghb_subtitle_prune(signal_user_data_t *ud)
 719 {
 720         GtkTreeView  *tv;
 721         GtkTreeModel *tm;
 722         GtkTreeIter   ti;
 723         GValue *subtitle_list, *settings;
 724         gint count, ii, track;
 725         gboolean burned;
 726         gint first_track, one_burned = 0;
 727
 728         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 729         if (subtitle_list == NULL)
 730                 return;
 731         count = ghb_array_len(subtitle_list);
 732
 733         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 734         g_return_if_fail(tv != NULL);
 735         tm = gtk_tree_view_get_model(tv);
 736         for (ii = count-1; ii >= 0; ii--)
 737         {
 738                 settings = ghb_array_get_nth(subtitle_list, ii);
 739                 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 740                 track = ghb_settings_combo_int(settings, "SubtitleTrack");
 741                 if (!burned && mustBurn(ud, track))
 742                 {
 743                         gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
 744                         gtk_list_store_remove (GTK_LIST_STORE(tm), &ti);
 745                         ghb_array_remove(subtitle_list, ii);
 746                 }
 747                 if (burned)
 748                 {
 749                         first_track = ii;
 750                         one_burned++;
 751                 }
 752         }
 753         if (one_burned)
 754         {
 755                 ghb_subtitle_exclusive_burn(ud, first_track);
 756         }
 757         int mux;
 758         mux = ghb_settings_combo_int(ud->settings, "FileFormat");
 759         if (mux == HB_MUX_MP4)
 760         {
 761                 ghb_ui_update(ud, "SubtitleForeignBurned", ghb_boolean_value(TRUE));
 762                 ghb_ui_update(ud, "SubtitleForeignDefaultTrack", ghb_boolean_value(FALSE));
 763         }
 764 }
 765
 766 void
 767 ghb_reset_subtitles(signal_user_data_t *ud, GValue *settings)
 768 {
 769         GValue *slist;
 770         GValue *subtitle;
 771         gint count, ii;
 772         gint titleindex;
 773
 774         g_debug("ghb_reset_subtitles");
 775         ghb_clear_subtitle_list(ud);
 776         titleindex = ghb_settings_combo_int(ud->settings, "title");
 777         if (titleindex < 0)
 778                 return;
 779
 780         slist = ghb_settings_get_value(settings, "subtitle_list");
 781         count = ghb_array_len(slist);
 782         for (ii = 0; ii < count; ii++)
 783         {
 784                 subtitle = ghb_value_dup(ghb_array_get_nth(slist, ii));
 785                 ghb_add_subtitle(ud, subtitle);
 786         }
 787 }
 788
 789 G_MODULE_EXPORT void
 790 subtitle_foreign_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 791 {
 792         ghb_widget_to_setting(ud->settings, widget);
 793         ghb_check_dependency(ud, widget);
 794         ghb_clear_presets_selection(ud);
 795         ghb_live_reset(ud);
 796
 797         if (ghb_settings_get_boolean(ud->settings, "SubtitleForeignBurned"))
 798         {
 799                 ghb_subtitle_exclusive_burn(ud, -1);
 800         }
 801         if (ghb_settings_get_boolean(ud->settings, "SubtitleForeignDefaultTrack"))
 802         {
 803                 ghb_subtitle_exclusive_default(ud, -1);
 804         }
 805 }
 806