gboolean ghb_queue_add(signal_user_data_t *ud, GValue *settings, gint batch) { // Add settings to the queue gint titleindex; gint titlenum; g_debug("queue_add ()"); if (!validate_settings(ud, settings, batch)) { return FALSE; } if (ud->queue == NULL) ud->queue = ghb_array_value_new(32); // Make a copy of current settings to be used for the new job ghb_settings_set_int(settings, "job_status", GHB_QUEUE_PENDING); ghb_settings_set_int(settings, "job_unique_id", 0); titleindex = ghb_settings_combo_int(settings, "title"); titlenum = ghb_get_title_number(titleindex); ghb_settings_set_int(settings, "titlenum", titlenum); ghb_array_append(ud->queue, settings); add_to_queue_list(ud, settings, NULL); ghb_save_queue(ud->queue); ghb_update_pending(ud); return TRUE; }
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); } }
static void subtitle_add_to_settings(GValue *settings, GValue *subsettings) { // Add the current subtitle settings to the list. GValue *subtitle_list; gint count; gboolean burned, forced, def; gint source; subtitle_list = ghb_settings_get_value(settings, "subtitle_list"); if (subtitle_list == NULL) { subtitle_list = ghb_array_value_new(8); ghb_settings_set_value(settings, "subtitle_list", subtitle_list); } // Validate some settings const char *mux_id; const hb_container_t *mux; mux_id = ghb_settings_get_const_string(settings, "FileFormat"); mux = ghb_lookup_container_by_name(mux_id); source = ghb_settings_get_int(subsettings, "SubtitleSource"); burned = ghb_settings_get_boolean(subsettings, "SubtitleBurned"); if (burned && !hb_subtitle_can_burn(source)) { burned = FALSE; ghb_settings_set_boolean(subsettings, "SubtitleBurned", burned); } if (!burned && !hb_subtitle_can_pass(source, mux->format)) { burned = TRUE; ghb_settings_set_boolean(subsettings, "SubtitleBurned", burned); ghb_settings_set_boolean(subsettings, "SubtitleDefaultTrack", FALSE); } def = ghb_settings_get_boolean(subsettings, "SubtitleDefaultTrack"); forced = ghb_settings_get_boolean(subsettings, "SubtitleForced"); if (forced && !hb_subtitle_can_force(source)) { forced = FALSE; ghb_settings_set_boolean(subsettings, "SubtitleForced", forced); } ghb_array_append(subtitle_list, subsettings); // Check consistancy of exclusive flags count = ghb_array_len(subtitle_list); if (burned) ghb_subtitle_exclusive_burn_settings(settings, count-1); if (def) ghb_subtitle_exclusive_default_settings(settings, count-1); }
static void ghb_clear_subtitle_list_settings(GValue *settings) { GValue *subtitle_list; subtitle_list = ghb_settings_get_value(settings, "subtitle_list"); if (subtitle_list == NULL) { subtitle_list = ghb_array_value_new(8); ghb_settings_set_value(settings, "subtitle_list", subtitle_list); } else ghb_array_value_reset(subtitle_list, 8); }
void ghb_clear_audio_list_settings(GValue *settings) { GValue *audio_list; g_debug("clear_audio_list_settings ()"); audio_list = ghb_settings_get_value(settings, "audio_list"); if (audio_list == NULL) { audio_list = ghb_array_value_new(8); ghb_settings_set_value(settings, "audio_list", audio_list); } else ghb_array_value_reset(audio_list, 8); }
static gboolean ghb_add_audio_to_settings(GValue *settings, GValue *asettings) { GValue *audio_list; const gchar * track; int count; audio_list = ghb_settings_get_value(settings, "audio_list"); if (audio_list == NULL) { audio_list = ghb_array_value_new(8); ghb_settings_set_value(settings, "audio_list", audio_list); } count = ghb_array_len(audio_list); // Don't allow more than 99 // This is a hard limit imposed by libhb/reader.c:GetFifoForId() if (count >= 99) { ghb_value_free(asettings); return FALSE; } int title_no = ghb_settings_get_int(settings, "title_no"); int track_no = ghb_settings_get_int(asettings, "AudioTrack"); track = ghb_audio_track_description(track_no, title_no); ghb_settings_set_string(asettings, "AudioTrackDescription", track); GValue *aname; aname = ghb_dict_lookup(asettings, "AudioTrackName"); if (aname == NULL) { ghb_settings_set_string(asettings, "AudioTrackName", ""); } if (ghb_array_len(audio_list) >= 99) { ghb_value_free(asettings); return FALSE; } ghb_array_append(audio_list, asettings); return TRUE; }
static void start_element( GMarkupParseContext *ctx, const gchar *name, const gchar **attr_names, const gchar **attr_values, gpointer ud, GError **error) { parse_data_t *pd = (parse_data_t*)ud; union { gint id; gpointer pid; } id; gint ii; // Check to see if the first element found has been closed // If so, ignore any junk following it. if (pd->closed_top) return; for (ii = 0; ii < TAG_MAP_SZ; ii++) { if (strcmp(name, tag_map[ii].tag) == 0) { id.id = tag_map[ii].id; break; } } if (ii == TAG_MAP_SZ) { g_warning("Unrecognized start tag (%s)", name); return; } g_queue_push_head(pd->tag_stack, id.pid); GType gtype = 0; GValue *gval = NULL; GValue *current = g_queue_peek_head(pd->stack); switch (id.id) { case P_PLIST: { // Ignore } break; case P_KEY: { if (pd->key) g_free(pd->key); pd->key = NULL; } break; case P_DICT: { gval = ghb_dict_value_new(); g_queue_push_head(pd->stack, gval); } break; case P_ARRAY: { gval = ghb_array_value_new(128); g_queue_push_head(pd->stack, gval); } break; case P_INTEGER: { } break; case P_REAL: { } break; case P_STRING: { } break; case P_DATE: { } break; case P_TRUE: { } break; case P_FALSE: { } break; case P_DATA: { } break; } // Add the element to the current container if (gval) { // There's an element to add if (current == NULL) { pd->plist = gval; return; } gtype = G_VALUE_TYPE(current); if (gtype == ghb_array_get_type()) { ghb_array_append(current, gval); } else if (gtype == ghb_dict_get_type()) { if (pd->key == NULL) { g_warning("No key for dictionary item"); ghb_value_free(gval); } else { ghb_dict_insert(current, g_strdup(pd->key), gval); } } else { g_error("Invalid container type. This shouldn't happen"); } } }
int main(gint argc, gchar *argv[]) { gint ii, jj; GValue *top; gint count = sizeof(dep_map) / sizeof(dependency_t); g_type_init(); top = ghb_dict_value_new(); for (ii = 0; ii < count; ii++) { const gchar *name; GValue *array; name = dep_map[ii].widget_name; if (ghb_dict_lookup(top, name)) continue; array = ghb_array_value_new(8); for (jj = 0; jj < count; jj++) { if (strcmp(name, dep_map[jj].widget_name) == 0) { ghb_array_append(array, ghb_value_dup(ghb_string_value(dep_map[jj].dep_name))); } } ghb_dict_insert(top, g_strdup(name), array); } ghb_plist_write_file("widget.deps", top); // reverse map top = ghb_dict_value_new(); for (ii = 0; ii < count; ii++) { const gchar *name; GValue *array; name = dep_map[ii].dep_name; if (ghb_dict_lookup(top, name)) continue; array = ghb_array_value_new(8); for (jj = 0; jj < count; jj++) { if (strcmp(name, dep_map[jj].dep_name) == 0) { GValue *data; data = ghb_array_value_new(3); ghb_array_append(data, ghb_value_dup( ghb_string_value(dep_map[jj].widget_name))); ghb_array_append(data, ghb_value_dup( ghb_string_value(dep_map[jj].enable_value))); ghb_array_append(data, ghb_value_dup( ghb_boolean_value(dep_map[jj].disable_if_equal))); ghb_array_append(data, ghb_value_dup( ghb_boolean_value(dep_map[jj].hide))); ghb_array_append(array, data); } } ghb_dict_insert(top, g_strdup(name), array); } ghb_plist_write_file("widget_reverse.deps", top); return 0; }