gtk/src/queuehandler.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * callbacks.c
   4  * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
   5  *
   6  * callbacks.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 <gdk/gdkkeysyms.h>
  16 #include <glib/gstdio.h>
  17 #include <gio/gio.h>
  18 #include "hb.h"
  19 #include "settings.h"
  20 #include "hb-backend.h"
  21 #include "values.h"
  22 #include "callbacks.h"
  23 #include "presets.h"
  24 #include "ghb-dvd.h"
  25
  26 G_MODULE_EXPORT void
  27 queue_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
  28 {
  29         GtkTreeModel *store;
  30         GtkTreeIter iter, piter;
  31
  32         g_debug("queue_list_selection_changed_cb ()");
  33         // A queue entry is made up of a parent and multiple
  34         // children that are visible when expanded.  When and entry
  35         // is selected, I want the parent to be selected.
  36         // This is purely cosmetic.
  37         if (gtk_tree_selection_get_selected(selection, &store, &iter))
  38         {
  39                 GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit");
  40                 gtk_widget_set_sensitive (widget, TRUE);
  41                 if (gtk_tree_model_iter_parent (store, &piter, &iter))
  42                 {
  43                         GtkTreePath *path;
  44                         GtkTreeView *treeview;
  45
  46                         gtk_tree_selection_select_iter (selection, &piter);
  47                         path = gtk_tree_model_get_path (store, &piter);
  48                         treeview = gtk_tree_selection_get_tree_view (selection);
  49                         // Make the parent visible in scroll window if it is not.
  50                         gtk_tree_view_scroll_to_cell (treeview, path, NULL, FALSE, 0, 0);
  51                         gtk_tree_path_free(path);
  52                 }
  53         }
  54         else
  55         {
  56                 GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit");
  57                 gtk_widget_set_sensitive (widget, FALSE);
  58         }
  59 }
  60
  61 static void
  62 add_to_queue_list(signal_user_data_t *ud, GValue *settings, GtkTreeIter *piter)
  63 {
  64         GtkTreeView *treeview;
  65         GtkTreeIter iter;
  66         GtkTreeStore *store;
  67         gchar *info;
  68         gint status;
  69         GtkTreeIter citer;
  70         gchar *dest, *preset, *vol_name, *basename;
  71         const gchar *vcodec, *container;
  72         gchar *fps, *vcodec_abbr;
  73         gint title, start_chapter, end_chapter, width, height;
  74         gint source_width, source_height;
  75         gboolean pass2, keep_aspect, vqtype, turbo;
  76         gint pic_par;
  77         gboolean tweaks;
  78         gchar *escape;
  79
  80         g_debug("update_queue_list ()");
  81         if (settings == NULL) return;
  82         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
  83         store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
  84
  85         tweaks = ghb_settings_get_boolean(settings, "allow_tweaks");
  86         title = ghb_settings_get_int(settings, "titlenum");
  87         start_chapter = ghb_settings_get_int(settings, "start_chapter");
  88         end_chapter = ghb_settings_get_int(settings, "end_chapter");
  89         pass2 = ghb_settings_get_boolean(settings, "VideoTwoPass");
  90         vol_name = ghb_settings_get_string(settings, "volume_label");
  91         dest = ghb_settings_get_string(settings, "destination");
  92         basename = g_path_get_basename(dest);
  93         escape = g_markup_escape_text(basename, -1);
  94         info = g_strdup_printf
  95         (
  96                 "<big><b>%s</b></big> "
  97                 "<small>(Title %d, Chapters %d through %d, %d Video %s)"
  98                 " --> %s</small>",
  99                  vol_name, title, start_chapter, end_chapter,
 100                  pass2 ? 2:1, pass2 ? "Passes":"Pass", escape
 101         );
 102         g_free(basename);
 103         g_free(escape);
 104
 105         if (piter)
 106                 iter = *piter;
 107         else
 108                 gtk_tree_store_append(store, &iter, NULL);
 109
 110         gtk_tree_store_set(store, &iter, 1, info, 2, "hb-queue-delete", -1);
 111         g_free(info);
 112         status = ghb_settings_get_int(settings, "job_status");
 113         switch (status)
 114         {
 115                 case GHB_QUEUE_PENDING:
 116                         gtk_tree_store_set(store, &iter, 0, "hb-queue-job", -1);
 117                         break;
 118                 case GHB_QUEUE_CANCELED:
 119                         gtk_tree_store_set(store, &iter, 0, "hb-canceled", -1);
 120                         break;
 121                 case GHB_QUEUE_RUNNING:
 122                         gtk_tree_store_set(store, &iter, 0, "hb-working0", -1);
 123                         break;
 124                 case GHB_QUEUE_DONE:
 125                         gtk_tree_store_set(store, &iter, 0, "hb-complete", -1);
 126                         break;
 127                 default:
 128                         gtk_tree_store_set(store, &iter, 0, "hb-queue-job", -1);
 129                         break;
 130         }
 131
 132         GString *str = g_string_new("");
 133         gboolean markers;
 134         gboolean preset_modified;
 135         gint mux;
 136         const GValue *path;
 137
 138         container = ghb_settings_combo_option(settings, "FileFormat");
 139         mux = ghb_settings_combo_int(settings, "FileFormat");
 140         preset_modified = ghb_settings_get_boolean(settings, "preset_modified");
 141         path = ghb_settings_get_value(settings, "preset");
 142         preset = ghb_preset_path_string(path);
 143         markers = ghb_settings_get_boolean(settings, "ChapterMarkers");
 144
 145         if (preset_modified)
 146                 g_string_append_printf(str,
 147                         "<b>Modified Preset Based On:</b> <small>%s</small>\n",
 148                         preset);
 149         else
 150                 g_string_append_printf(str,
 151                         "<b>Preset:</b> <small>%s</small>\n",
 152                         preset);
 153
 154         if (markers)
 155         {
 156                 g_string_append_printf(str,
 157                         "<b>Format:</b> <small>%s Container, Chapter Markers</small>\n",
 158                         container);
 159         }
 160         else
 161         {
 162                 g_string_append_printf(str,
 163                         "<b>Format:</b> <small>%s Container</small>\n", container);
 164         }
 165         if (mux == HB_MUX_MP4)
 166         {
 167                 gboolean ipod, http, large;
 168
 169                 ipod = ghb_settings_get_boolean(settings, "Mp4iPodCompatible");
 170                 http = ghb_settings_get_boolean(settings, "Mp4HttpOptimize");
 171                 large = ghb_settings_get_boolean(settings, "Mp4LargeFile");
 172                 if (http || ipod || large)
 173                 {
 174                         g_string_append_printf(str, "<b>MP4 Options:</b><small>");
 175                         if (ipod)
 176                                 g_string_append_printf(str, " - iPod 5G Support");
 177                         if (http)
 178                                 g_string_append_printf(str, " - Web Optimized");
 179                         if (large)
 180                                 g_string_append_printf(str, " - Large File Size (>4GB)");
 181                         g_string_append_printf(str, "</small>\n");
 182                 }
 183         }
 184         escape = g_markup_escape_text(dest, -1);
 185         g_string_append_printf(str,
 186                 "<b>Destination:</b> <small>%s</small>\n", escape);
 187
 188         width = ghb_settings_get_int(settings, "scale_width");
 189         height = ghb_settings_get_int(settings, "scale_height");
 190         pic_par = ghb_settings_combo_int(settings, "PicturePAR");
 191         keep_aspect = ghb_settings_get_boolean(settings, "PictureKeepRatio");
 192
 193         gchar *aspect_desc;
 194         switch (pic_par)
 195         {
 196         case 0:
 197         {
 198                 if (keep_aspect)
 199                 {
 200                         aspect_desc = "(Aspect Preserved)";
 201                 }
 202                 else
 203                 {
 204                         aspect_desc = "(Aspect Lost)";
 205                 }
 206         } break;
 207
 208         case 1:
 209         {
 210                 aspect_desc = "(Strict Anamorphic)";
 211         } break;
 212
 213         case 2:
 214         {
 215                 aspect_desc = "(Loose Anamorphic)";
 216         } break;
 217
 218         case 3:
 219         {
 220                 aspect_desc = "(Custom Anamorphic)";
 221         } break;
 222
 223         default:
 224         {
 225                 aspect_desc = "(Unknown)";
 226         } break;
 227         }
 228         vqtype = ghb_settings_get_boolean(settings, "vquality_type_constant");
 229
 230         gchar *vq_desc = "Error";
 231         gchar *vq_units = "";
 232         gchar *vqstr;
 233         gdouble vqvalue;
 234         if (!vqtype)
 235         {
 236                 vqtype = ghb_settings_get_boolean(settings, "vquality_type_target");
 237                 if (!vqtype)
 238                 {
 239                         // Has to be bitrate
 240                         vqvalue = ghb_settings_get_int(settings, "VideoAvgBitrate");
 241                         vq_desc = "Bitrate:";
 242                         vq_units = "kbps";
 243                 }
 244                 else
 245                 {
 246                         // Target file size
 247                         vqvalue = ghb_settings_get_int(settings, "VideoTargetSize");
 248                         vq_desc = "Target Size:";
 249                         vq_units = "MB";
 250                 }
 251                 vqstr = g_strdup_printf("%d", (gint)vqvalue);
 252         }
 253         else
 254         {
 255                 // Constant quality
 256                 vqvalue = ghb_settings_get_double(settings, "VideoQualitySlider");
 257                 vq_desc = "Constant Quality:";
 258                 vqstr = g_strdup_printf("%d", (gint)vqvalue);
 259                 vq_units = "(crf)";
 260         }
 261         fps = ghb_settings_get_string(settings, "VideoFramerate");
 262         if (strcmp("source", fps) == 0)
 263         {
 264                 g_free(fps);
 265                 if (ghb_settings_combo_int(settings, "PictureDetelecine"))
 266                         fps = g_strdup("Same As Source (vfr detelecine)");
 267                 else
 268                         fps = g_strdup("Same As Source (variable)");
 269         }
 270         else
 271         {
 272                 gchar *tmp;
 273                 tmp = g_strdup_printf("%s (constant frame rate)", fps);
 274                 g_free(fps);
 275                 fps = tmp;
 276         }
 277         vcodec = ghb_settings_combo_option(settings, "VideoEncoder");
 278         vcodec_abbr = ghb_settings_get_string(settings, "VideoEncoder");
 279         source_width = ghb_settings_get_int(settings, "source_width");
 280         source_height = ghb_settings_get_int(settings, "source_height");
 281         g_string_append_printf(str,
 282                 "<b>Picture:</b> Source: <small>%d x %d, Output %d x %d %s</small>\n",
 283                  source_width, source_height, width, height, aspect_desc);
 284
 285         gint decomb, detel;
 286         gboolean filters = FALSE;
 287
 288         decomb = ghb_settings_combo_int(settings, "PictureDecomb");
 289         g_string_append_printf(str, "<b>Filters:</b><small>");
 290         detel = ghb_settings_combo_int(settings, "PictureDetelecine");
 291         if (detel)
 292         {
 293                 g_string_append_printf(str, " - Detelecine");
 294                 if (detel == 1)
 295                 {
 296                         gchar *cust;
 297                         cust = ghb_settings_get_string(settings, "PictureDetelecineCustom");
 298                         g_string_append_printf(str, ": %s", cust);
 299                         g_free(cust);
 300                 }
 301                 filters = TRUE;
 302         }
 303         if (decomb)
 304         {
 305                 g_string_append_printf(str, " - Decomb");
 306                 if (decomb == 1)
 307                 {
 308                         gchar *cust;
 309                         cust = ghb_settings_get_string(settings, "PictureDecombCustom");
 310                         g_string_append_printf(str, ": %s", cust);
 311                         g_free(cust);
 312                 }
 313                 filters = TRUE;
 314         }
 315         else
 316         {
 317                 gint deint = ghb_settings_combo_int(settings, "PictureDeinterlace");
 318                 if (deint)
 319                 {
 320                         if (deint == 1)
 321                         {
 322                                 gchar *cust = ghb_settings_get_string(settings,
 323                                                                                                 "PictureDeinterlaceCustom");
 324                                 g_string_append_printf(str, " - Deinterlace: %s", cust);
 325                                 g_free(cust);
 326                         }
 327                         else
 328                         {
 329                                 const gchar *opt = ghb_settings_combo_option(settings,
 330                                                                                                         "PictureDeinterlace");
 331                                 g_string_append_printf(str, " - Deinterlace: %s", opt);
 332                         }
 333                         filters = TRUE;
 334                 }
 335         }
 336         gint denoise = ghb_settings_combo_int(settings, "PictureDenoise");
 337         if (denoise)
 338         {
 339                 if (denoise == 1)
 340                 {
 341                         gchar *cust = ghb_settings_get_string(settings,
 342                                                                                                         "PictureDenoiseCustom");
 343                         g_string_append_printf(str, " - Denoise: %s", cust);
 344                         g_free(cust);
 345                 }
 346                 else
 347                 {
 348                         const gchar *opt = ghb_settings_combo_option(settings,
 349                                                                                                         "PictureDenoise");
 350                         g_string_append_printf(str, " - Denoise: %s", opt);
 351                 }
 352                 filters = TRUE;
 353         }
 354         gint deblock = ghb_settings_get_int(settings, "PictureDeblock");
 355         if (deblock >= 5)
 356         {
 357                 g_string_append_printf(str, " - Deblock (%d)", deblock);
 358                 filters = TRUE;
 359         }
 360         if (ghb_settings_get_boolean(settings, "VideoGrayScale"))
 361         {
 362                 g_string_append_printf(str, " - Grayscale");
 363                 filters = TRUE;
 364         }
 365         if (!filters)
 366                 g_string_append_printf(str, " None");
 367         g_string_append_printf(str, "</small>\n");
 368
 369         g_string_append_printf(str,
 370                 "<b>Video:</b> <small>%s, Framerate: %s, %s %s%s</small>\n",
 371                  vcodec, fps, vq_desc, vqstr, vq_units);
 372
 373         turbo = ghb_settings_get_boolean(settings, "VideoTurboTwoPass");
 374         if (turbo)
 375         {
 376                 g_string_append_printf(str, "<b>Turbo:</b> <small>On</small>\n");
 377         }
 378         if (strcmp(vcodec_abbr, "x264") == 0)
 379         {
 380                 gchar *x264opts = ghb_build_x264opts_string(settings);
 381                 g_string_append_printf(str,
 382                         "<b>x264 Options:</b> <small>%s</small>\n", x264opts);
 383                 g_free(x264opts);
 384         }
 385         // Add the audios
 386         gint count, ii;
 387         const GValue *audio_list;
 388
 389         audio_list = ghb_settings_get_value(settings, "audio_list");
 390         count = ghb_array_len(audio_list);
 391         for (ii = 0; ii < count; ii++)
 392         {
 393                 gchar *bitrate, *samplerate, *track;
 394                 const gchar *acodec, *mix;
 395                 GValue *asettings;
 396
 397                 asettings = ghb_array_get_nth(audio_list, ii);
 398
 399                 acodec = ghb_settings_combo_option(asettings, "AudioEncoder");
 400                 bitrate = ghb_settings_get_string(asettings, "AudioBitrate");
 401                 samplerate = ghb_settings_get_string(asettings, "AudioSamplerate");
 402                 if (strcmp("source", samplerate) == 0)
 403                 {
 404                         g_free(samplerate);
 405                         samplerate = g_strdup("Same As Source");
 406                 }
 407                 track = ghb_settings_get_string(asettings, "AudioTrackDescription");
 408                 mix = ghb_settings_combo_option(asettings, "AudioMixdown");
 409                 if (count == 1)
 410                         g_string_append_printf(str, "<b>Audio:</b>");
 411                 else if (ii == 0)
 412                         g_string_append_printf(str, "<b>Audio:</b>\n");
 413                 if (count != 1)
 414                         g_string_append_printf(str, "\t");
 415
 416                 g_string_append_printf(str,
 417                         "<small> %s, Encoder: %s, Mixdown: %s, SampleRate: %s, Bitrate: %s</small>\n",
 418                          track, acodec, mix, samplerate, bitrate);
 419                 g_free(track);
 420                 g_free(bitrate);
 421                 g_free(samplerate);
 422         }
 423
 424         // Add the audios
 425         const GValue *sub_list;
 426
 427         sub_list = ghb_settings_get_value(settings, "subtitle_list");
 428         count = ghb_array_len(sub_list);
 429         for (ii = 0; ii < count; ii++)
 430         {
 431                 GValue *settings;
 432                 gchar *track;
 433                 gboolean force, burn, def;
 434                 gint source;
 435
 436                 settings = ghb_array_get_nth(sub_list, ii);
 437                 track = ghb_settings_get_string(settings, "SubtitleTrackDescription");
 438                 source = ghb_settings_get_int(settings, "SubtitleSource");
 439                 force = ghb_settings_get_boolean(settings, "SubtitleForced");
 440                 burn = ghb_settings_get_boolean(settings, "SubtitleBurned");
 441                 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 442                 if (count == 1)
 443                         g_string_append_printf(str, "<b>Subtitle:</b>");
 444                 else if (ii == 0)
 445                         g_string_append_printf(str, "<b>Subtitles:</b>\n");
 446                 if (count != 1)
 447                         g_string_append_printf(str, "\t");
 448
 449                 if (source != SRTSUB)
 450                 {
 451                         g_string_append_printf(str,
 452                                 "<small> %s%s%s%s</small>",
 453                                 track,
 454                                 force ? " (Force)":"",
 455                                 burn  ? " (Burn)":"",
 456                                 def   ? " (Default)":""
 457                         );
 458                 }
 459                 if (ii < count-1)
 460                         g_string_append_printf(str, "\n");
 461                 g_free(track);
 462         }
 463
 464         info = g_string_free(str, FALSE);
 465         gtk_tree_store_append(store, &citer, &iter);
 466         gtk_tree_store_set(store, &citer, 1, info, -1);
 467         g_free(info);
 468         g_free(fps);
 469         g_free(vcodec_abbr);
 470         g_free(vol_name);
 471         g_free(dest);
 472         g_free(preset);
 473 }
 474
 475 void
 476 audio_list_refresh(signal_user_data_t *ud)
 477 {
 478         GtkTreeView *treeview;
 479         GtkTreeIter iter;
 480         GtkListStore *store;
 481         gboolean done;
 482         gint row = 0;
 483         const GValue *audio_list;
 484
 485         g_debug("ghb_audio_list_refresh ()");
 486         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 487         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 488         if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
 489         {
 490                 do
 491                 {
 492                         const gchar *track, *codec, *br, *sr, *mix;
 493                         gchar *drc, *s_track, *s_codec, *s_br, *s_sr, *s_mix;
 494                         gdouble s_drc;
 495                         GValue *asettings;
 496
 497                         audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 498                         if (row >= ghb_array_len(audio_list))
 499                                 return;
 500                         asettings = ghb_array_get_nth(audio_list, row);
 501
 502                         track = ghb_settings_combo_option(asettings, "AudioTrack");
 503                         codec = ghb_settings_combo_option(asettings, "AudioEncoder");
 504                         br = ghb_settings_combo_option(asettings, "AudioBitrate");
 505                         sr = ghb_settings_combo_option(asettings, "AudioSamplerate");
 506                         mix = ghb_settings_combo_option(asettings, "AudioMixdown");
 507
 508                         s_track = ghb_settings_get_string(asettings, "AudioTrack");
 509                         s_codec = ghb_settings_get_string(asettings, "AudioEncoder");
 510                         s_br = ghb_settings_get_string(asettings, "AudioBitrate");
 511                         s_sr = ghb_settings_get_string(asettings, "AudioSamplerate");
 512                         s_mix = ghb_settings_get_string(asettings, "AudioMixdown");
 513                         s_drc = ghb_settings_get_double(asettings, "AudioTrackDRCSlider");
 514                         if (s_drc < 1.0)
 515                                 drc = g_strdup("Off");
 516                         else
 517                                 drc = g_strdup_printf("%.1f", s_drc);
 518
 519                         gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 520                                 // These are displayed in list
 521                                 0, track,
 522                                 1, codec,
 523                                 2, br,
 524                                 3, sr,
 525                                 4, mix,
 526                                 5, drc,
 527                                 // These are used to set combo values when an item is selected
 528                                 6, s_track,
 529                                 7, s_codec,
 530                                 8, s_br,
 531                                 9, s_sr,
 532                                 10, s_mix,
 533                                 11, s_drc,
 534                                 -1);
 535                         g_free(drc);
 536                         g_free(s_track);
 537                         g_free(s_codec);
 538                         g_free(s_br);
 539                         g_free(s_sr);
 540                         g_free(s_mix);
 541                         done = !gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
 542                         row++;
 543                 } while (!done);
 544         }
 545 }
 546
 547 static gboolean
 548 validate_settings(signal_user_data_t *ud)
 549 {
 550         // Check to see if the dest file exists or is
 551         // already in the queue
 552         gchar *message, *dest;
 553         gint count, ii;
 554         gint titleindex;
 555
 556         titleindex = ghb_settings_combo_int(ud->settings, "title");
 557         if (titleindex < 0) return FALSE;
 558         dest = ghb_settings_get_string(ud->settings, "destination");
 559         count = ghb_array_len(ud->queue);
 560         for (ii = 0; ii < count; ii++)
 561         {
 562                 GValue *js;
 563                 gchar *filename;
 564
 565                 js = ghb_array_get_nth(ud->queue, ii);
 566                 filename = ghb_settings_get_string(js, "destination");
 567                 if (strcmp(dest, filename) == 0)
 568                 {
 569                         message = g_strdup_printf(
 570                                                 "Destination: %s\n\n"
 571                                                 "Another queued job has specified the same destination.\n"
 572                                                 "Do you want to overwrite?",
 573                                                 dest);
 574                         if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Overwrite"))
 575                         {
 576                                 g_free(filename);
 577                                 g_free(dest);
 578                                 g_free(message);
 579                                 return FALSE;
 580                         }
 581                         g_free(message);
 582                         break;
 583                 }
 584                 g_free(filename);
 585         }
 586         gchar *destdir = g_path_get_dirname(dest);
 587         if (!g_file_test(destdir, G_FILE_TEST_IS_DIR))
 588         {
 589                 message = g_strdup_printf(
 590                                         "Destination: %s\n\n"
 591                                         "This is not a valid directory.",
 592                                         destdir);
 593                 ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL);
 594                 g_free(dest);
 595                 g_free(message);
 596                 g_free(destdir);
 597                 return FALSE;
 598         }
 599 #if !defined(_WIN32)
 600         // This doesn't work properly on windows
 601         if (g_access(destdir, R_OK|W_OK) != 0)
 602         {
 603                 message = g_strdup_printf(
 604                                         "Destination: %s\n\n"
 605                                         "Can not read or write the directory.",
 606                                         destdir);
 607                 ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL);
 608                 g_free(dest);
 609                 g_free(message);
 610                 g_free(destdir);
 611                 return FALSE;
 612         }
 613 #endif
 614         GFile *gfile;
 615         GFileInfo *info;
 616         guint64 size;
 617         gchar *resolved = ghb_resolve_symlink(destdir);
 618
 619         gfile = g_file_new_for_path(resolved);
 620         info = g_file_query_filesystem_info(gfile,
 621                                                 G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, NULL);
 622         if (info != NULL)
 623         {
 624                 if (g_file_info_has_attribute(info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE))
 625                 {
 626                         size = g_file_info_get_attribute_uint64(info,
 627                                                                         G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
 628
 629                         gint64 fsize = (guint64)10 * 1024 * 1024 * 1024;
 630                         if (size < fsize)
 631                         {
 632                                 message = g_strdup_printf(
 633                                                         "Destination filesystem is almost full: %uM free\n\n"
 634                                                         "Encode may be incomplete if you proceed.\n",
 635                                                         (guint)(size / (1024L*1024L)));
 636                                 if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Proceed"))
 637                                 {
 638                                         g_free(dest);
 639                                         g_free(message);
 640                                         return FALSE;
 641                                 }
 642                                 g_free(message);
 643                         }
 644                 }
 645                 g_object_unref(info);
 646         }
 647         g_object_unref(gfile);
 648         g_free(resolved);
 649         g_free(destdir);
 650         if (g_file_test(dest, G_FILE_TEST_EXISTS))
 651         {
 652                 message = g_strdup_printf(
 653                                         "Destination: %s\n\n"
 654                                         "File already exists.\n"
 655                                         "Do you want to overwrite?",
 656                                         dest);
 657                 if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Overwrite"))
 658                 {
 659                         g_free(dest);
 660                         g_free(message);
 661                         return FALSE;
 662                 }
 663                 g_free(message);
 664                 g_unlink(dest);
 665         }
 666         g_free(dest);
 667         // Validate video quality is in a reasonable range
 668         if (!ghb_validate_vquality(ud->settings))
 669         {
 670                 return FALSE;
 671         }
 672         // Validate audio settings
 673         if (!ghb_validate_audio(ud))
 674         {
 675                 return FALSE;
 676         }
 677         // Validate audio settings
 678         if (!ghb_validate_subtitles(ud))
 679         {
 680                 return FALSE;
 681         }
 682         // Validate video settings
 683         if (!ghb_validate_video(ud))
 684         {
 685                 return FALSE;
 686         }
 687         // Validate filter settings
 688         if (!ghb_validate_filters(ud))
 689         {
 690                 return FALSE;
 691         }
 692         audio_list_refresh(ud);
 693         return TRUE;
 694 }
 695
 696 static gboolean
 697 queue_add(signal_user_data_t *ud)
 698 {
 699         // Add settings to the queue
 700         GValue *settings;
 701         gint titleindex;
 702         gint titlenum;
 703
 704         g_debug("queue_add ()");
 705         if (!validate_settings(ud))
 706         {
 707                 return FALSE;
 708         }
 709
 710         if (ud->queue == NULL)
 711                 ud->queue = ghb_array_value_new(32);
 712         // Make a copy of current settings to be used for the new job
 713         settings = ghb_value_dup(ud->settings);
 714         ghb_settings_set_int(settings, "job_status", GHB_QUEUE_PENDING);
 715         ghb_settings_set_int(settings, "job_unique_id", 0);
 716         titleindex = ghb_settings_combo_int(settings, "title");
 717         titlenum = ghb_get_title_number(titleindex);
 718         ghb_settings_set_int(settings, "titlenum", titlenum);
 719         ghb_array_append(ud->queue, settings);
 720         add_to_queue_list(ud, settings, NULL);
 721         ghb_save_queue(ud->queue);
 722
 723         return TRUE;
 724 }
 725
 726 G_MODULE_EXPORT void
 727 queue_add_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
 728 {
 729         g_debug("queue_add_clicked_cb ()");
 730         queue_add(ud);
 731 }
 732
 733 G_MODULE_EXPORT void
 734 queue_remove_clicked_cb(GtkWidget *widget, gchar *path, signal_user_data_t *ud)
 735 {
 736         GtkTreeView *treeview;
 737         GtkTreePath *treepath;
 738         GtkTreeModel *store;
 739         GtkTreeIter iter;
 740         gint row;
 741         gint *indices;
 742         gint unique_id;
 743         GValue *settings;
 744         gint status;
 745
 746         g_debug("queue_remove_clicked_cb ()");
 747         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
 748         store = gtk_tree_view_get_model(treeview);
 749         treepath = gtk_tree_path_new_from_string (path);
 750         if (gtk_tree_path_get_depth(treepath) > 1) return;
 751         if (gtk_tree_model_get_iter(store, &iter, treepath))
 752         {
 753                 // Find the entry in the queue
 754                 indices = gtk_tree_path_get_indices (treepath);
 755                 row = indices[0];
 756                 // Can only free the treepath After getting what I need from
 757                 // indices since this points into treepath somewhere.
 758                 gtk_tree_path_free (treepath);
 759                 if (row < 0) return;
 760                 if (row >= ghb_array_len(ud->queue))
 761                         return;
 762                 settings = ghb_array_get_nth(ud->queue, row);
 763                 status = ghb_settings_get_int(settings, "job_status");
 764                 if (status == GHB_QUEUE_RUNNING)
 765                 {
 766                         // Ask if wants to stop encode.
 767                         if (!ghb_cancel_encode(NULL))
 768                         {
 769                                 return;
 770                         }
 771                         unique_id = ghb_settings_get_int(settings, "job_unique_id");
 772                         ghb_remove_job(unique_id);
 773                 }
 774                 // Remove the selected item
 775                 gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
 776                 // Remove the corresponding item from the queue list
 777                 GValue *old = ghb_array_get_nth(ud->queue, row);
 778                 ghb_value_free(old);
 779                 ghb_array_remove(ud->queue, row);
 780                 ghb_save_queue(ud->queue);
 781         }
 782         else
 783         {
 784                 gtk_tree_path_free (treepath);
 785         }
 786 }
 787
 788 static gint
 789 find_last_finished(GValue *queue)
 790 {
 791         GValue *js;
 792         gint ii, count;
 793         gint status;
 794
 795         g_debug("find_last_finished");
 796         count = ghb_array_len(queue);
 797         for (ii = 0; ii < count; ii++)
 798         {
 799                 js = ghb_array_get_nth(queue, ii);
 800                 status = ghb_settings_get_int(js, "job_status");
 801                 if (status != GHB_QUEUE_DONE && status != GHB_QUEUE_RUNNING)
 802                 {
 803                         return ii-1;
 804                 }
 805         }
 806         return -1;
 807 }
 808
 809 // This little bit is needed to prevent the default drag motion
 810 // handler from expanding rows if you hover over them while
 811 // dragging.
 812 // Also controls where valid drop locations are
 813 G_MODULE_EXPORT gboolean
 814 queue_drag_motion_cb(
 815         GtkTreeView *tv,
 816         GdkDragContext *ctx,
 817         gint x,
 818         gint y,
 819         guint time,
 820         signal_user_data_t *ud)
 821 {
 822         GtkTreePath *path = NULL;
 823         GtkTreeViewDropPosition pos;
 824         gint *indices, row, status, finished;
 825         GValue *js;
 826         GtkTreeIter iter;
 827         GtkTreeView *srctv;
 828         GtkTreeModel *model;
 829         GtkTreeSelection *select;
 830         GtkWidget *widget;
 831
 832         widget = gtk_drag_get_source_widget(ctx);
 833         if (widget == NULL || widget != GTK_WIDGET(tv))
 834                 return TRUE;
 835
 836         // This bit checks to see if the source is allowed to be
 837         // moved.  Only pending and canceled items may be moved.
 838         srctv = GTK_TREE_VIEW(gtk_drag_get_source_widget(ctx));
 839         select = gtk_tree_view_get_selection (srctv);
 840         gtk_tree_selection_get_selected (select, &model, &iter);
 841         path = gtk_tree_model_get_path (model, &iter);
 842         indices = gtk_tree_path_get_indices(path);
 843         row = indices[0];
 844         gtk_tree_path_free(path);
 845         js = ghb_array_get_nth(ud->queue, row);
 846         status = ghb_settings_get_int(js, "job_status");
 847         if (status != GHB_QUEUE_PENDING && status != GHB_QUEUE_CANCELED)
 848         {
 849                 gdk_drag_status(ctx, 0, time);
 850                 return TRUE;
 851         }
 852
 853         // The reset checks that the destination is a valid position
 854         // in the list.  Can not move above any finished or running items
 855         gtk_tree_view_get_dest_row_at_pos (tv, x, y, &path, &pos);
 856         if (path == NULL)
 857         {
 858                 gdk_drag_status(ctx, GDK_ACTION_MOVE, time);
 859                 return TRUE;
 860         }
 861         // Don't allow *drop into*
 862         if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)
 863                 pos = GTK_TREE_VIEW_DROP_BEFORE;
 864         if (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
 865                 pos = GTK_TREE_VIEW_DROP_AFTER;
 866         // Don't allow droping int child items
 867         if (gtk_tree_path_get_depth(path) > 1)
 868         {
 869                 gtk_tree_path_up(path);
 870                 pos = GTK_TREE_VIEW_DROP_AFTER;
 871         }
 872         indices = gtk_tree_path_get_indices(path);
 873         row = indices[0];
 874         js = ghb_array_get_nth(ud->queue, row);
 875
 876         finished = find_last_finished(ud->queue);
 877         if (row < finished)
 878         {
 879                 gtk_tree_path_free(path);
 880                 gdk_drag_status(ctx, 0, time);
 881                 return TRUE;
 882         }
 883         if (pos != GTK_TREE_VIEW_DROP_AFTER &&
 884                 row == finished)
 885         {
 886                 gtk_tree_path_free(path);
 887                 gdk_drag_status(ctx, 0, time);
 888                 return TRUE;
 889         }
 890         gtk_tree_view_set_drag_dest_row(tv, path, pos);
 891         gtk_tree_path_free(path);
 892         gdk_drag_status(ctx, GDK_ACTION_MOVE, time);
 893         return TRUE;
 894 }
 895
 896 G_MODULE_EXPORT void
 897 queue_drag_cb(
 898         GtkTreeView *dstwidget,
 899         GdkDragContext *dc,
 900         gint x, gint y,
 901         GtkSelectionData *selection_data,
 902         guint info, guint t,
 903         signal_user_data_t *ud)
 904 {
 905         GtkTreePath *path = NULL;
 906         //GtkTreeModel *model;
 907         GtkTreeViewDropPosition pos;
 908         GtkTreeIter dstiter, srciter;
 909         gint *indices, row;
 910         GValue *js;
 911
 912         GtkTreeModel *dstmodel = gtk_tree_view_get_model(dstwidget);
 913
 914         g_debug("queue_drag_cb ()");
 915         // This doesn't work here for some reason...
 916         // gtk_tree_view_get_drag_dest_row(dstwidget, &path, &pos);
 917         gtk_tree_view_get_dest_row_at_pos (dstwidget, x, y, &path, &pos);
 918         // This little hack is needed because attempting to drop after
 919         // the last item gives us no path or pos.
 920         if (path == NULL)
 921         {
 922                 gint n_children;
 923
 924                 n_children = gtk_tree_model_iter_n_children(dstmodel, NULL);
 925                 if (n_children)
 926                 {
 927                         pos = GTK_TREE_VIEW_DROP_AFTER;
 928                         path = gtk_tree_path_new_from_indices(n_children-1, -1);
 929                 }
 930                 else
 931                 {
 932                         pos = GTK_TREE_VIEW_DROP_BEFORE;
 933                         path = gtk_tree_path_new_from_indices(0, -1);
 934                 }
 935         }
 936         if (path)
 937         {
 938                 if (gtk_tree_path_get_depth(path) > 1)
 939                         gtk_tree_path_up(path);
 940                 if (gtk_tree_model_get_iter (dstmodel, &dstiter, path))
 941                 {
 942                         GtkTreeIter iter;
 943                         GtkTreeView *srcwidget;
 944                         GtkTreeModel *srcmodel;
 945                         GtkTreeSelection *select;
 946                         GtkTreePath *srcpath = NULL;
 947                         GtkTreePath *dstpath = NULL;
 948
 949                         srcwidget = GTK_TREE_VIEW(gtk_drag_get_source_widget(dc));
 950                         //srcmodel = gtk_tree_view_get_model(srcwidget);
 951                         select = gtk_tree_view_get_selection (srcwidget);
 952                         gtk_tree_selection_get_selected (select, &srcmodel, &srciter);
 953
 954                         srcpath = gtk_tree_model_get_path (srcmodel, &srciter);
 955                         indices = gtk_tree_path_get_indices(srcpath);
 956                         row = indices[0];
 957                         gtk_tree_path_free(srcpath);
 958                         js = ghb_array_get_nth(ud->queue, row);
 959
 960                         switch (pos)
 961                         {
 962                                 case GTK_TREE_VIEW_DROP_BEFORE:
 963                                 case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
 964                                         gtk_tree_store_insert_before (GTK_TREE_STORE (dstmodel),
 965                                                                                                         &iter, NULL, &dstiter);
 966                                         break;
 967
 968                                 case GTK_TREE_VIEW_DROP_AFTER:
 969                                 case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
 970                                         gtk_tree_store_insert_after (GTK_TREE_STORE (dstmodel),
 971                                                                                                         &iter, NULL, &dstiter);
 972                                         break;
 973
 974                                 default:
 975                                         break;
 976                         }
 977                         // Reset job to pending
 978                         ghb_settings_set_int(js, "job_status", GHB_QUEUE_PENDING);
 979                         add_to_queue_list(ud, js, &iter);
 980
 981                         dstpath = gtk_tree_model_get_path (dstmodel, &iter);
 982                         indices = gtk_tree_path_get_indices(dstpath);
 983                         row = indices[0];
 984                         gtk_tree_path_free(dstpath);
 985                         ghb_array_insert(ud->queue, row, js);
 986
 987                         srcpath = gtk_tree_model_get_path (srcmodel, &srciter);
 988                         indices = gtk_tree_path_get_indices(srcpath);
 989                         row = indices[0];
 990                         gtk_tree_path_free(srcpath);
 991                         ghb_array_remove(ud->queue, row);
 992                         gtk_tree_store_remove (GTK_TREE_STORE (srcmodel), &srciter);
 993                         ghb_save_queue(ud->queue);
 994                 }
 995                 gtk_tree_path_free(path);
 996         }
 997 }
 998
 999 void
