G_MODULE_EXPORT gboolean
queue_key_press_cb(
GtkWidget *widget,
GdkEventKey *event,
signal_user_data_t *ud)
{
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkTreeModel *store;
GtkTreeIter iter;
gint row;
gint *indices;
gint unique_id;
GValue *settings;
gint status;
g_debug("queue_key_press_cb ()");
if (event->keyval != GDK_KEY_Delete)
return FALSE;
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
store = gtk_tree_view_get_model(treeview);
selection = gtk_tree_view_get_selection (treeview);
if (gtk_tree_selection_get_selected(selection, &store, &iter))
{
GtkTreePath *treepath;
treepath = gtk_tree_model_get_path (store, &iter);
// Find the entry in the queue
indices = gtk_tree_path_get_indices (treepath);
row = indices[0];
// Can only free the treepath After getting what I need from
// indices since this points into treepath somewhere.
gtk_tree_path_free (treepath);
if (row < 0) return FALSE;
if (row >= ghb_array_len(ud->queue))
return FALSE;
settings = ghb_array_get_nth(ud->queue, row);
status = ghb_settings_get_int(settings, "job_status");
if (status == GHB_QUEUE_RUNNING)
{
// Ask if wants to stop encode.
if (!ghb_cancel_encode2(ud, NULL))
{
return TRUE;
}
unique_id = ghb_settings_get_int(settings, "job_unique_id");
ghb_remove_job(unique_id);
}
// Remove the selected item
gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
// Remove the corresponding item from the queue list
GValue *old = ghb_array_get_nth(ud->queue, row);
ghb_value_free(old);
ghb_array_remove(ud->queue, row);
ghb_save_queue(ud->queue);
return TRUE;
}
return FALSE;
}
G_MODULE_EXPORT void
subtitle_remove_clicked_cb(GtkWidget *widget, gchar *path, signal_user_data_t *ud)
{
GtkTreeView *tv;
GtkTreePath *tp;
GtkTreeModel *tm;
GtkTreeSelection *ts;
GtkTreeIter ti, nextIter;
gint row;
gint *indices;
GValue *subtitle_list;
tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
ts = gtk_tree_view_get_selection(tv);
tm = gtk_tree_view_get_model(tv);
tp = gtk_tree_path_new_from_string (path);
if (gtk_tree_path_get_depth(tp) > 1) return;
if (gtk_tree_model_get_iter(tm, &ti, tp))
{
nextIter = ti;
if (!gtk_tree_model_iter_next(tm, &nextIter))
{
nextIter = ti;
if (gtk_tree_model_get_iter_first(tm, &nextIter))
{
gtk_tree_selection_select_iter(ts, &nextIter);
}
}
else
{
gtk_tree_selection_select_iter(ts, &nextIter);
}
subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
// Get the row number
indices = gtk_tree_path_get_indices (tp);
row = indices[0];
if (row < 0 || row >= ghb_array_len(subtitle_list))
{
gtk_tree_path_free(tp);
return;
}
// Update our settings list before removing the row from the
// treeview. Removing from the treeview sometimes provokes an
// immediate selection change, so the list needs to be up to date
// when this happens.
GValue *old = ghb_array_get_nth(subtitle_list, row);
ghb_array_remove(subtitle_list, row);
ghb_value_free(old);
// Remove the selected item
gtk_tree_store_remove(GTK_TREE_STORE(tm), &ti);
ghb_live_reset(ud);
}
gtk_tree_path_free(tp);
}
static void subtitle_def_lang_list_init(signal_user_data_t *ud)
{
GValue *lang_list;
// Clear selected languages.
subtitle_def_selected_lang_list_clear(ud);
lang_list = ghb_settings_get_value(ud->settings, "SubtitleLanguageList");
if (lang_list == NULL)
{
lang_list = ghb_array_value_new(8);
ghb_settings_set_value(ud->settings, "SubtitleLanguageList", lang_list);
}
int ii, count;
count = ghb_array_len(lang_list);
for (ii = 0; ii < count; )
{
GValue *lang_val = ghb_array_get_nth(lang_list, ii);
int idx = ghb_lookup_audio_lang(lang_val);
if (ii == 0)
{
const iso639_lang_t *lang;
lang = ghb_iso639_lookup_by_int(idx);
subtitle_update_pref_lang(ud, lang);
}
GtkListBox *avail, *selected;
GtkListBoxRow *row;
avail = GTK_LIST_BOX(GHB_WIDGET(ud->builder, "subtitle_avail_lang"));
selected = GTK_LIST_BOX(GHB_WIDGET(ud->builder, "subtitle_selected_lang"));
row = ghb_find_lang_row(avail, idx);
if (row)
{
GtkWidget *label = gtk_bin_get_child(GTK_BIN(row));
g_object_ref(G_OBJECT(label));
gtk_widget_destroy(GTK_WIDGET(row));
gtk_widget_show(label);
gtk_list_box_insert(selected, label, -1);
ii++;
}
else
{
// Error in list. Probably duplicate languages. Remove
// this item from the list.
GValue *glang = ghb_array_get_nth(lang_list, ii);
ghb_array_remove(lang_list, ii);
ghb_value_free(glang);
count--;
}
}
if (count == 0)
{
subtitle_update_pref_lang(ud, NULL);
}
}
G_MODULE_EXPORT void
audio_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
{
GtkTreeView *treeview;
GtkTreePath *treepath;
GtkTreeSelection *selection;
GtkTreeModel *store;
GtkTreeIter iter, nextIter;
gint *indices;
gint row;
GValue *audio_list;
g_debug("audio_remove_clicked_cb ()");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
selection = gtk_tree_view_get_selection (treeview);
if (gtk_tree_selection_get_selected(selection, &store, &iter))
{
nextIter = iter;
if (!gtk_tree_model_iter_next(store, &nextIter))
{
nextIter = iter;
if (gtk_tree_model_get_iter_first(store, &nextIter))
{
gtk_tree_selection_select_iter (selection, &nextIter);
}
}
else
{
gtk_tree_selection_select_iter (selection, &nextIter);
}
// Get the row number
treepath = gtk_tree_model_get_path (store, &iter);
indices = gtk_tree_path_get_indices (treepath);
row = indices[0];
gtk_tree_path_free(treepath);
if (row < 0) return;
audio_list = ghb_settings_get_value(ud->settings, "audio_list");
if (row >= ghb_array_len(audio_list))
return;
// Update our settings list before removing the row from the
// treeview. Removing from the treeview sometimes provokes an
// immediate selection change, so the list needs to be up to date
// when this happens.
GValue *old = ghb_array_get_nth(audio_list, row);
ghb_value_free(old);
ghb_array_remove(audio_list, row);
// Remove the selected item
gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
// remove from audio settings list
widget = GHB_WIDGET (ud->builder, "audio_add");
gtk_widget_set_sensitive(widget, TRUE);
}
}
G_MODULE_EXPORT void
queue_remove_clicked_cb(GtkWidget *widget, gchar *path, signal_user_data_t *ud)
{
GtkTreeView *treeview;
GtkTreePath *treepath;
GtkTreeModel *store;
GtkTreeIter iter;
gint row;
gint *indices;
gint unique_id;
GValue *settings;
gint status;
g_debug("queue_remove_clicked_cb ()");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
store = gtk_tree_view_get_model(treeview);
treepath = gtk_tree_path_new_from_string (path);
if (gtk_tree_path_get_depth(treepath) > 1) return;
if (gtk_tree_model_get_iter(store, &iter, treepath))
{
// Find the entry in the queue
indices = gtk_tree_path_get_indices (treepath);
row = indices[0];
// Can only free the treepath After getting what I need from
// indices since this points into treepath somewhere.
gtk_tree_path_free (treepath);
if (row < 0) return;
if (row >= ghb_array_len(ud->queue))
return;
settings = ghb_array_get_nth(ud->queue, row);
status = ghb_settings_get_int(settings, "job_status");
if (status == GHB_QUEUE_RUNNING)
{
// Ask if wants to stop encode.
if (!ghb_cancel_encode2(ud, NULL))
{
return;
}
unique_id = ghb_settings_get_int(settings, "job_unique_id");
ghb_remove_job(unique_id);
}
// Remove the selected item
gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
// Remove the corresponding item from the queue list
GValue *old = ghb_array_get_nth(ud->queue, row);
ghb_value_free(old);
ghb_array_remove(ud->queue, row);
ghb_save_queue(ud->queue);
}
else
{
gtk_tree_path_free (treepath);
}
ghb_update_pending(ud);
}
G_MODULE_EXPORT void
queue_edit_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
{
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkTreeModel *store;
GtkTreeIter iter;
gint row;
gint *indices;
gint status;
g_debug("queue_key_press_cb ()");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
store = gtk_tree_view_get_model(treeview);
selection = gtk_tree_view_get_selection (treeview);
if (gtk_tree_selection_get_selected(selection, &store, &iter))
{
GtkTreePath *treepath;
treepath = gtk_tree_model_get_path (store, &iter);
// Find the entry in the queue
indices = gtk_tree_path_get_indices (treepath);
row = indices[0];
// Can only free the treepath After getting what I need from
// indices since this points into treepath somewhere.
gtk_tree_path_free (treepath);
if (row < 0) return;
if (row >= ghb_array_len(ud->queue))
return;
ghb_queue_edit_settings = ghb_array_get_nth(ud->queue, row);
status = ghb_settings_get_int(ghb_queue_edit_settings, "job_status");
if (status == GHB_QUEUE_PENDING)
{
// Remove the selected item
gtk_tree_store_remove(GTK_TREE_STORE(store), &iter);
// Remove the corresponding item from the queue list
ghb_array_remove(ud->queue, row);
}
else
{
ghb_queue_edit_settings = ghb_value_dup(ghb_queue_edit_settings);
}
gchar *source;
source = ghb_settings_get_string(ghb_queue_edit_settings, "source");
ghb_do_scan(ud, source, 0, FALSE);
g_free(source);
}
}
void
ghb_array_copy(GValue *arr1, GValue *arr2, gint count)
{
gint len, ii;
// empty the first array if it is not already empty
len = ghb_array_len(arr1);
for (ii = 0; ii < len; ii++)
ghb_array_remove(arr1, 0);
len = ghb_array_len(arr2);
count = MIN(count, len);
for (ii = 0; ii < count; ii++)
ghb_array_append(arr1, ghb_value_dup(ghb_array_get_nth(arr2, ii)));
}
G_MODULE_EXPORT void
subtitle_remove_lang_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
{
GtkListBox *avail, *selected;
GtkListBoxRow *row;
GtkWidget *label;
avail = GTK_LIST_BOX(GHB_WIDGET(ud->builder, "subtitle_avail_lang"));
selected = GTK_LIST_BOX(GHB_WIDGET(ud->builder, "subtitle_selected_lang"));
row = gtk_list_box_get_selected_row(selected);
if (row != NULL)
{
gint index;
GValue *lang_list;
index = gtk_list_box_row_get_index(row);
// Remove from UI selected language list box
label = gtk_bin_get_child(GTK_BIN(row));
g_object_ref(G_OBJECT(label));
int idx = (intptr_t)g_object_get_data(G_OBJECT(label), "lang_idx");
gtk_widget_destroy(GTK_WIDGET(row));
gtk_widget_show(label);
// Add to UI available language list box
gtk_list_box_insert(avail, label, idx);
// Remove from preset language list
lang_list = ghb_settings_get_value(ud->settings, "SubtitleLanguageList");
GValue *glang = ghb_array_get_nth(lang_list, index);
ghb_array_remove(lang_list, index);
ghb_value_free(glang);
ghb_clear_presets_selection(ud);
if (ghb_array_len(lang_list) > 0)
{
const iso639_lang_t *lang;
GValue *entry = ghb_array_get_nth(lang_list, 0);
lang = ghb_iso639_lookup_by_int(ghb_lookup_audio_lang(entry));
subtitle_update_pref_lang(ud, lang);
}
else
{
subtitle_update_pref_lang(ud, NULL);
}
}
}
void
ghb_subtitle_prune(signal_user_data_t *ud)
{
GValue *subtitle_list;
GValue *subsettings;
gint ii;
gboolean one_burned = FALSE;
subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
if (subtitle_list == NULL)
return;
const char *mux_id;
const hb_container_t *mux;
mux_id = ghb_settings_get_const_string(ud->settings, "FileFormat");
mux = ghb_lookup_container_by_name(mux_id);
for (ii = 0; ii < ghb_array_len(subtitle_list); )
{
gboolean burned;
int source;
subsettings = ghb_array_get_nth(subtitle_list, ii);
burned = ghb_settings_get_boolean(subsettings, "SubtitleBurned");
source = ghb_settings_get_boolean(subsettings, "SubtitleSource");
burned = burned || !hb_subtitle_can_pass(source, mux->format);
if (burned && one_burned)
{
GValue *gsub = ghb_array_get_nth(subtitle_list, ii);
ghb_array_remove(subtitle_list, ii);
ghb_value_free(gsub);
continue;
}
one_burned = one_burned || burned;
ghb_settings_set_boolean(subsettings, "SubtitleBurned", burned);
ii++;
}
subsettings = subtitle_get_selected_settings(ud, NULL);
if (subsettings != NULL)
{
subtitle_update_dialog_widgets(ud, subsettings);
}
}
G_MODULE_EXPORT void
queue_drag_cb(
GtkTreeView *dstwidget,
GdkDragContext *dc,
gint x, gint y,
GtkSelectionData *selection_data,
guint info, guint t,
signal_user_data_t *ud)
{
GtkTreePath *path = NULL;
//GtkTreeModel *model;
GtkTreeViewDropPosition pos;
GtkTreeIter dstiter, srciter;
gint *indices, row;
GValue *js;
GtkTreeModel *dstmodel = gtk_tree_view_get_model(dstwidget);
g_debug("queue_drag_cb ()");
// This doesn't work here for some reason...
// gtk_tree_view_get_drag_dest_row(dstwidget, &path, &pos);
gtk_tree_view_get_dest_row_at_pos (dstwidget, x, y, &path, &pos);
// This little hack is needed because attempting to drop after
// the last item gives us no path or pos.
if (path == NULL)
{
gint n_children;
n_children = gtk_tree_model_iter_n_children(dstmodel, NULL);
if (n_children)
{
pos = GTK_TREE_VIEW_DROP_AFTER;
path = gtk_tree_path_new_from_indices(n_children-1, -1);
}
else
{
pos = GTK_TREE_VIEW_DROP_BEFORE;
path = gtk_tree_path_new_from_indices(0, -1);
}
}
if (path)
{
if (gtk_tree_path_get_depth(path) > 1)
gtk_tree_path_up(path);
if (gtk_tree_model_get_iter (dstmodel, &dstiter, path))
{
GtkTreeIter iter;
GtkTreeView *srcwidget;
GtkTreeModel *srcmodel;
GtkTreeSelection *select;
GtkTreePath *srcpath = NULL;
GtkTreePath *dstpath = NULL;
srcwidget = GTK_TREE_VIEW(gtk_drag_get_source_widget(dc));
//srcmodel = gtk_tree_view_get_model(srcwidget);
select = gtk_tree_view_get_selection (srcwidget);
gtk_tree_selection_get_selected (select, &srcmodel, &srciter);
srcpath = gtk_tree_model_get_path (srcmodel, &srciter);
indices = gtk_tree_path_get_indices(srcpath);
row = indices[0];
gtk_tree_path_free(srcpath);
js = ghb_array_get_nth(ud->queue, row);
switch (pos)
{
case GTK_TREE_VIEW_DROP_BEFORE:
case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
gtk_tree_store_insert_before (GTK_TREE_STORE (dstmodel),
&iter, NULL, &dstiter);
break;
case GTK_TREE_VIEW_DROP_AFTER:
case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
gtk_tree_store_insert_after (GTK_TREE_STORE (dstmodel),
&iter, NULL, &dstiter);
break;
default:
break;
}
// Reset job to pending
ghb_settings_set_int(js, "job_status", GHB_QUEUE_PENDING);
add_to_queue_list(ud, js, &iter);
dstpath = gtk_tree_model_get_path (dstmodel, &iter);
indices = gtk_tree_path_get_indices(dstpath);
row = indices[0];
gtk_tree_path_free(dstpath);
ghb_array_insert(ud->queue, row, js);
srcpath = gtk_tree_model_get_path (srcmodel, &srciter);
indices = gtk_tree_path_get_indices(srcpath);
row = indices[0];
gtk_tree_path_free(srcpath);
ghb_array_remove(ud->queue, row);
gtk_tree_store_remove (GTK_TREE_STORE (srcmodel), &srciter);
ghb_save_queue(ud->queue);
}
gtk_tree_path_free(path);
}
}
gboolean
ghb_reload_queue(signal_user_data_t *ud)
{
GValue *queue;
gint unfinished = 0;
gint count, ii;
gint pid;
gint status;
GValue *settings;
gchar *message;
g_debug("ghb_reload_queue");
find_pid:
pid = ghb_find_pid_file();
if (pid < 0)
return FALSE;
queue = ghb_load_old_queue(pid);
ghb_remove_old_queue_file(pid);
// Look for unfinished entries
count = ghb_array_len(queue);
for (ii = 0; ii < count; ii++)
{
settings = ghb_array_get_nth(queue, ii);
status = ghb_settings_get_int(settings, "job_status");
if (status != GHB_QUEUE_DONE && status != GHB_QUEUE_CANCELED)
{
unfinished++;
}
}
if (!unfinished)
goto find_pid;
if (unfinished)
{
message = g_strdup_printf(
"You have %d unfinished job%s in a saved queue.\n\n"
"Would you like to reload %s?",
unfinished,
(unfinished > 1) ? "s" : "",
(unfinished > 1) ? "them" : "it");
if (ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "No", "Yes"))
{
GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
gtk_widget_show (widget);
widget = GHB_WIDGET (ud->builder, "show_queue");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), TRUE);
ud->queue = queue;
// First get rid of any old items we don't want
for (ii = count-1; ii >= 0; ii--)
{
settings = ghb_array_get_nth(queue, ii);
status = ghb_settings_get_int(settings, "job_status");
if (status == GHB_QUEUE_DONE || status == GHB_QUEUE_CANCELED)
{
GValue *old = ghb_array_get_nth(queue, ii);
ghb_value_free(old);
ghb_array_remove(queue, ii);
}
}
count = ghb_array_len(queue);
for (ii = 0; ii < count; ii++)
{
settings = ghb_array_get_nth(queue, ii);
ghb_settings_set_int(settings, "job_unique_id", 0);
ghb_settings_set_int(settings, "job_status", GHB_QUEUE_PENDING);
add_to_queue_list(ud, settings, NULL);
}
ghb_queue_buttons_grey(ud);
ghb_save_queue(ud->queue);
}
else
{
ghb_value_free(queue);
}
g_free(message);
}
return FALSE;
}