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