1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
4 * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
6 * callbacks.c is free software.
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)
15 #include <gdk/gdkkeysyms.h>
16 #include <glib/gstdio.h>
20 #include "hb-backend.h"
22 #include "callbacks.h"
27 queue_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
30 GtkTreeIter iter, piter;
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))
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))
44 GtkTreeView *treeview;
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);
56 GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_edit");
57 gtk_widget_set_sensitive (widget, FALSE);
62 add_to_queue_list(signal_user_data_t *ud, GValue *settings, GtkTreeIter *piter)
64 GtkTreeView *treeview;
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;
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));
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
96 "<big><b>%s</b></big> "
97 "<small>(Title %d, Chapters %d through %d, %d Video %s)"
99 vol_name, title, start_chapter, end_chapter,
100 pass2 ? 2:1, pass2 ? "Passes":"Pass", escape
108 gtk_tree_store_append(store, &iter, NULL);
110 gtk_tree_store_set(store, &iter, 1, info, 2, "hb-queue-delete", -1);
112 status = ghb_settings_get_int(settings, "job_status");
115 case GHB_QUEUE_PENDING:
116 gtk_tree_store_set(store, &iter, 0, "hb-queue-job", -1);
118 case GHB_QUEUE_CANCELED:
119 gtk_tree_store_set(store, &iter, 0, "hb-canceled", -1);
121 case GHB_QUEUE_RUNNING:
122 gtk_tree_store_set(store, &iter, 0, "hb-working0", -1);
125 gtk_tree_store_set(store, &iter, 0, "hb-complete", -1);
128 gtk_tree_store_set(store, &iter, 0, "hb-queue-job", -1);
132 GString *str = g_string_new("");
134 gboolean preset_modified;
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");
146 g_string_append_printf(str,
147 "<b>Modified Preset Based On:</b> <small>%s</small>\n",
150 g_string_append_printf(str,
151 "<b>Preset:</b> <small>%s</small>\n",
156 g_string_append_printf(str,
157 "<b>Format:</b> <small>%s Container, Chapter Markers</small>\n",
162 g_string_append_printf(str,
163 "<b>Format:</b> <small>%s Container</small>\n", container);
165 if (mux == HB_MUX_MP4)
167 gboolean ipod, http, large;
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)
174 g_string_append_printf(str, "<b>MP4 Options:</b><small>");
176 g_string_append_printf(str, " - iPod 5G Support");
178 g_string_append_printf(str, " - Web Optimized");
180 g_string_append_printf(str, " - Large File Size (>4GB)");
181 g_string_append_printf(str, "</small>\n");
184 escape = g_markup_escape_text(dest, -1);
185 g_string_append_printf(str,
186 "<b>Destination:</b> <small>%s</small>\n", escape);
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");
200 aspect_desc = "(Aspect Preserved)";
204 aspect_desc = "(Aspect Lost)";
210 aspect_desc = "(Strict Anamorphic)";
215 aspect_desc = "(Loose Anamorphic)";
220 aspect_desc = "(Custom Anamorphic)";
225 aspect_desc = "(Unknown)";
228 vqtype = ghb_settings_get_boolean(settings, "vquality_type_constant");
230 gchar *vq_desc = "Error";
231 gchar *vq_units = "";
236 vqtype = ghb_settings_get_boolean(settings, "vquality_type_target");
240 vqvalue = ghb_settings_get_int(settings, "VideoAvgBitrate");
241 vq_desc = "Bitrate:";
247 vqvalue = ghb_settings_get_int(settings, "VideoTargetSize");
248 vq_desc = "Target Size:";
251 vqstr = g_strdup_printf("%d", (gint)vqvalue);
256 vqvalue = ghb_settings_get_double(settings, "VideoQualitySlider");
257 vq_desc = "Constant Quality:";
258 vqstr = g_strdup_printf("%d", (gint)vqvalue);
261 fps = ghb_settings_get_string(settings, "VideoFramerate");
262 if (strcmp("source", fps) == 0)
265 if (ghb_settings_combo_int(settings, "PictureDetelecine"))
266 fps = g_strdup("Same As Source (vfr detelecine)");
268 fps = g_strdup("Same As Source (variable)");
273 tmp = g_strdup_printf("%s (constant frame rate)", fps);
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);
286 gboolean decomb_deint;
287 gboolean filters = FALSE;
289 decomb_deint = ghb_settings_get_boolean(settings, "PictureDecombDeinterlace");
290 decomb = ghb_settings_combo_int(settings, "PictureDecomb");
291 g_string_append_printf(str, "<b>Filters:</b><small>");
292 detel = ghb_settings_combo_int(settings, "PictureDetelecine");
295 g_string_append_printf(str, " - Detelecine");
299 cust = ghb_settings_get_string(settings, "PictureDetelecineCustom");
300 g_string_append_printf(str, ": %s", cust);
305 if (decomb_deint && decomb)
307 g_string_append_printf(str, " - Decomb");
311 cust = ghb_settings_get_string(settings, "PictureDecombCustom");
312 g_string_append_printf(str, ": %s", cust);
317 else if (!decomb_deint)
319 gint deint = ghb_settings_combo_int(settings, "PictureDeinterlace");
324 gchar *cust = ghb_settings_get_string(settings,
325 "PictureDeinterlaceCustom");
326 g_string_append_printf(str, " - Deinterlace: %s", cust);
331 const gchar *opt = ghb_settings_combo_option(settings,
332 "PictureDeinterlace");
333 g_string_append_printf(str, " - Deinterlace: %s", opt);
338 gint denoise = ghb_settings_combo_int(settings, "PictureDenoise");
343 gchar *cust = ghb_settings_get_string(settings,
344 "PictureDenoiseCustom");
345 g_string_append_printf(str, " - Denoise: %s", cust);
350 const gchar *opt = ghb_settings_combo_option(settings,
352 g_string_append_printf(str, " - Denoise: %s", opt);
356 gint deblock = ghb_settings_get_int(settings, "PictureDeblock");
359 g_string_append_printf(str, " - Deblock (%d)", deblock);
362 if (ghb_settings_get_boolean(settings, "VideoGrayScale"))
364 g_string_append_printf(str, " - Grayscale");
368 g_string_append_printf(str, " None");
369 g_string_append_printf(str, "</small>\n");
371 g_string_append_printf(str,
372 "<b>Video:</b> <small>%s, Framerate: %s, %s %s%s</small>\n",
373 vcodec, fps, vq_desc, vqstr, vq_units);
375 turbo = ghb_settings_get_boolean(settings, "VideoTurboTwoPass");
378 g_string_append_printf(str, "<b>Turbo:</b> <small>On</small>\n");
380 if (strcmp(vcodec_abbr, "x264") == 0)
382 gchar *x264opts = ghb_build_x264opts_string(settings);
383 g_string_append_printf(str,
384 "<b>x264 Options:</b> <small>%s</small>\n", x264opts);
389 const GValue *audio_list;
391 audio_list = ghb_settings_get_value(settings, "audio_list");
392 count = ghb_array_len(audio_list);
393 for (ii = 0; ii < count; ii++)
395 gchar *bitrate, *samplerate, *track;
396 const gchar *acodec, *mix;
399 asettings = ghb_array_get_nth(audio_list, ii);
401 acodec = ghb_settings_combo_option(asettings, "AudioEncoder");
402 bitrate = ghb_settings_get_string(asettings, "AudioBitrate");
403 samplerate = ghb_settings_get_string(asettings, "AudioSamplerate");
404 if (strcmp("source", samplerate) == 0)
407 samplerate = g_strdup("Same As Source");
409 track = ghb_settings_get_string(asettings, "AudioTrackDescription");
410 mix = ghb_settings_combo_option(asettings, "AudioMixdown");
412 g_string_append_printf(str, "<b>Audio:</b>");
414 g_string_append_printf(str, "<b>Audio:</b>\n");
416 g_string_append_printf(str, "\t");
418 g_string_append_printf(str,
419 "<small> %s, Encoder: %s, Mixdown: %s, SampleRate: %s, Bitrate: %s</small>\n",
420 track, acodec, mix, samplerate, bitrate);
427 const GValue *sub_list;
429 sub_list = ghb_settings_get_value(settings, "subtitle_list");
430 count = ghb_array_len(sub_list);
431 for (ii = 0; ii < count; ii++)
435 gboolean force, burn, def;
438 settings = ghb_array_get_nth(sub_list, ii);
439 track = ghb_settings_get_string(settings, "SubtitleTrackDescription");
440 source = ghb_settings_get_int(settings, "SubtitleSource");
441 force = ghb_settings_get_boolean(settings, "SubtitleForced");
442 burn = ghb_settings_get_boolean(settings, "SubtitleBurned");
443 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
445 g_string_append_printf(str, "<b>Subtitle:</b>");
447 g_string_append_printf(str, "<b>Subtitles:</b>\n");
449 g_string_append_printf(str, "\t");
451 if (source != SRTSUB)
453 g_string_append_printf(str,
454 "<small> %s%s%s%s</small>",
456 force ? " (Force)":"",
458 def ? " (Default)":""
464 gchar *filename, *basename, *code;
466 offset = ghb_settings_get_int(settings, "SrtOffset");
467 filename = ghb_settings_get_string(settings, "SrtFile");
468 basename = g_path_get_basename(filename);
469 code = ghb_settings_get_string(settings, "SrtCodeset");
470 g_string_append_printf(str,
471 "<small> %s (%s), %s, Offset (ms) %d%s</small>",
472 track, code, basename, offset,
473 def ? " (Default)":""
480 g_string_append_printf(str, "\n");
484 info = g_string_free(str, FALSE);
485 gtk_tree_store_append(store, &citer, &iter);
486 gtk_tree_store_set(store, &citer, 1, info, -1);
496 audio_list_refresh(signal_user_data_t *ud)
498 GtkTreeView *treeview;
503 const GValue *audio_list;
505 g_debug("ghb_audio_list_refresh ()");
506 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
507 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
508 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
512 const gchar *track, *codec, *br, *sr, *mix;
513 gchar *drc, *s_track, *s_codec, *s_br, *s_sr, *s_mix;
517 audio_list = ghb_settings_get_value(ud->settings, "audio_list");
518 if (row >= ghb_array_len(audio_list))
520 asettings = ghb_array_get_nth(audio_list, row);
522 track = ghb_settings_combo_option(asettings, "AudioTrack");
523 codec = ghb_settings_combo_option(asettings, "AudioEncoder");
524 br = ghb_settings_combo_option(asettings, "AudioBitrate");
525 sr = ghb_settings_combo_option(asettings, "AudioSamplerate");
526 mix = ghb_settings_combo_option(asettings, "AudioMixdown");
528 s_track = ghb_settings_get_string(asettings, "AudioTrack");
529 s_codec = ghb_settings_get_string(asettings, "AudioEncoder");
530 s_br = ghb_settings_get_string(asettings, "AudioBitrate");
531 s_sr = ghb_settings_get_string(asettings, "AudioSamplerate");
532 s_mix = ghb_settings_get_string(asettings, "AudioMixdown");
533 s_drc = ghb_settings_get_double(asettings, "AudioTrackDRCSlider");
535 drc = g_strdup("Off");
537 drc = g_strdup_printf("%.1f", s_drc);
539 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
540 // These are displayed in list
547 // These are used to set combo values when an item is selected
561 done = !gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
568 validate_settings(signal_user_data_t *ud)
570 // Check to see if the dest file exists or is
571 // already in the queue
572 gchar *message, *dest;
576 titleindex = ghb_settings_combo_int(ud->settings, "title");
577 if (titleindex < 0) return FALSE;
578 dest = ghb_settings_get_string(ud->settings, "destination");
579 count = ghb_array_len(ud->queue);
580 for (ii = 0; ii < count; ii++)
585 js = ghb_array_get_nth(ud->queue, ii);
586 filename = ghb_settings_get_string(js, "destination");
587 if (strcmp(dest, filename) == 0)
589 message = g_strdup_printf(
590 "Destination: %s\n\n"
591 "Another queued job has specified the same destination.\n"
592 "Do you want to overwrite?",
594 if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Overwrite"))
606 gchar *destdir = g_path_get_dirname(dest);
607 if (!g_file_test(destdir, G_FILE_TEST_IS_DIR))
609 message = g_strdup_printf(
610 "Destination: %s\n\n"
611 "This is not a valid directory.",
613 ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL);
620 // This doesn't work properly on windows
621 if (g_access(destdir, R_OK|W_OK) != 0)
623 message = g_strdup_printf(
624 "Destination: %s\n\n"
625 "Can not read or write the directory.",
627 ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL);
637 gchar *resolved = ghb_resolve_symlink(destdir);
639 gfile = g_file_new_for_path(resolved);
640 info = g_file_query_filesystem_info(gfile,
641 G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, NULL);
644 if (g_file_info_has_attribute(info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE))
646 size = g_file_info_get_attribute_uint64(info,
647 G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
649 gint64 fsize = (guint64)10 * 1024 * 1024 * 1024;
652 message = g_strdup_printf(
653 "Destination filesystem is almost full: %uM free\n\n"
654 "Encode may be incomplete if you proceed.\n",
655 (guint)(size / (1024L*1024L)));
656 if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Proceed"))
665 g_object_unref(info);
667 g_object_unref(gfile);
670 if (g_file_test(dest, G_FILE_TEST_EXISTS))
672 message = g_strdup_printf(
673 "Destination: %s\n\n"
674 "File already exists.\n"
675 "Do you want to overwrite?",
677 if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Overwrite"))
687 // Validate video quality is in a reasonable range
688 if (!ghb_validate_vquality(ud->settings))
692 // Validate audio settings
693 if (!ghb_validate_audio(ud))
697 // Validate audio settings
698 if (!ghb_validate_subtitles(ud))
702 // Validate video settings
703 if (!ghb_validate_video(ud))
707 // Validate filter settings
708 if (!ghb_validate_filters(ud))
712 audio_list_refresh(ud);
717 queue_add(signal_user_data_t *ud)
719 // Add settings to the queue
724 g_debug("queue_add ()");
725 if (!validate_settings(ud))
730 if (ud->queue == NULL)
731 ud->queue = ghb_array_value_new(32);
732 // Make a copy of current settings to be used for the new job
733 settings = ghb_value_dup(ud->settings);
734 ghb_settings_set_int(settings, "job_status", GHB_QUEUE_PENDING);
735 ghb_settings_set_int(settings, "job_unique_id", 0);
736 titleindex = ghb_settings_combo_int(settings, "title");
737 titlenum = ghb_get_title_number(titleindex);
738 ghb_settings_set_int(settings, "titlenum", titlenum);
739 ghb_array_append(ud->queue, settings);
740 add_to_queue_list(ud, settings, NULL);
741 ghb_save_queue(ud->queue);
742 ghb_update_pending(ud);
748 queue_add_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
750 g_debug("queue_add_clicked_cb ()");
755 queue_remove_clicked_cb(GtkWidget *widget, gchar *path, signal_user_data_t *ud)
757 GtkTreeView *treeview;
758 GtkTreePath *treepath;
767 g_debug("queue_remove_clicked_cb ()");
768 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
769 store = gtk_tree_view_get_model(treeview);
770 treepath = gtk_tree_path_new_from_string (path);
771 if (gtk_tree_path_get_depth(treepath) > 1) return;
772 if (gtk_tree_model_get_iter(store, &iter, treepath))
774 // Find the entry in the queue
775 indices = gtk_tree_path_get_indices (treepath);
777 // Can only free the treepath After getting what I need from
778 // indices since this points into treepath somewhere.
779 gtk_tree_path_free (treepath);
781 if (row >= ghb_array_len(ud->queue))
783 settings = ghb_array_get_nth(ud->queue, row);
784 status = ghb_settings_get_int(settings, "job_status");
785 if (status == GHB_QUEUE_RUNNING)
787 // Ask if wants to stop encode.
788 if (!ghb_cancel_encode2(ud, NULL))
792 unique_id = ghb_settings_get_int(settings, "job_unique_id");
793 ghb_remove_job(unique_id);
795 // Remove the selected item
796 gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
797 // Remove the corresponding item from the queue list
798 GValue *old = ghb_array_get_nth(ud->queue, row);
800 ghb_array_remove(ud->queue, row);
801 ghb_save_queue(ud->queue);
805 gtk_tree_path_free (treepath);
807 ghb_update_pending(ud);
811 find_last_finished(GValue *queue)
817 g_debug("find_last_finished");
818 count = ghb_array_len(queue);
819 for (ii = 0; ii < count; ii++)
821 js = ghb_array_get_nth(queue, ii);
822 status = ghb_settings_get_int(js, "job_status");
823 if (status != GHB_QUEUE_DONE && status != GHB_QUEUE_RUNNING)
831 // This little bit is needed to prevent the default drag motion
832 // handler from expanding rows if you hover over them while
834 // Also controls where valid drop locations are
835 G_MODULE_EXPORT gboolean
836 queue_drag_motion_cb(
842 signal_user_data_t *ud)
844 GtkTreePath *path = NULL;
845 GtkTreeViewDropPosition pos;
846 gint *indices, row, status, finished;
851 GtkTreeSelection *select;
854 widget = gtk_drag_get_source_widget(ctx);
855 if (widget == NULL || widget != GTK_WIDGET(tv))
858 // This bit checks to see if the source is allowed to be
859 // moved. Only pending and canceled items may be moved.
860 srctv = GTK_TREE_VIEW(gtk_drag_get_source_widget(ctx));
861 select = gtk_tree_view_get_selection (srctv);
862 gtk_tree_selection_get_selected (select, &model, &iter);
863 path = gtk_tree_model_get_path (model, &iter);
864 indices = gtk_tree_path_get_indices(path);
866 gtk_tree_path_free(path);
867 js = ghb_array_get_nth(ud->queue, row);
868 status = ghb_settings_get_int(js, "job_status");
869 if (status != GHB_QUEUE_PENDING && status != GHB_QUEUE_CANCELED)
871 gdk_drag_status(ctx, 0, time);
875 // The reset checks that the destination is a valid position
876 // in the list. Can not move above any finished or running items
877 gtk_tree_view_get_dest_row_at_pos (tv, x, y, &path, &pos);
880 gdk_drag_status(ctx, GDK_ACTION_MOVE, time);
883 // Don't allow *drop into*
884 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)
885 pos = GTK_TREE_VIEW_DROP_BEFORE;
886 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
887 pos = GTK_TREE_VIEW_DROP_AFTER;
888 // Don't allow droping int child items
889 if (gtk_tree_path_get_depth(path) > 1)
891 gtk_tree_path_up(path);
892 pos = GTK_TREE_VIEW_DROP_AFTER;
894 indices = gtk_tree_path_get_indices(path);
896 js = ghb_array_get_nth(ud->queue, row);
898 finished = find_last_finished(ud->queue);
901 gtk_tree_path_free(path);
902 gdk_drag_status(ctx, 0, time);
905 if (pos != GTK_TREE_VIEW_DROP_AFTER &&
908 gtk_tree_path_free(path);
909 gdk_drag_status(ctx, 0, time);
912 gtk_tree_view_set_drag_dest_row(tv, path, pos);
913 gtk_tree_path_free(path);
914 gdk_drag_status(ctx, GDK_ACTION_MOVE, time);
920 GtkTreeView *dstwidget,
923 GtkSelectionData *selection_data,
925 signal_user_data_t *ud)
927 GtkTreePath *path = NULL;
928 //GtkTreeModel *model;
929 GtkTreeViewDropPosition pos;
930 GtkTreeIter dstiter, srciter;
934 GtkTreeModel *dstmodel = gtk_tree_view_get_model(dstwidget);
936 g_debug("queue_drag_cb ()");
937 // This doesn't work here for some reason...
938 // gtk_tree_view_get_drag_dest_row(dstwidget, &path, &pos);
939 gtk_tree_view_get_dest_row_at_pos (dstwidget, x, y, &path, &pos);
940 // This little hack is needed because attempting to drop after
941 // the last item gives us no path or pos.
946 n_children = gtk_tree_model_iter_n_children(dstmodel, NULL);
949 pos = GTK_TREE_VIEW_DROP_AFTER;
950 path = gtk_tree_path_new_from_indices(n_children-1, -1);
954 pos = GTK_TREE_VIEW_DROP_BEFORE;
955 path = gtk_tree_path_new_from_indices(0, -1);
960 if (gtk_tree_path_get_depth(path) > 1)
961 gtk_tree_path_up(path);
962 if (gtk_tree_model_get_iter (dstmodel, &dstiter, path))
965 GtkTreeView *srcwidget;
966 GtkTreeModel *srcmodel;
967 GtkTreeSelection *select;
968 GtkTreePath *srcpath = NULL;
969 GtkTreePath *dstpath = NULL;
971 srcwidget = GTK_TREE_VIEW(gtk_drag_get_source_widget(dc));
972 //srcmodel = gtk_tree_view_get_model(srcwidget);
973 select = gtk_tree_view_get_selection (srcwidget);
974 gtk_tree_selection_get_selected (select, &srcmodel, &srciter);
976 srcpath = gtk_tree_model_get_path (srcmodel, &srciter);
977 indices = gtk_tree_path_get_indices(srcpath);
979 gtk_tree_path_free(srcpath);
980 js = ghb_array_get_nth(ud->queue, row);
984 case GTK_TREE_VIEW_DROP_BEFORE:
985 case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
986 gtk_tree_store_insert_before (GTK_TREE_STORE (dstmodel),
987 &iter, NULL, &dstiter);
990 case GTK_TREE_VIEW_DROP_AFTER:
991 case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
992 gtk_tree_store_insert_after (GTK_TREE_STORE (dstmodel),
993 &iter, NULL, &dstiter);
999 // Reset job to pending
1000 ghb_settings_set_int(js, "job_status", GHB_QUEUE_PENDING);
1001 add_to_queue_list(ud, js, &iter);
1003 dstpath = gtk_tree_model_get_path (dstmodel, &iter);
1004 indices = gtk_tree_path_get_indices(dstpath);
1006 gtk_tree_path_free(dstpath);
1007 ghb_array_insert(ud->queue, row, js);
1009 srcpath = gtk_tree_model_get_path (srcmodel, &srciter);
1010 indices = gtk_tree_path_get_indices(srcpath);
1012 gtk_tree_path_free(srcpath);
1013 ghb_array_remove(ud->queue, row);
1014 gtk_tree_store_remove (GTK_TREE_STORE (srcmodel), &srciter);
1015 ghb_save_queue(ud->queue);
1017 gtk_tree_path_free(path);
1022 ghb_queue_buttons_grey(signal_user_data_t *ud)
1028 gint queue_state, scan_state;
1029 gboolean show_start, show_stop, paused;
1031 queue_count = ghb_array_len(ud->queue);
1032 titleindex = ghb_settings_combo_int(ud->settings, "title");
1034 queue_state = ghb_get_queue_state();
1035 scan_state = ghb_get_scan_state();
1037 show_stop = queue_state &
1038 (GHB_STATE_WORKING | GHB_STATE_SCANNING | GHB_STATE_MUXING);
1039 show_start = !(scan_state & GHB_STATE_SCANNING) &&
1040 (titleindex >= 0 || queue_count > 0);
1043 paused = queue_state & GHB_STATE_PAUSED;
1045 widget = GHB_WIDGET (ud->builder, "queue_start1");
1048 gtk_widget_set_sensitive (widget, TRUE);
1049 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-stop");
1050 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Stop");
1051 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Stop Encoding");
1055 gtk_widget_set_sensitive (widget, show_start);
1056 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-play");
1057 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Start");
1058 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Start Encoding");
1060 widget = GHB_WIDGET (ud->builder, "queue_start2");
1063 gtk_widget_set_sensitive (widget, TRUE);
1064 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-stop");
1065 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Stop");
1066 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Stop Encoding");
1070 gtk_widget_set_sensitive (widget, show_start);
1071 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-play");
1072 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Start");
1073 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Start Encoding");
1075 widget = GHB_WIDGET (ud->builder, "queue_pause1");
1078 gtk_widget_set_sensitive (widget, show_stop);
1079 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-play");
1080 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Resume");
1081 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Resume Encoding");
1085 gtk_widget_set_sensitive (widget, show_stop);
1086 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-pause");
1087 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Pause");
1088 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Pause Encoding");
1090 widget = GHB_WIDGET (ud->builder, "queue_pause2");
1093 gtk_widget_set_sensitive (widget, show_stop);
1094 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-play");
1095 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Resume");
1096 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Resume Encoding");
1100 gtk_widget_set_sensitive (widget, show_stop);
1101 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-pause");
1102 gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Pause");
1103 gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Pause Encoding");
1106 action = GHB_ACTION (ud->builder, "queue_start_menu");
1109 gtk_action_set_sensitive (action, TRUE);
1110 #if GTK_CHECK_VERSION(2, 16, 0)
1111 gtk_action_set_icon_name(action, "hb-stop");
1112 gtk_action_set_label(action, "S_top Queue");
1113 gtk_action_set_tooltip(action, "Stop Encoding");
1115 g_object_set_property(G_OBJECT(action), "icon-name",
1116 ghb_string_value("hb-stop"));
1117 g_object_set_property(G_OBJECT(action), "label",
1118 ghb_string_value("S_top Queue"));
1119 g_object_set_property(G_OBJECT(action), "tooltip",
1120 ghb_string_value("Stop Encoding"));
1125 gtk_action_set_sensitive (action, show_start);
1126 #if GTK_CHECK_VERSION(2, 16, 0)
1127 gtk_action_set_icon_name(action, "hb-play");
1128 gtk_action_set_label(action, "_Start Queue");
1129 gtk_action_set_tooltip(action, "Start Encoding");
1131 g_object_set_property(G_OBJECT(action), "icon-name",
1132 ghb_string_value("hb-play"));
1133 g_object_set_property(G_OBJECT(action), "label",
1134 ghb_string_value("_Start Queue"));
1135 g_object_set_property(G_OBJECT(action), "tooltip",
1136 ghb_string_value("Start Encoding"));
1139 action = GHB_ACTION (ud->builder, "queue_pause_menu");
1142 gtk_action_set_sensitive (action, show_start);
1143 #if GTK_CHECK_VERSION(2, 16, 0)
1144 gtk_action_set_icon_name(action, "hb-play");
1145 gtk_action_set_label(action, "_Resume Queue");
1146 gtk_action_set_tooltip(action, "Resume Encoding");
1148 g_object_set_property(G_OBJECT(action), "icon-name",
1149 ghb_string_value("hb-play"));
1150 g_object_set_property(G_OBJECT(action), "label",
1151 ghb_string_value("_Resume Queue"));
1152 g_object_set_property(G_OBJECT(action), "tooltip",
1153 ghb_string_value("Resume Encoding"));
1158 gtk_action_set_sensitive (action, show_stop);
1159 #if GTK_CHECK_VERSION(2, 16, 0)
1160 gtk_action_set_icon_name(action, "hb-pause");
1161 gtk_action_set_label(action, "_Pause Queue");
1162 gtk_action_set_tooltip(action, "Pause Encoding");
1164 g_object_set_property(G_OBJECT(action), "icon-name",
1165 ghb_string_value("hb-pause"));
1166 g_object_set_property(G_OBJECT(action), "label",
1167 ghb_string_value("_Pause Queue"));
1168 g_object_set_property(G_OBJECT(action), "tooltip",
1169 ghb_string_value("Pause Encoding"));
1174 G_MODULE_EXPORT void
1175 queue_list_size_allocate_cb(GtkWidget *widget, GtkAllocation *allocation, GtkCellRenderer *cell)
1177 GtkTreeViewColumn *column;
1180 column = gtk_tree_view_get_column (GTK_TREE_VIEW(widget), 0);
1181 width = gtk_tree_view_column_get_width(column);
1182 g_debug("col width %d alloc width %d", width, allocation->width);
1183 // Set new wrap-width. Shave a little off to accomidate the icons
1184 // that share this column.
1185 if (width >= 564) // Don't allow below a certain size
1186 g_object_set(cell, "wrap-width", width-70, NULL);
1189 G_MODULE_EXPORT void
1190 queue_start_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1193 gboolean running = FALSE;
1198 state = ghb_get_queue_state();
1199 if (state & (GHB_STATE_WORKING | GHB_STATE_SCANNING | GHB_STATE_MUXING))
1201 ghb_cancel_encode(ud, "You are currently encoding. "
1202 "What would you like to do?");
1206 count = ghb_array_len(ud->queue);
1207 for (ii = 0; ii < count; ii++)
1209 js = ghb_array_get_nth(ud->queue, ii);
1210 status = ghb_settings_get_int(js, "job_status");
1211 if ((status == GHB_QUEUE_RUNNING) ||
1212 (status == GHB_QUEUE_PENDING))
1220 // The queue has no running or pending jobs.
1221 // Add current settings to the queue, then run.
1225 if (state == GHB_STATE_IDLE)
1227 // Add the first pending queue item and start
1228 ud->current_job = ghb_start_next_job(ud, TRUE);
1232 G_MODULE_EXPORT void
1233 queue_pause_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1239 ghb_reload_queue(signal_user_data_t *ud)
1242 gint unfinished = 0;
1248 g_debug("ghb_reload_queue");
1250 queue = ghb_load_queue();
1251 // Look for unfinished entries
1252 count = ghb_array_len(queue);
1253 for (ii = 0; ii < count; ii++)
1255 settings = ghb_array_get_nth(queue, ii);
1256 status = ghb_settings_get_int(settings, "job_status");
1257 if (status != GHB_QUEUE_DONE && status != GHB_QUEUE_CANCELED)
1264 message = g_strdup_printf(
1265 "You have %d unfinished job%s in a saved queue.\n\n"
1266 "Would you like to reload %s?",
1268 (unfinished > 1) ? "s" : "",
1269 (unfinished > 1) ? "them" : "it");
1270 if (ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "No", "Yes"))
1272 GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
1273 gtk_widget_show (widget);
1276 // First get rid of any old items we don't want
1277 for (ii = count-1; ii >= 0; ii--)
1279 settings = ghb_array_get_nth(queue, ii);
1280 status = ghb_settings_get_int(settings, "job_status");
1281 if (status == GHB_QUEUE_DONE || status == GHB_QUEUE_CANCELED)
1283 GValue *old = ghb_array_get_nth(queue, ii);
1284 ghb_value_free(old);
1285 ghb_array_remove(queue, ii);
1288 count = ghb_array_len(queue);
1289 for (ii = 0; ii < count; ii++)
1291 settings = ghb_array_get_nth(queue, ii);
1292 ghb_settings_set_int(settings, "job_unique_id", 0);
1293 ghb_settings_set_int(settings, "job_status", GHB_QUEUE_PENDING);
1294 add_to_queue_list(ud, settings, NULL);
1296 ghb_queue_buttons_grey(ud);
1300 ghb_value_free(queue);
1301 ghb_remove_queue_file();
1308 G_MODULE_EXPORT gboolean
1312 signal_user_data_t *ud)
1314 GtkTreeView *treeview;
1315 GtkTreeSelection *selection;
1316 GtkTreeModel *store;
1324 g_debug("queue_key_press_cb ()");
1325 if (event->keyval != GDK_Delete)
1327 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
1328 store = gtk_tree_view_get_model(treeview);
1330 selection = gtk_tree_view_get_selection (treeview);
1331 if (gtk_tree_selection_get_selected(selection, &store, &iter))
1333 GtkTreePath *treepath;
1335 treepath = gtk_tree_model_get_path (store, &iter);
1336 // Find the entry in the queue
1337 indices = gtk_tree_path_get_indices (treepath);
1339 // Can only free the treepath After getting what I need from
1340 // indices since this points into treepath somewhere.
1341 gtk_tree_path_free (treepath);
1342 if (row < 0) return FALSE;
1343 if (row >= ghb_array_len(ud->queue))
1345 settings = ghb_array_get_nth(ud->queue, row);
1346 status = ghb_settings_get_int(settings, "job_status");
1347 if (status == GHB_QUEUE_RUNNING)
1349 // Ask if wants to stop encode.
1350 if (!ghb_cancel_encode2(ud, NULL))
1354 unique_id = ghb_settings_get_int(settings, "job_unique_id");
1355 ghb_remove_job(unique_id);
1357 // Remove the selected item
1358 gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
1359 // Remove the corresponding item from the queue list
1360 GValue *old = ghb_array_get_nth(ud->queue, row);
1361 ghb_value_free(old);
1362 ghb_array_remove(ud->queue, row);
1363 ghb_save_queue(ud->queue);
1369 GValue *ghb_queue_edit_settings = NULL;
1371 G_MODULE_EXPORT void
1372 queue_edit_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1374 GtkTreeView *treeview;
1375 GtkTreeSelection *selection;
1376 GtkTreeModel *store;
1382 g_debug("queue_key_press_cb ()");
1383 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
1384 store = gtk_tree_view_get_model(treeview);
1386 selection = gtk_tree_view_get_selection (treeview);
1387 if (gtk_tree_selection_get_selected(selection, &store, &iter))
1389 GtkTreePath *treepath;
1391 treepath = gtk_tree_model_get_path (store, &iter);
1392 // Find the entry in the queue
1393 indices = gtk_tree_path_get_indices (treepath);
1395 // Can only free the treepath After getting what I need from
1396 // indices since this points into treepath somewhere.
1397 gtk_tree_path_free (treepath);
1398 if (row < 0) return;
1399 if (row >= ghb_array_len(ud->queue))
1401 ghb_queue_edit_settings = ghb_array_get_nth(ud->queue, row);
1402 status = ghb_settings_get_int(ghb_queue_edit_settings, "job_status");
1403 if (status == GHB_QUEUE_PENDING)
1405 // Remove the selected item
1406 gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
1407 // Remove the corresponding item from the queue list
1408 ghb_array_remove(ud->queue, row);
1411 source = ghb_settings_get_string(ghb_queue_edit_settings, "source");
1412 ghb_do_scan(ud, source, 0, FALSE);