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