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