1000 ghb_queue_buttons_grey(signal_user_data_t *ud, gboolean working)
1001 {
1002         GtkWidget *widget;
1003         GtkAction *action;
1004         gint queue_count;
1005         gint titleindex;
1006         gboolean title_ok;
1007
1008         queue_count = ghb_array_len(ud->queue);
1009         titleindex = ghb_settings_combo_int(ud->settings, "title");
1010         title_ok = (titleindex >= 0);
1011
1012         widget = GHB_WIDGET (ud->builder, "queue_start1");
1013         gtk_widget_set_sensitive (widget, !working && (title_ok || queue_count));
1014         widget = GHB_WIDGET (ud->builder, "queue_start2");
1015         gtk_widget_set_sensitive (widget, !working && (title_ok || queue_count));
1016         action = GHB_ACTION (ud->builder, "queue_start_menu");
1017         gtk_action_set_sensitive (action, !working && (title_ok || queue_count));
1018         widget = GHB_WIDGET (ud->builder, "queue_pause1");
1019         gtk_widget_set_sensitive (widget, working);
1020         widget = GHB_WIDGET (ud->builder, "queue_pause2");
1021         gtk_widget_set_sensitive (widget, working);
1022         action = GHB_ACTION (ud->builder, "queue_pause_menu");
1023         gtk_action_set_sensitive (action, working);
1024         widget = GHB_WIDGET (ud->builder, "queue_stop");
1025         gtk_widget_set_sensitive (widget, working);
1026         action = GHB_ACTION (ud->builder, "queue_stop_menu");
1027         gtk_action_set_sensitive (action, working);
1028 }
1029
1030 G_MODULE_EXPORT void
1031 queue_list_size_allocate_cb(GtkWidget *widget, GtkAllocation *allocation, GtkCellRenderer *cell)
1032 {
1033         GtkTreeViewColumn *column;
1034         gint width;
1035
1036         column = gtk_tree_view_get_column (GTK_TREE_VIEW(widget), 0);
1037         width = gtk_tree_view_column_get_width(column);
1038         g_debug("col width %d alloc width %d", width, allocation->width);
1039         // Set new wrap-width.  Shave a little off to accomidate the icons
1040         // that share this column.
1041         if (width >= 564) // Don't allow below a certain size
1042                 g_object_set(cell, "wrap-width", width-70, NULL);
1043 }
1044
1045 G_MODULE_EXPORT void
1046 queue_start_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1047 {
1048         GValue *js;
1049         gboolean running = FALSE;
1050         gint count, ii;
1051         gint status;
1052         gint state;
1053
1054         count = ghb_array_len(ud->queue);
1055         for (ii = 0; ii < count; ii++)
1056         {
1057                 js = ghb_array_get_nth(ud->queue, ii);
1058                 status = ghb_settings_get_int(js, "job_status");
1059                 if ((status == GHB_QUEUE_RUNNING) ||
1060                         (status == GHB_QUEUE_PENDING))
1061                 {
1062                         running = TRUE;
1063                         break;
1064                 }
1065         }
1066         if (!running)
1067         {
1068                 // The queue has no running or pending jobs.
1069                 // Add current settings to the queue, then run.
1070                 if (!queue_add(ud))
1071                         return;
1072         }
1073         state = ghb_get_queue_state();
1074         if (state == GHB_STATE_IDLE)
1075         {
1076                 // Add the first pending queue item and start
1077                 ud->current_job = ghb_start_next_job(ud, TRUE);
1078         }
1079 }
1080
1081 G_MODULE_EXPORT void
1082 queue_stop_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1083 {
1084         ud->cancel_encode = TRUE;
1085         ghb_cancel_encode(NULL);
1086 }
1087
1088 G_MODULE_EXPORT void
1089 queue_pause_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1090 {
1091         ghb_pause_queue();
1092 }
1093
1094 gboolean
1095 ghb_reload_queue(signal_user_data_t *ud)
1096 {
1097         GValue *queue;
1098         gint unfinished = 0;
1099         gint count, ii;
1100         gint status;
1101         GValue *settings;
1102         gchar *message;
1103
1104         g_debug("ghb_reload_queue");
1105
1106         queue = ghb_load_queue();
1107         // Look for unfinished entries
1108         count = ghb_array_len(queue);
1109         for (ii = 0; ii < count; ii++)
1110         {
1111                 settings = ghb_array_get_nth(queue, ii);
1112                 status = ghb_settings_get_int(settings, "job_status");
1113                 if (status != GHB_QUEUE_DONE && status != GHB_QUEUE_CANCELED)
1114                 {
1115                         unfinished++;
1116                 }
1117         }
1118         if (unfinished)
1119         {
1120                 message = g_strdup_printf(
1121                                         "You have %d unfinished job%s in a saved queue.\n\n"
1122                                         "Would you like to reload %s?",
1123                                         unfinished,
1124                                         (unfinished > 1) ? "s" : "",
1125                                         (unfinished > 1) ? "them" : "it");
1126                 if (ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "No", "Yes"))
1127                 {
1128                         GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
1129                         gtk_widget_show (widget);
1130
1131                         ud->queue = queue;
1132                         // First get rid of any old items we don't want
1133                         for (ii = count-1; ii >= 0; ii--)
1134                         {
1135                                 settings = ghb_array_get_nth(queue, ii);
1136                                 status = ghb_settings_get_int(settings, "job_status");
1137                                 if (status == GHB_QUEUE_DONE || status == GHB_QUEUE_CANCELED)
1138                                 {
1139                                         GValue *old = ghb_array_get_nth(queue, ii);
1140                                         ghb_value_free(old);
1141                                         ghb_array_remove(queue, ii);
1142                                 }
1143                         }
1144                         count = ghb_array_len(queue);
1145                         for (ii = 0; ii < count; ii++)
1146                         {
1147                                 settings = ghb_array_get_nth(queue, ii);
1148                                 ghb_settings_set_int(settings, "job_unique_id", 0);
1149                                 ghb_settings_set_int(settings, "job_status", GHB_QUEUE_PENDING);
1150                                 add_to_queue_list(ud, settings, NULL);
1151                         }
1152                         ghb_queue_buttons_grey(ud, FALSE);
1153                 }
1154                 else
1155                 {
1156                         ghb_value_free(queue);
1157                         ghb_remove_queue_file();
1158                 }
1159                 g_free(message);
1160         }
1161         return FALSE;
1162 }
1163
1164 G_MODULE_EXPORT gboolean
1165 queue_key_press_cb(
1166         GtkWidget *widget,
1167         GdkEventKey *event,
1168         signal_user_data_t *ud)
1169 {
1170         GtkTreeView *treeview;
1171         GtkTreeSelection *selection;
1172         GtkTreeModel *store;
1173         GtkTreeIter iter;
1174         gint row;
1175         gint *indices;
1176         gint unique_id;
1177         GValue *settings;
1178         gint status;
1179
1180         g_debug("queue_key_press_cb ()");
1181         if (event->keyval != GDK_Delete)
1182                 return FALSE;
1183         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
1184         store = gtk_tree_view_get_model(treeview);
1185
1186         selection = gtk_tree_view_get_selection (treeview);
1187         if (gtk_tree_selection_get_selected(selection, &store, &iter))
1188         {
1189                 GtkTreePath *treepath;
1190
1191                 treepath = gtk_tree_model_get_path (store, &iter);
1192                 // Find the entry in the queue
1193                 indices = gtk_tree_path_get_indices (treepath);
1194                 row = indices[0];
1195                 // Can only free the treepath After getting what I need from
1196                 // indices since this points into treepath somewhere.
1197                 gtk_tree_path_free (treepath);
1198                 if (row < 0) return FALSE;
1199                 if (row >= ghb_array_len(ud->queue))
1200                         return FALSE;
1201                 settings = ghb_array_get_nth(ud->queue, row);
1202                 status = ghb_settings_get_int(settings, "job_status");
1203                 if (status == GHB_QUEUE_RUNNING)
1204                 {
1205                         // Ask if wants to stop encode.
1206                         if (!ghb_cancel_encode(NULL))
1207                         {
1208                                 return TRUE;
1209                         }
1210                         unique_id = ghb_settings_get_int(settings, "job_unique_id");
1211                         ghb_remove_job(unique_id);
1212                 }
1213                 // Remove the selected item
1214                 gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
1215                 // Remove the corresponding item from the queue list
1216                 GValue *old = ghb_array_get_nth(ud->queue, row);
1217                 ghb_value_free(old);
1218                 ghb_array_remove(ud->queue, row);
1219                 ghb_save_queue(ud->queue);
1220                 return TRUE;
1221         }
1222         return FALSE;
1223 }
1224
1225 GValue *ghb_queue_edit_settings = NULL;
1226
1227 G_MODULE_EXPORT void
1228 queue_edit_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1229 {
1230         GtkTreeView *treeview;
1231         GtkTreeSelection *selection;
1232         GtkTreeModel *store;
1233         GtkTreeIter iter;
1234         gint row;
1235         gint *indices;
1236         gint status;
1237
1238         g_debug("queue_key_press_cb ()");
1239         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
1240         store = gtk_tree_view_get_model(treeview);
1241
1242         selection = gtk_tree_view_get_selection (treeview);
1243         if (gtk_tree_selection_get_selected(selection, &store, &iter))
1244         {
1245                 GtkTreePath *treepath;
1246
1247                 treepath = gtk_tree_model_get_path (store, &iter);
1248                 // Find the entry in the queue
1249                 indices = gtk_tree_path_get_indices (treepath);
1250                 row = indices[0];
1251                 // Can only free the treepath After getting what I need from
1252                 // indices since this points into treepath somewhere.
1253                 gtk_tree_path_free (treepath);
1254                 if (row < 0) return;
1255                 if (row >= ghb_array_len(ud->queue))
1256                         return;
1257                 ghb_queue_edit_settings = ghb_array_get_nth(ud->queue, row);
1258                 status = ghb_settings_get_int(ghb_queue_edit_settings, "job_status");
1259                 if (status == GHB_QUEUE_PENDING)
1260                 {
1261                         // Remove the selected item
1262                         gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
1263                         // Remove the corresponding item from the queue list
1264                         ghb_array_remove(ud->queue, row);
1265                 }
1266                 gchar *source;
1267                 source = ghb_settings_get_string(ghb_queue_edit_settings, "source");
1268                 ghb_do_scan(ud, source, 0, FALSE);
1269                 g_free(source);
1270         }
1271 }
1272