X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=gtk%2Fsrc%2Fpresets.c;h=66f69a748badedbb635503cb4b0fa06e12be09fe;hb=bc4ca95f1c72e6e30b9b5df7e809c1ba1abbd308;hp=bb5e2e70f190d0fc2620eee38b9df8be3a125e68;hpb=7d4f3c93ea6ce9de22cf4187b03bb9432e51726c;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/gtk/src/presets.c b/gtk/src/presets.c index bb5e2e70..66f69a74 100644 --- a/gtk/src/presets.c +++ b/gtk/src/presets.c @@ -11,14 +11,20 @@ * any later version. * */ +#include +#include +#include +#include #include #include #include #include #include +#include "hb.h" #include "settings.h" #include "callbacks.h" #include "audiohandler.h" +#include "subtitlehandler.h" #include "hb-backend.h" #include "plist.h" #include "resources.h" @@ -37,10 +43,24 @@ enum static GValue *presetsPlist = NULL; static GValue *internalPlist = NULL; static GValue *prefsPlist = NULL; +static gboolean prefs_modified = FALSE; static const GValue* preset_dict_get_value(GValue *dict, const gchar *key); static void store_plist(GValue *plist, const gchar *name); static void store_presets(void); +static void store_prefs(void); + +gint +preset_path_cmp(gint *indices1, gint len1, gint *indices2, gint len2) +{ + gint ii; + for (ii = 0; ii < len1 && ii < len2; ii++) + { + if (indices1[ii] != indices2[ii]) + return indices1[ii] - indices2[ii]; + } + return len1 - len2; +} // This only handle limited depth GtkTreePath* @@ -139,37 +159,6 @@ ghb_preset_path_string(const GValue *path) return str; } -static void -debug_show_type(GType tp) -{ - const gchar *str = "unknown"; - if (tp == G_TYPE_STRING) - { - str ="string"; - } - else if (tp == G_TYPE_INT) - { - str ="int"; - } - else if (tp == G_TYPE_INT64) - { - str ="int64"; - } - else if (tp == G_TYPE_BOOLEAN) - { - str ="bool"; - } - else if (tp == ghb_array_get_type()) - { - str ="array"; - } - else if (tp == ghb_dict_get_type()) - { - str ="dict"; - } - g_message("Type: %s", str); -} - void dump_preset_path(const gchar *msg, const GValue *path) { @@ -284,6 +273,17 @@ preset_get_name(GValue *dict) return g_value_get_string(preset_dict_get_value(dict, "PresetName")); } +static gboolean +preset_folder_is_open(GValue *dict) +{ + const GValue *gval; + + gval = preset_dict_get_value(dict, "FolderOpen"); + if (gval != NULL) + return g_value_get_boolean(gval); + return FALSE; +} + gboolean ghb_preset_folder(GValue *dict) { @@ -323,8 +323,7 @@ ghb_presets_remove( presets_remove_nth(folder, indices[len-1]); else { - g_warning("ghb_presets_remove ()"); - g_warning("internal preset lookup error"); + g_warning("ghb_presets_remove (): internal preset lookup error"); return FALSE; } return TRUE; @@ -344,8 +343,7 @@ ghb_presets_replace( ghb_array_replace(folder, indices[len-1], dict); else { - g_warning("ghb_presets_replace ()"); - g_warning("internal preset lookup error"); + g_warning("ghb_presets_replace (): internal preset lookup error"); } } @@ -363,8 +361,7 @@ ghb_presets_insert( ghb_array_insert(folder, indices[len-1], dict); else { - g_warning("ghb_presets_insert ()"); - g_warning("internal preset lookup error"); + g_warning("ghb_presets_insert (): internal preset lookup error"); } } @@ -493,6 +490,68 @@ preset_is_default(GValue *dict) return ghb_value_boolean(val); } +static void +presets_clear_default(GValue *presets) +{ + gint count, ii; + + count = ghb_array_len(presets); + for (ii = 0; ii < count; ii++) + { + GValue *dict; + gboolean folder; + + dict = ghb_array_get_nth(presets, ii); + folder = ghb_value_boolean(preset_dict_get_value(dict, "Folder")); + if (folder) + { + GValue *nested; + + nested = ghb_dict_lookup(dict, "ChildrenArray"); + presets_clear_default(nested); + } + else + { + if (preset_is_default(dict)) + { + ghb_dict_insert(dict, g_strdup("Default"), + ghb_boolean_value_new(FALSE)); + } + } + } +} + +static void +presets_customize(GValue *presets) +{ + gint count, ii; + + count = ghb_array_len(presets); + for (ii = 0; ii < count; ii++) + { + GValue *dict; + gboolean folder; + gint ptype; + + dict = ghb_array_get_nth(presets, ii); + + ptype = ghb_value_int(preset_dict_get_value(dict, "Type")); + if (ptype != PRESETS_CUSTOM) + { + ghb_dict_insert(dict, g_strdup("Type"), + ghb_int64_value_new(PRESETS_CUSTOM)); + } + folder = ghb_value_boolean(preset_dict_get_value(dict, "Folder")); + if (folder) + { + GValue *nested; + + nested = ghb_dict_lookup(dict, "ChildrenArray"); + presets_customize(nested); + } + } +} + static gint* presets_find_default2(GValue *presets, gint *len) { @@ -527,7 +586,7 @@ presets_find_default2(GValue *presets, gint *len) { if (preset_is_default(dict)) { - indices = malloc(MAX_NESTED_PRESET * sizeof(gint)); + indices = g_malloc(MAX_NESTED_PRESET * sizeof(gint)); indices[*len] = ii; (*len)++; return indices; @@ -538,10 +597,10 @@ presets_find_default2(GValue *presets, gint *len) } static gint* -presets_find_default(gint *len) +presets_find_default(GValue *presets, gint *len) { *len = 0; - return presets_find_default2(presetsPlist, len); + return presets_find_default2(presets, len); } gint* @@ -606,8 +665,7 @@ ghb_presets_get_type( } else { - g_warning("ghb_presets_get_type ()"); - g_warning("internal preset lookup error"); + g_warning("ghb_presets_get_type (): internal preset lookup error"); } return type; } @@ -628,8 +686,7 @@ ghb_presets_get_folder( } else { - g_warning("ghb_presets_get_folder ()"); - g_warning("internal preset lookup error"); + g_warning("ghb_presets_get_folder (): internal preset lookup error"); } return folder; } @@ -638,19 +695,9 @@ void presets_set_default(gint *indices, gint len) { GValue *dict; - gint *curr_indices, curr_len; g_debug("presets_set_default ()"); - curr_indices = presets_find_default(&curr_len); - if (curr_indices) - { - dict = presets_get_dict(presetsPlist, curr_indices, curr_len); - if (dict) - { - ghb_dict_insert(dict, g_strdup("Default"), - ghb_boolean_value_new(FALSE)); - } - } + presets_clear_default(presetsPlist); dict = presets_get_dict(presetsPlist, indices, len); if (dict) { @@ -659,6 +706,20 @@ presets_set_default(gint *indices, gint len) store_presets(); } +static void +presets_set_folder_open(gboolean open, gint *indices, gint len) +{ + GValue *dict; + + g_debug("presets_set_folder_open ()"); + dict = presets_get_dict(presetsPlist, indices, len); + if (dict) + { + ghb_dict_insert(dict, g_strdup("FolderOpen"), + ghb_boolean_value_new(open)); + } +} + // Used for sorting dictionaries. gint key_cmp(gconstpointer a, gconstpointer b) @@ -846,18 +907,16 @@ preset_to_ui(signal_user_data_t *ud, GValue *dict) init_ui_from_dict(ud, internal, dict); init_ui_from_dict(ud, hidden, dict); - if (ghb_settings_get_boolean(ud->settings, "allow_tweaks")) + if (dict != NULL) { - const GValue *gval; - gval = preset_dict_get_value(dict, "PictureDeinterlace"); - if (gval) - { - ghb_ui_update(ud, "tweak_PictureDeinterlace", gval); - } - gval = preset_dict_get_value(dict, "PictureDenoise"); - if (gval) + GValue *val; + gboolean dd; + + val = ghb_dict_lookup(dict, "PictureDecombDeinterlace"); + if (val != NULL) { - ghb_ui_update(ud, "tweak_PictureDenoise", gval); + dd = ghb_value_boolean(val); + ghb_ui_update(ud, "PictureDeinterlaceDecomb", ghb_boolean_value(!dd)); } } } @@ -870,6 +929,16 @@ ghb_settings_to_ui(signal_user_data_t *ud, GValue *dict) static GValue *current_preset = NULL; +gboolean +ghb_preset_is_custom() +{ + const GValue *val; + + if (current_preset == NULL) return FALSE; + val = preset_dict_get_value(current_preset, "Type"); + return (ghb_value_int(val) == 1); +} + void ghb_set_preset_from_indices(signal_user_data_t *ud, gint *indices, gint len) { @@ -980,7 +1049,7 @@ ghb_select_default_preset(GtkBuilder *builder) gint *indices, len; g_debug("ghb_select_default_preset()"); - indices = presets_find_default(&len); + indices = presets_find_default(presetsPlist, &len); if (indices) { ghb_select_preset2(builder, indices, len); @@ -989,7 +1058,7 @@ ghb_select_default_preset(GtkBuilder *builder) } gchar* -ghb_get_user_config_dir() +ghb_get_user_config_dir(gchar *subdir) { const gchar *dir; gchar *config; @@ -1008,6 +1077,23 @@ ghb_get_user_config_dir() if (!g_file_test(config, G_FILE_TEST_IS_DIR)) g_mkdir (config, 0755); } + if (subdir) + { + gchar **split; + gint ii; + + split = g_strsplit(subdir, G_DIR_SEPARATOR_S, -1); + for (ii = 0; split[ii] != NULL; ii++) + { + gchar *tmp; + + tmp = g_strdup_printf ("%s/%s", config, split[ii]); + g_free(config); + config = tmp; + if (!g_file_test(config, G_FILE_TEST_IS_DIR)) + g_mkdir (config, 0755); + } + } return config; } @@ -1017,7 +1103,7 @@ store_plist(GValue *plist, const gchar *name) gchar *config, *path; FILE *file; - config = ghb_get_user_config_dir(); + config = ghb_get_user_config_dir(NULL); path = g_strdup_printf ("%s/%s", config, name); file = g_fopen(path, "w"); g_free(config); @@ -1032,7 +1118,7 @@ load_plist(const gchar *name) gchar *config, *path; GValue *plist = NULL; - config = ghb_get_user_config_dir(); + config = ghb_get_user_config_dir(NULL); path = g_strdup_printf ("%s/%s", config, name); if (g_file_test(path, G_FILE_TEST_IS_REGULAR)) { @@ -1043,12 +1129,141 @@ load_plist(const gchar *name) return plist; } +gboolean +ghb_lock_file(const gchar *name) +{ +#if !defined(_WIN32) + gchar *config, *path; + int fd, lock = 0; + + config = ghb_get_user_config_dir(NULL); + path = g_strdup_printf ("%s/%s", config, name); + fd = open(path, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR); + if (fd >= 0) + lock = lockf(fd, F_TLOCK, 0); + if (lock) + close(fd); + g_free(config); + g_free(path); + return !lock; +#else + return 1; +#endif +} + +void +ghb_write_pid_file() +{ +#if !defined(_WIN32) + gchar *config, *path; + pid_t pid; + FILE *fp; + int fd, lock; + + pid = getpid(); + + config = ghb_get_user_config_dir(NULL); + path = g_strdup_printf ("%s/ghb.pid.%d", config, pid); + + fp = g_fopen(path, "w"); + fprintf(fp, "%d\n", pid); + fclose(fp); + + fd = open(path, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR); + lock = lockf(fd, F_TLOCK, 0); + + g_free(config); + g_free(path); +#endif +} + +void +ghb_unlink_pid_file(int pid) +{ + gchar *config, *path; + + config = ghb_get_user_config_dir(NULL); + path = g_strdup_printf ("%s/ghb.pid.%d", config, pid); + + if (g_file_test(path, G_FILE_TEST_IS_REGULAR)) + { + g_unlink(path); + } + + g_free(config); + g_free(path); +} + +int +ghb_find_pid_file() +{ + const gchar *file; + gchar *config; + + config = ghb_get_user_config_dir(NULL); + + if (g_file_test(config, G_FILE_TEST_IS_DIR)) + { + GDir *gdir = g_dir_open(config, 0, NULL); + file = g_dir_read_name(gdir); + while (file) + { + if (strncmp(file, "ghb.pid.", 8) == 0) + { + gchar *path; + pid_t my_pid; + int pid; + + sscanf(file, "ghb.pid.%d", &pid); + my_pid = getpid(); + if (my_pid == pid) + { + file = g_dir_read_name(gdir); + continue; + } + path = g_strdup_printf("%s/%s", config, file); + +#if !defined(_WIN32) + int fd, lock = 1; + + fd = open(path, O_RDWR); + if (fd >= 0) + { + lock = lockf(fd, F_TLOCK, 0); + } + if (lock == 0) + { + close(fd); + g_dir_close(gdir); + g_unlink(path); + g_free(path); + g_free(config); + return pid; + } + g_free(path); + close(fd); +#else + g_dir_close(gdir); + g_unlink(path); + g_free(path); + g_free(config); + return pid; +#endif + } + file = g_dir_read_name(gdir); + } + g_dir_close(gdir); + } + g_free(config); + return -1; +} + static void remove_plist(const gchar *name) { gchar *config, *path; - config = ghb_get_user_config_dir(); + config = ghb_get_user_config_dir(NULL); path = g_strdup_printf ("%s/%s", config, name); if (g_file_test(path, G_FILE_TEST_IS_REGULAR)) { @@ -1095,14 +1310,14 @@ ghb_prefs_to_ui(signal_user_data_t *ud) // pointer will break strict-aliasing rules" while (g_hash_table_iter_next( &iter, (gpointer*)(void*)&key, (gpointer*)(void*)&gval)) - { + { const GValue *value = NULL; if (dict) value = ghb_dict_lookup(dict, key); if (value == NULL) value = gval; ghb_settings_set_value(ud->settings, key, value); - } + } internal = plist_get_dict(internalPlist, "Preferences"); ghb_dict_iter_init(&iter, internal); // middle (void*) cast prevents gcc warning "defreferencing type-punned @@ -1133,13 +1348,15 @@ ghb_prefs_to_ui(signal_user_data_t *ud) ghb_ui_update(ud, "hbfd", ghb_int64_value(0)); } gval = ghb_settings_get_value(ud->settings, "default_source"); - ghb_settings_set_value (ud->settings, "source", gval); + ghb_settings_set_value (ud->settings, "scan_source", gval); + str = ghb_settings_get_string(ud->settings, "destination_dir"); + ghb_ui_update(ud, "dest_dir", ghb_string_value(str)); - gchar *path = g_strdup_printf ("%s/new_video.mp4", str); - ghb_ui_update(ud, "destination", ghb_string_value(path)); + gchar *file = g_strdup_printf ("new_video.mp4"); + ghb_ui_update(ud, "dest_file", ghb_string_value(file)); g_free(str); - g_free(path); + g_free(file); prefs_initializing = FALSE; } @@ -1163,20 +1380,43 @@ ghb_prefs_save(GValue *settings) // pointer will break strict-aliasing rules" while (g_hash_table_iter_next( &iter, (gpointer*)(void*)&key, (gpointer*)(void*)&value)) - { - value = ghb_settings_get_value(settings, key); - if (value != NULL) - { + { + value = ghb_settings_get_value(settings, key); + if (value != NULL) + { ghb_dict_insert(pref_dict, g_strdup(key), ghb_value_dup(value)); - } + } + } + store_prefs(); + prefs_modified = FALSE; +} + +void +ghb_pref_set(GValue *settings, const gchar *key) +{ + const GValue *value, *value2; + + if (prefs_initializing) return; + value = ghb_settings_get_value(settings, key); + if (value != NULL) + { + GValue *dict; + dict = plist_get_dict(prefsPlist, "Preferences"); + if (dict == NULL) return; + value2 = ghb_dict_lookup(dict, key); + if (ghb_value_cmp(value, value2) != 0) + { + ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(value)); + store_prefs(); + prefs_modified = TRUE; + } } - store_plist(prefsPlist, "preferences"); } void ghb_pref_save(GValue *settings, const gchar *key) { - const GValue *value; + const GValue *value, *value2; if (prefs_initializing) return; value = ghb_settings_get_value(settings, key); @@ -1185,8 +1425,23 @@ ghb_pref_save(GValue *settings, const gchar *key) GValue *dict; dict = plist_get_dict(prefsPlist, "Preferences"); if (dict == NULL) return; - ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(value)); - store_plist(prefsPlist, "preferences"); + value2 = ghb_dict_lookup(dict, key); + if (ghb_value_cmp(value, value2) != 0) + { + ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(value)); + store_prefs(); + prefs_modified = FALSE; + } + } +} + +void +ghb_prefs_store(void) +{ + if (prefs_modified) + { + store_prefs(); + prefs_modified = FALSE; } } @@ -1251,6 +1506,34 @@ ghb_settings_close() ghb_value_free(prefsPlist); } +#if defined(_WIN32) +gchar* +FindFirstCDROM(void) +{ + gint ii, drives; + gchar drive[5]; + + strcpy(drive, "A:" G_DIR_SEPARATOR_S); + drives = GetLogicalDrives(); + for (ii = 0; ii < 26; ii++) + { + if (drives & 0x01) + { + guint dtype; + + drive[0] = 'A' + ii; + dtype = GetDriveType(drive); + if (dtype == DRIVE_CDROM) + { + return g_strdup(drive); + } + } + drives >>= 1; + } + return NULL; +} +#endif + void ghb_prefs_load(signal_user_data_t *ud) { @@ -1265,29 +1548,53 @@ ghb_prefs_load(signal_user_data_t *ud) prefsPlist = ghb_dict_value_new(); dict = plist_get_dict(prefsPlist, "Preferences"); internal = plist_get_dict(internalPlist, "Preferences"); - if (dict == NULL && internal) - { + if (dict == NULL && internal) + { dict = ghb_dict_value_new(); ghb_dict_insert(prefsPlist, g_strdup("Preferences"), dict); - // Get defaults from internal defaults + // Get defaults from internal defaults ghb_dict_iter_init(&iter, internal); // middle (void*) cast prevents gcc warning "defreferencing type-punned // pointer will break strict-aliasing rules" while (g_hash_table_iter_next( &iter, (gpointer*)(void*)&key, (gpointer*)(void*)&gval)) - { + { ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(gval)); - } - const gchar *dir = g_get_user_special_dir (G_USER_DIRECTORY_VIDEOS); + } + + const gchar *dir = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP); + if (dir == NULL) + { + dir = "."; + } + ghb_dict_insert(dict, + g_strdup("ExportDirectory"), ghb_value_dup(ghb_string_value(dir))); + + dir = g_get_user_special_dir (G_USER_DIRECTORY_VIDEOS); if (dir == NULL) { dir = "."; } ghb_dict_insert(dict, g_strdup("destination_dir"), ghb_value_dup(ghb_string_value(dir))); - store_plist(prefsPlist, "preferences"); - } + + ghb_dict_insert(dict, + g_strdup("SrtDir"), ghb_value_dup(ghb_string_value(dir))); +#if defined(_WIN32) + gchar *source; + + source = FindFirstCDROM(); + if (source == NULL) + { + source = g_strdup("C:" G_DIR_SEPARATOR_S); + } + ghb_dict_insert(dict, g_strdup("default_source"), + ghb_value_dup(ghb_string_value(source))); + g_free(source); +#endif + store_prefs(); + } // Read legacy default_preset preference and update accordingly path = ghb_dict_lookup(dict, "default_preset"); if (path) @@ -1312,7 +1619,7 @@ ghb_prefs_load(signal_user_data_t *ud) g_free(indices); } ghb_dict_remove(dict, "default_preset"); - store_plist(prefsPlist, "preferences"); + store_prefs(); } } @@ -1404,6 +1711,7 @@ ghb_presets_list_init( 2, def ? 2 : 0, 3, color, 4, description, + 5, type == PRESETS_BUILTIN ? 0 : 1, -1); if (def && piter) { @@ -1424,6 +1732,20 @@ ghb_presets_list_init( if (folder) { ghb_presets_list_init(ud, more_indices, len+1); + if (preset_folder_is_open(dict)) + { + GtkTreePath *path; + + if (piter != NULL) + { + path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), piter); + gtk_tree_view_expand_row(treeview, path, FALSE); + gtk_tree_path_free(path); + } + path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter); + gtk_tree_view_expand_row(treeview, path, FALSE); + gtk_tree_path_free(path); + } } } g_free(more_indices); @@ -1433,7 +1755,8 @@ static void presets_list_update_item( signal_user_data_t *ud, gint *indices, - gint len) + gint len, + gboolean recurse) { GtkTreeView *treeview; GtkTreeStore *store; @@ -1467,8 +1790,9 @@ presets_list_update_item( 2, def ? 2 : 0, 3, color, 4, description, + 5, type == PRESETS_BUILTIN ? 0 : 1, -1); - if (folder) + if (recurse && folder) { ghb_presets_list_init(ud, indices, len); } @@ -1531,6 +1855,7 @@ presets_list_insert( 2, def ? 2 : 0, 3, color, 4, description, + 5, type == PRESETS_BUILTIN ? 0 : 1, -1); if (folder) { @@ -1588,19 +1913,61 @@ remove_std_presets(signal_user_data_t *ud) void ghb_save_queue(GValue *queue) { - store_plist(queue, "queue"); + pid_t pid; + char *path; + + pid = getpid(); + path = g_strdup_printf ("queue.%d", pid); + store_plist(queue, path); + g_free(path); } GValue* ghb_load_queue() { - return load_plist("queue"); + GValue *queue; + pid_t pid; + char *path; + + pid = getpid(); + path = g_strdup_printf ("queue.%d", pid); + queue = load_plist(path); + g_free(path); + return queue; } -void +GValue* +ghb_load_old_queue(int pid) +{ + GValue *queue; + char *path; + + path = g_strdup_printf ("queue.%d", pid); + queue = load_plist(path); + g_free(path); + return queue; +} + +void +ghb_remove_old_queue_file(int pid) +{ + char *path; + + path = g_strdup_printf ("queue.%d", pid); + remove_plist(path); + g_free(path); +} + +void ghb_remove_queue_file() { - remove_plist("queue"); + pid_t pid; + char *path; + + pid = getpid(); + path = g_strdup_printf ("queue.%d", pid); + remove_plist(path); + g_free(path); } typedef struct @@ -1612,7 +1979,7 @@ typedef struct static value_map_t vcodec_xlat[] = { {"MPEG-4 (FFmpeg)", "ffmpeg"}, - {"MPEG-4 (XviD)", "xvid"}, + {"MPEG-4 (XviD)", "ffmpeg"}, {"H.264 (x264)", "x264"}, {"VP3 (Theora)", "theora"}, {NULL,NULL} @@ -1621,6 +1988,7 @@ static value_map_t vcodec_xlat[] = static value_map_t acodec_xlat[] = { {"AAC (faac)", "faac"}, + {"AAC (CoreAudio)", "faac"}, {"AC3 Passthru", "ac3"}, {"MP3 (lame)", "lame"}, {"Vorbis (vorbis)", "vorbis"}, @@ -1630,10 +1998,10 @@ static value_map_t acodec_xlat[] = value_map_t container_xlat[] = { {"MP4 file", "mp4"}, - {"M4V file", "m4v"}, + {"M4V file", "mp4"}, {"MKV file", "mkv"}, - {"AVI file", "avi"}, - {"OGM file", "ogm"}, + {"AVI file", "mkv"}, + {"OGM file", "mkv"}, {NULL, NULL} }; @@ -1675,19 +2043,37 @@ value_map_t mix_xlat[] = value_map_t deint_xlat[] = { - {"0", "none"}, - {"1", "fast"}, - {"2", "slow"}, - {"3", "slower"}, + {"0", "off"}, + {"1", "custom"}, + {"2", "fast"}, + {"3", "slow"}, + {"4", "slower"}, {NULL, NULL} }; value_map_t denoise_xlat[] = { - {"0", "none"}, - {"1", "weak"}, - {"2", "medium"}, - {"3", "strong"}, + {"0", "off"}, + {"1", "custom"}, + {"2", "weak"}, + {"3", "medium"}, + {"4", "strong"}, + {NULL, NULL} +}; + +value_map_t detel_xlat[] = +{ + {"0", "off"}, + {"1", "custom"}, + {"2", "default"}, + {NULL, NULL} +}; + +value_map_t decomb_xlat[] = +{ + {"0", "off"}, + {"1", "custom"}, + {"2", "default"}, {NULL, NULL} }; @@ -1707,7 +2093,14 @@ export_lang_xlat2(GValue *lin_val) { if (strcmp(str, ghb_language_table[ii].iso639_2) == 0) { - gval = ghb_string_value_new(ghb_language_table[ii].eng_name); + const gchar *lang; + + if (ghb_language_table[ii].native_name[0] != 0) + lang = ghb_language_table[ii].native_name; + else + lang = ghb_language_table[ii].eng_name; + + gval = ghb_string_value_new(lang); g_free(str); return gval; } @@ -1723,6 +2116,7 @@ export_subtitle_xlat2(GValue *lin_val) gchar *str; GValue *gval; + if (lin_val == NULL) return NULL; str = ghb_value_string(lin_val); if (strcmp(str, "none") == 0) { @@ -1752,7 +2146,8 @@ import_lang_xlat2(GValue *mac_val) str = ghb_value_string(mac_val); for (ii = 0; ghb_language_table[ii].eng_name; ii++) { - if (strcmp(str, ghb_language_table[ii].eng_name) == 0) + if ((strcmp(str, ghb_language_table[ii].eng_name) == 0) || + (strcmp(str, ghb_language_table[ii].native_name) == 0)) { gval = ghb_string_value_new(ghb_language_table[ii].iso639_2); g_free(str); @@ -1770,6 +2165,7 @@ import_subtitle_xlat2(GValue *mac_val) gchar *str; GValue *gval; + if (mac_val == NULL) return NULL; str = ghb_value_string(mac_val); if (strcmp(str, "None") == 0) { @@ -1793,6 +2189,7 @@ export_audio_track_xlat2(GValue *lin_val) gchar *str; GValue *gval = NULL; + if (lin_val == NULL) return NULL; str = ghb_value_string(lin_val); if (strcmp(str, "none") == 0) { @@ -1814,6 +2211,7 @@ import_audio_track_xlat2(GValue *mac_val) gchar *str; GValue *gval; + if (mac_val == NULL) return NULL; val = ghb_value_int(mac_val); if (val <= 0) { @@ -1884,29 +2282,45 @@ export_value_xlat(GValue *dict) gval = export_value_xlat2(framerate_xlat, lin_val, G_TYPE_STRING); if (gval) ghb_dict_insert(dict, g_strdup(key), gval); + key = "PictureDetelecine"; + lin_val = ghb_dict_lookup(dict, key); + gval = export_value_xlat2(detel_xlat, lin_val, G_TYPE_INT); + if (gval) + ghb_dict_insert(dict, g_strdup(key), gval); + key = "PictureDecomb"; + lin_val = ghb_dict_lookup(dict, key); + gval = export_value_xlat2(decomb_xlat, lin_val, G_TYPE_INT); + if (gval) + ghb_dict_insert(dict, g_strdup(key), gval); key = "PictureDeinterlace"; lin_val = ghb_dict_lookup(dict, key); gval = export_value_xlat2(deint_xlat, lin_val, G_TYPE_INT); if (gval) ghb_dict_insert(dict, g_strdup(key), gval); - else - ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(lin_val)); key = "PictureDenoise"; lin_val = ghb_dict_lookup(dict, key); gval = export_value_xlat2(denoise_xlat, lin_val, G_TYPE_INT); if (gval) ghb_dict_insert(dict, g_strdup(key), gval); - else - ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(lin_val)); - key = "Subtitles"; - lin_val = ghb_dict_lookup(dict, key); - gval = export_subtitle_xlat2(lin_val); - if (gval) - ghb_dict_insert(dict, g_strdup(key), gval); + + GValue *slist; + GValue *sdict; + gint count, ii; + + slist = ghb_dict_lookup(dict, "SubtitleList"); + count = ghb_array_len(slist); + for (ii = 0; ii < count; ii++) + { + sdict = ghb_array_get_nth(slist, ii); + key = "SubtitleLanguage"; + lin_val = ghb_dict_lookup(sdict, key); + gval = export_subtitle_xlat2(lin_val); + if (gval) + ghb_dict_insert(sdict, g_strdup(key), gval); + } GValue *alist; GValue *adict; - gint count, ii; alist = ghb_dict_lookup(dict, "AudioList"); count = ghb_array_len(alist); @@ -1973,13 +2387,34 @@ import_value_xlat2( return gval; } } - //g_warning("Can't map value: (%s)", str); g_free(str); } else { - g_warning("Bad key: (%s)", key); - return NULL; + gint ii; + gchar *str; + GValue *sval; + + str = ghb_value_string(mac_val); + for (ii = 0; value_map[ii].mac_val; ii++) + { + if (strcmp(str, value_map[ii].mac_val) == 0) + { + sval = ghb_string_value_new(value_map[ii].lin_val); + g_free(str); + gval = ghb_value_new(G_VALUE_TYPE(mac_val)); + if (!g_value_transform(sval, gval)) + { + g_warning("can't transform"); + ghb_value_free(gval); + ghb_value_free(sval); + return NULL; + } + ghb_value_free(sval); + return gval; + } + } + g_free(str); } return NULL; } @@ -2006,6 +2441,16 @@ import_value_xlat(GValue *dict) gval = import_value_xlat2(defaults, framerate_xlat, key, mac_val); if (gval) ghb_dict_insert(dict, g_strdup(key), gval); + key = "PictureDetelecine"; + mac_val = ghb_dict_lookup(dict, key); + gval = import_value_xlat2(defaults, detel_xlat, key, mac_val); + if (gval) + ghb_dict_insert(dict, g_strdup(key), gval); + key = "PictureDecomb"; + mac_val = ghb_dict_lookup(dict, key); + gval = import_value_xlat2(defaults, decomb_xlat, key, mac_val); + if (gval) + ghb_dict_insert(dict, g_strdup(key), gval); key = "PictureDeinterlace"; mac_val = ghb_dict_lookup(dict, key); gval = import_value_xlat2(defaults, deint_xlat, key, mac_val); @@ -2016,19 +2461,85 @@ import_value_xlat(GValue *dict) gval = import_value_xlat2(defaults, denoise_xlat, key, mac_val); if (gval) ghb_dict_insert(dict, g_strdup(key), gval); - key = "Subtitles"; - mac_val = ghb_dict_lookup(dict, key); - gval = import_subtitle_xlat2(mac_val); - if (gval) - ghb_dict_insert(dict, g_strdup(key), gval); + + + GValue *sdeflist; + GValue *sdefaults; + GValue *slist; + GValue *sdict; + gint count, ii; + + sdeflist = ghb_dict_lookup(defaults, "SubtitleList"); + if (sdeflist) + { + slist = ghb_dict_lookup(dict, "SubtitleList"); + if (slist) + { + sdefaults = ghb_array_get_nth(sdeflist, 0); + count = ghb_array_len(slist); + for (ii = 0; ii < count; ii++) + { + sdict = ghb_array_get_nth(slist, ii); + key = "SubtitleLanguage"; + mac_val = ghb_dict_lookup(sdict, key); + gval = import_subtitle_xlat2(mac_val); + if (gval) + ghb_dict_insert(sdict, g_strdup(key), gval); + } + + } + else + { + key = "Subtitles"; + mac_val = ghb_dict_lookup(dict, key); + slist = ghb_array_value_new(8); + ghb_dict_insert(dict, g_strdup("SubtitleList"), slist); + if (mac_val) + { + gchar *lang; + + gval = import_subtitle_xlat2(mac_val); + lang = ghb_value_string(gval); + if (lang && strcasecmp(lang, "none") != 0 && !slist) + { + sdict = ghb_dict_value_new(); + ghb_array_append(slist, sdict); + ghb_dict_insert(sdict, g_strdup("SubtitleLanguage"), gval); + gval = ghb_dict_lookup(dict, "SubtitlesForced"); + if (gval != NULL) + { + ghb_dict_insert(sdict, g_strdup("SubtitleForced"), + ghb_value_dup(gval)); + } + else + { + ghb_dict_insert(sdict, g_strdup("SubtitleForced"), + ghb_boolean_value_new(FALSE)); + } + ghb_dict_insert(sdict, g_strdup("SubtitleBurned"), + ghb_boolean_value_new(TRUE)); + ghb_dict_insert(sdict, g_strdup("SubtitleDefaultTrack"), + ghb_boolean_value_new(FALSE)); + } + else + { + ghb_value_free(gval); + } + if (lang) + g_free(lang); + } + } + } + ghb_dict_remove(dict, "Subtitles"); + ghb_dict_remove(dict, "SubtitlesForced"); + GValue *alist; GValue *adict; GValue *adefaults; GValue *adeflist; - gint count, ii; - adeflist = ghb_dict_lookup(dict, "AudioList"); + adeflist = ghb_dict_lookup(defaults, "AudioList"); if (adeflist) { adefaults = ghb_array_get_nth(adeflist, 0); @@ -2057,6 +2568,18 @@ import_value_xlat(GValue *dict) gval = import_value_xlat2(adefaults, mix_xlat, key, mac_val); if (gval) ghb_dict_insert(adict, g_strdup(key), gval); + + mac_val = ghb_dict_lookup(adict, "AudioTrackDRCSlider"); + if (mac_val != NULL) + { + gdouble drc; + drc = ghb_value_double(mac_val); + if (drc < 1.0 && drc > 0.0) + { + ghb_dict_insert(adict, g_strdup("AudioTrackDRCSlider"), + ghb_double_value_new(0.0)); + } + } } } } @@ -2086,32 +2609,26 @@ import_xlat_preset(GValue *dict) { case 0: { - ghb_dict_insert(dict, g_strdup("anamorphic"), - ghb_boolean_value_new(FALSE)); - if (ghb_dict_lookup(dict, "ModDimensions") == NULL) - ghb_dict_insert(dict, g_strdup("ModDimensions"), - ghb_boolean_value_new(TRUE)); + if (ghb_dict_lookup(dict, "PictureModulus") == NULL) + ghb_dict_insert(dict, g_strdup("PictureModulus"), + ghb_int_value_new(16)); } break; case 1: { - ghb_dict_insert(dict, g_strdup("anamorphic"), - ghb_boolean_value_new(TRUE)); - ghb_dict_insert(dict, g_strdup("ModDimensions"), - ghb_boolean_value_new(FALSE)); + ghb_dict_insert(dict, g_strdup("PictureModulus"), + ghb_int_value_new(1)); } break; case 2: { - ghb_dict_insert(dict, g_strdup("anamorphic"), - ghb_boolean_value_new(TRUE)); - ghb_dict_insert(dict, g_strdup("ModDimensions"), - ghb_boolean_value_new(TRUE)); + if (ghb_dict_lookup(dict, "PictureModulus") == NULL) + ghb_dict_insert(dict, g_strdup("PictureModulus"), + ghb_int_value_new(16)); } break; default: { - ghb_dict_insert(dict, g_strdup("anamorphic"), - ghb_boolean_value_new(TRUE)); - ghb_dict_insert(dict, g_strdup("ModDimensions"), - ghb_boolean_value_new(TRUE)); + if (ghb_dict_lookup(dict, "PictureModulus") == NULL) + ghb_dict_insert(dict, g_strdup("PictureModulus"), + ghb_int_value_new(16)); } break; } // VideoQualityType/0/1/2 - vquality_type_/target/bitrate/constant @@ -2155,6 +2672,42 @@ import_xlat_preset(GValue *dict) } break; } import_value_xlat(dict); + + gdouble vquality; + const GValue *gval; + + vquality = ghb_value_double(preset_dict_get_value(dict, "VideoQualitySlider")); + if (vquality > 0.0 && vquality < 1.0) + { + gint vcodec; + + gval = preset_dict_get_value(dict, "VideoEncoder"); + vcodec = ghb_lookup_combo_int("VideoEncoder", gval); + switch (vcodec) + { + case HB_VCODEC_X264: + { + vquality = 51. - vquality * 51.; + } break; + + case HB_VCODEC_FFMPEG: + { + vquality = 31. - vquality * 30.; + } break; + + case HB_VCODEC_THEORA: + { + vquality = vquality * 63.; + } break; + + default: + { + vquality = 0.; + } break; + } + ghb_dict_insert(dict, g_strdup("VideoQualitySlider"), + ghb_double_value_new(vquality)); + } } static void @@ -2188,12 +2741,10 @@ import_xlat_presets(GValue *presets) static void export_xlat_preset(GValue *dict) { - gboolean ana, round, autoscale, target, br, constant; + gboolean autoscale, target, br, constant; g_debug("export_xlat_prest ()"); autoscale = ghb_value_boolean(preset_dict_get_value(dict, "autoscale")); - ana = ghb_value_boolean(preset_dict_get_value(dict, "anamorphic")); - round = ghb_value_boolean(preset_dict_get_value(dict, "ModDimensions")); target = ghb_value_boolean( preset_dict_get_value(dict, "vquality_type_target")); br = ghb_value_boolean( @@ -2208,20 +2759,6 @@ export_xlat_preset(GValue *dict) ghb_dict_insert(dict, g_strdup("UsesPictureSettings"), ghb_int_value_new(1)); - if (ana) - { - if (round) - ghb_dict_insert(dict, g_strdup("PicturePAR"), - ghb_int_value_new(2)); - else - ghb_dict_insert(dict, g_strdup("PicturePAR"), - ghb_int_value_new(1)); - } - else - { - ghb_dict_insert(dict, g_strdup("PicturePAR"), - ghb_int_value_new(0)); - } // VideoQualityType/0/1/2 - vquality_type_/target/bitrate/constant if (target) { @@ -2238,8 +2775,28 @@ export_xlat_preset(GValue *dict) ghb_dict_insert(dict, g_strdup("VideoQualityType"), ghb_int_value_new(2)); } + + GValue *alist, *adict; + gint count, ii; + + alist = ghb_dict_lookup(dict, "AudioList"); + count = ghb_array_len(alist); + for (ii = 0; ii < count; ii++) + { + gdouble drc; + + adict = ghb_array_get_nth(alist, ii); + drc = ghb_value_double( + preset_dict_get_value(adict, "AudioTrackDRCSlider")); + if (drc < 1.0 && drc > 0.0) + { + ghb_dict_insert(adict, g_strdup("AudioTrackDRCSlider"), + ghb_double_value_new(0.0)); + } + } + + ghb_dict_remove(dict, "UsesMaxPictureSettings"); ghb_dict_remove(dict, "autoscale"); - ghb_dict_remove(dict, "anamorphic"); ghb_dict_remove(dict, "vquality_type_target"); ghb_dict_remove(dict, "vquality_type_bitrate"); ghb_dict_remove(dict, "vquality_type_constant"); @@ -2273,6 +2830,16 @@ export_xlat_presets(GValue *presets) } } +static guint prefs_timeout_id = 0; + +static gboolean +delayed_store_prefs(gpointer data) +{ + store_plist(prefsPlist, "preferences"); + prefs_timeout_id = 0; + return FALSE; +} + static void store_presets() { @@ -2284,130 +2851,253 @@ store_presets() ghb_value_free(export); } +static void +store_prefs(void) +{ + if (prefs_timeout_id != 0) + { + GMainContext *mc; + GSource *source; + + mc = g_main_context_default(); + source = g_main_context_find_source_by_id(mc, prefs_timeout_id); + if (source != NULL) + g_source_destroy(source); + } + prefs_timeout_id = g_timeout_add_seconds(1, (GSourceFunc)delayed_store_prefs, NULL); +} + void ghb_presets_reload(signal_user_data_t *ud) { GValue *std_presets; gint count, ii; + int *indices, len; g_debug("ghb_presets_reload()\n"); std_presets = ghb_resource_get("standard-presets"); if (std_presets == NULL) return; remove_std_presets(ud); + indices = presets_find_default(presetsPlist, &len); + if (indices) + { + presets_clear_default(std_presets); + g_free(indices); + } // Merge the keyfile contents into our presets count = ghb_array_len(std_presets); for (ii = count-1; ii >= 0; ii--) { GValue *std_dict; GValue *copy_dict; - GHashTableIter iter; - gchar *key; - GValue *value; gint indices = 0; std_dict = ghb_array_get_nth(std_presets, ii); - copy_dict = ghb_dict_value_new(); + copy_dict = ghb_value_dup(std_dict); + ghb_dict_insert(copy_dict, g_strdup("PresetBuildNumber"), + ghb_int64_value_new(hb_get_build(NULL))); ghb_presets_insert(presetsPlist, copy_dict, &indices, 1); - ghb_dict_iter_init(&iter, std_dict); - // middle (void*) cast prevents gcc warning "defreferencing - // type-punned pointer will break strict-aliasing rules" - while (g_hash_table_iter_next( - &iter, (gpointer*)(void*)&key, (gpointer*)(void*)&value)) - { - ghb_dict_insert(copy_dict, g_strdup(key), ghb_value_dup(value)); - } presets_list_insert(ud, &indices, 1); } import_xlat_presets(presetsPlist); store_presets(); } -void -ghb_presets_load() +static gboolean +check_old_presets() { - presetsPlist = load_plist("presets"); - if (presetsPlist == NULL) + gint count, ii; + + count = ghb_array_len(presetsPlist); + for (ii = count-1; ii >= 0; ii--) { - presetsPlist = ghb_value_dup(ghb_resource_get("standard-presets")); - store_presets(); - } - else if (G_VALUE_TYPE(presetsPlist) == ghb_dict_get_type()) - { // Presets is older dictionary format. Convert to array - ghb_value_free(presetsPlist); - presetsPlist = ghb_value_dup(ghb_resource_get("standard-presets")); - store_presets(); + GValue *dict; + GValue *type; + + dict = ghb_array_get_nth(presetsPlist, ii); + type = ghb_dict_lookup(dict, "Type"); + if (type == NULL) + return TRUE; } - import_xlat_presets(presetsPlist); + return FALSE; } static void -settings_save(signal_user_data_t *ud, const GValue *path) +replace_standard_presets() { - GValue *dict, *internal; - GHashTableIter iter; - gchar *key; - GValue *value; - gboolean autoscale; - gint *indices, len, count; - const gchar *name; - gboolean replace = FALSE; + GValue *std_presets; + int *indices, len; + gint count, ii; - g_debug("settings_save"); - if (internalPlist == NULL) return; - count = ghb_array_len(path); - name = g_value_get_string(ghb_array_get_nth(path, count-1)); - indices = ghb_preset_indices_from_path(presetsPlist, path, &len); - if (indices) + count = ghb_array_len(presetsPlist); + for (ii = count-1; ii >= 0; ii--) { - if (ghb_presets_get_folder(presetsPlist, indices, len)) + GValue *dict; + gint ptype; + + dict = ghb_array_get_nth(presetsPlist, ii); + ptype = ghb_value_int(preset_dict_get_value(dict, "Type")); + if (ptype == PRESETS_BUILTIN) { - gchar *message; - message = g_strdup_printf( - "%s: Folder already exists.\n" - "You can not replace it with a preset.", - name); - ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL); - g_free(message); - return; + gint indices = 0; + ghb_presets_remove(presetsPlist, &indices, 1); } - dict = ghb_dict_value_new(); - ghb_presets_replace(presetsPlist, dict, indices, len); - replace = TRUE; } - else + + std_presets = ghb_resource_get("standard-presets"); + if (std_presets == NULL) return; + + indices = presets_find_default(presetsPlist, &len); + if (indices) { - indices = presets_find_pos(path, PRESETS_CUSTOM, &len); - if (indices) - { - dict = ghb_dict_value_new(); - ghb_presets_insert(presetsPlist, dict, indices, len); - } - else - { - g_warning("failed to find insert path"); - return; - } + presets_clear_default(std_presets); + g_free(indices); } - - if (ghb_settings_get_boolean(ud->settings, "allow_tweaks")) + // Merge the keyfile contents into our presets + count = ghb_array_len(std_presets); + for (ii = count-1; ii >= 0; ii--) { - gchar *str; - str = ghb_settings_get_string(ud->settings, "tweak_PictureDeinterlace"); - if (str) - { - ghb_settings_set_string(ud->settings, "PictureDeinterlace", str); - g_free(str); + GValue *std_dict; + GValue *copy_dict; + gint indices = 0; + + std_dict = ghb_array_get_nth(std_presets, ii); + copy_dict = ghb_value_dup(std_dict); + ghb_dict_insert(copy_dict, g_strdup("PresetBuildNumber"), + ghb_int64_value_new(hb_get_build(NULL))); + ghb_presets_insert(presetsPlist, copy_dict, &indices, 1); + } + import_xlat_presets(presetsPlist); + store_presets(); +} + +static void +update_standard_presets(signal_user_data_t *ud) +{ + gint count, ii; + + count = ghb_array_len(presetsPlist); + for (ii = count-1; ii >= 0; ii--) + { + GValue *dict; + const GValue *gval; + gint64 build; + gint type; + + dict = ghb_array_get_nth(presetsPlist, ii); + gval = ghb_dict_lookup(dict, "Type"); + if (gval == NULL) + { + // Old preset that doesn't have a Type + replace_standard_presets(); + return; } - str = ghb_settings_get_string(ud->settings, "tweak_PictureDenoise"); - if (str) + + type = ghb_value_int(gval); + if (type == 0) { - ghb_settings_set_string(ud->settings, "PictureDenoise", str); - g_free(str); + gval = ghb_dict_lookup(dict, "PresetBuildNumber"); + if (gval == NULL) + { + // Old preset that doesn't have a build number + replace_standard_presets(); + return; + } + + build = ghb_value_int64(gval); + if (build != hb_get_build(NULL)) + { + // Build number does not match + replace_standard_presets(); + return; + } + } + } + return; +} + +void +ghb_presets_load(signal_user_data_t *ud) +{ + presetsPlist = load_plist("presets"); + if (presetsPlist == NULL) + { + presetsPlist = ghb_value_dup(ghb_resource_get("standard-presets")); + import_xlat_presets(presetsPlist); + store_presets(); + } + else if (G_VALUE_TYPE(presetsPlist) == ghb_dict_get_type()) + { // Presets is older dictionary format. Convert to array + ghb_value_free(presetsPlist); + presetsPlist = ghb_value_dup(ghb_resource_get("standard-presets")); + import_xlat_presets(presetsPlist); + store_presets(); + } + else if (check_old_presets()) + { + ghb_value_free(presetsPlist); + presetsPlist = ghb_value_dup(ghb_resource_get("standard-presets")); + import_xlat_presets(presetsPlist); + store_presets(); + } + update_standard_presets(ud); + import_xlat_presets(presetsPlist); +} + +static void +settings_save(signal_user_data_t *ud, const GValue *path) +{ + GValue *dict, *internal; + GHashTableIter iter; + gchar *key; + GValue *value; + gboolean autoscale; + gint *indices, len, count; + gint *def_indices, def_len; + const gchar *name; + gboolean replace = FALSE; + + g_debug("settings_save"); + if (internalPlist == NULL) return; + count = ghb_array_len(path); + name = g_value_get_string(ghb_array_get_nth(path, count-1)); + indices = ghb_preset_indices_from_path(presetsPlist, path, &len); + if (indices) + { + if (ghb_presets_get_folder(presetsPlist, indices, len)) + { + gchar *message; + message = g_strdup_printf( + "%s: Folder already exists.\n" + "You can not replace it with a preset.", + name); + ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL); + g_free(message); + return; + } + dict = ghb_dict_value_new(); + ghb_presets_replace(presetsPlist, dict, indices, len); + replace = TRUE; + } + else + { + indices = presets_find_pos(path, PRESETS_CUSTOM, &len); + if (indices) + { + dict = ghb_dict_value_new(); + ghb_presets_insert(presetsPlist, dict, indices, len); + } + else + { + g_warning("failed to find insert path"); + return; } } + current_preset = dict; autoscale = ghb_settings_get_boolean(ud->settings, "autoscale"); ghb_settings_set_int64(ud->settings, "Type", PRESETS_CUSTOM); + ghb_settings_set_int64(ud->settings, "PresetBuildNumber", hb_get_build(NULL)); internal = plist_get_dict(internalPlist, "Presets"); ghb_dict_iter_init(&iter, internal); @@ -2456,7 +3146,16 @@ settings_save(signal_user_data_t *ud, const GValue *path) } ghb_dict_insert(dict, g_strdup("PresetName"), ghb_string_value_new(name)); if (replace) - presets_list_update_item(ud, indices, len); + { + def_indices = presets_find_default(presetsPlist, &def_len); + if (def_indices != NULL && + preset_path_cmp(indices, len, def_indices, def_len) != 0) + { + ghb_dict_insert(dict, g_strdup("Default"), + ghb_boolean_value_new(FALSE)); + } + presets_list_update_item(ud, indices, len, FALSE); + } else { ghb_dict_insert(dict, g_strdup("Default"), @@ -2501,7 +3200,9 @@ folder_save(signal_user_data_t *ud, const GValue *path) ghb_dict_insert(dict, g_strdup("PresetDescription"), ghb_value_dup(preset_dict_get_value( ud->settings, "PresetDescription"))); + presets_list_update_item(ud, indices, len, FALSE); g_free(indices); + store_presets(); return; } else @@ -2546,7 +3247,7 @@ ghb_presets_list_default(signal_user_data_t *ud) g_debug("ghb_presets_list_default ()"); treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "presets_list")); store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview)); - indices = presets_find_default(&len); + indices = presets_find_default(presetsPlist, &len); if (indices == NULL) return; treepath = ghb_tree_path_new_from_indices(indices, len); if (treepath) @@ -2575,7 +3276,7 @@ ghb_presets_list_clear_default(signal_user_data_t *ud) g_debug("ghb_presets_list_clear_default ()"); treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "presets_list")); store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview)); - indices = presets_find_default(&len); + indices = presets_find_default(presetsPlist, &len); if (indices == NULL) return; treepath = ghb_tree_path_new_from_indices(indices, len); if (treepath) @@ -2602,45 +3303,247 @@ update_audio_presets(signal_user_data_t *ud) ghb_settings_set_value(ud->settings, "AudioList", audio_list); } -void -enforce_preset_type(signal_user_data_t *ud, const GValue *path) +static void +update_subtitle_presets(signal_user_data_t *ud) { - gint *indices, len; - GtkWidget *normal, *folder; - gboolean fold; + g_debug("update_subtitle_presets"); + const GValue *subtitle_list, *subtitle; + GValue *slist, *dict; + gint count, ii, source; + + subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list"); + slist = ghb_array_value_new(8); + count = ghb_array_len(subtitle_list); + for (ii = 0; ii < count; ii++) + { + subtitle = ghb_array_get_nth(subtitle_list, ii); + source = ghb_settings_get_int(subtitle, "SubtitleSource"); + if (source != SRTSUB) + { + dict = ghb_value_dup(subtitle); + ghb_array_append(slist, dict); + } + } + ghb_settings_take_value(ud->settings, "SubtitleList", slist); +} - normal = GHB_WIDGET(ud->builder, "preset_type_normal"); - folder = GHB_WIDGET(ud->builder, "preset_type_folder"); - indices = ghb_preset_indices_from_path(presetsPlist, path, &len); - if (indices) +G_MODULE_EXPORT void +presets_menu_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) +{ + GtkMenu *menu; + + menu = GTK_MENU(GHB_WIDGET(ud->builder, "presets_menu")); + gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 1, + gtk_get_current_event_time()); +} + +G_MODULE_EXPORT void +preset_import_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) +{ + GtkWidget *dialog; + GtkResponseType response; + gchar *exportDir; + gchar *filename; + GtkFileFilter *filter; + + g_debug("preset_import_clicked_cb ()"); + + dialog = gtk_file_chooser_dialog_new("Import Preset", NULL, + GTK_FILE_CHOOSER_ACTION_OPEN, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, + NULL); + + filter = gtk_file_filter_new(); + gtk_file_filter_set_name(filter, "All (*)"); + gtk_file_filter_add_pattern(filter, "*"); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); + + filter = gtk_file_filter_new(); + gtk_file_filter_set_name(filter, "Presets (*.plist)"); + gtk_file_filter_add_pattern(filter, "*.plist"); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); + gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); + + exportDir = ghb_settings_get_string(ud->settings, "ExportDirectory"); + if (exportDir == NULL || exportDir[0] == '\0') { - fold = ghb_presets_get_folder(presetsPlist, indices, len); - if (fold) - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(folder), - TRUE); - else - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(normal), - TRUE); - gtk_widget_set_sensitive(folder, fold); - gtk_widget_set_sensitive(normal, !fold); - g_free(indices); + exportDir = g_strdup("."); } - else + gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), exportDir); + g_free(exportDir); + + response = gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_hide(dialog); + if (response == GTK_RESPONSE_ACCEPT) { - gtk_widget_set_sensitive(folder, TRUE); - gtk_widget_set_sensitive(normal, TRUE); + GValue *dict, *array; + gchar *dir; + gint count, ii; + + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + + // import the preset + if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) + { + gtk_widget_destroy(dialog); + g_free(filename); + return; + } + array = ghb_plist_parse_file(filename); + + import_xlat_presets(array); + presets_clear_default(array); + presets_customize(array); + + count = ghb_array_len(array); + for (ii = 0; ii < count; ii++) + { + GValue *path, *name; + gint *indices, len; + gint index = 1; + + dict = ghb_array_get_nth(array, ii); + path = ghb_array_value_new(1); + name = ghb_value_dup(ghb_dict_lookup(dict, "PresetName")); + ghb_array_append(path, name); + indices = ghb_preset_indices_from_path(presetsPlist, path, &len); + // Modify the preset name till we make it unique + while (indices != NULL) + { + gchar *str = ghb_value_string(name); + + ghb_value_free(path); + g_free(indices); + + str = g_strdup_printf("%s %d", str, index); + path = ghb_array_value_new(1); + name = ghb_string_value_new(str); + ghb_array_append(path, name); + g_free(str); + + index++; + indices = ghb_preset_indices_from_path(presetsPlist, path, &len); + } + ghb_dict_insert(dict, g_strdup("PresetName"), ghb_value_dup(name)); + indices = presets_find_pos(path, PRESETS_CUSTOM, &len); + ghb_presets_insert(presetsPlist, ghb_value_dup(dict), indices, len); + presets_list_insert(ud, indices, len); + ghb_value_free(path); + } + ghb_value_free(array); + + exportDir = ghb_settings_get_string(ud->settings, "ExportDirectory"); + dir = g_path_get_dirname(filename); + if (strcmp(dir, exportDir) != 0) + { + ghb_settings_set_string(ud->settings, "ExportDirectory", dir); + ghb_pref_save(ud->settings, "ExportDirectory"); + } + g_free(filename); + g_free(exportDir); + g_free(dir); + store_presets(); } + gtk_widget_destroy(dialog); } -void -presets_save_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) +G_MODULE_EXPORT void +preset_export_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) +{ + GtkWidget *dialog; + GtkResponseType response; + GValue *preset; + const gchar *name = ""; + gint count, *indices, len; + gchar *exportDir; + gchar *filename; + + g_debug("preset_export_clicked_cb ()"); + preset = ghb_settings_get_value (ud->settings, "preset_selection"); + if (preset == NULL) + return; + + count = ghb_array_len(preset); + if (count <= 0) + return; + + name = g_value_get_string(ghb_array_get_nth(preset, count-1)); + + dialog = gtk_file_chooser_dialog_new("Export Preset", NULL, + GTK_FILE_CHOOSER_ACTION_SAVE, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, + NULL); + + exportDir = ghb_settings_get_string(ud->settings, "ExportDirectory"); + if (exportDir == NULL || exportDir[0] == '\0') + { + exportDir = g_strdup("."); + } + filename = g_strdup_printf("%s.plist", name); + gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), exportDir); + gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename); + g_free(filename); + g_free(exportDir); + + indices = ghb_preset_indices_from_path(presetsPlist, preset, &len); + if (indices == NULL) + return; + + response = gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_hide(dialog); + if (response == GTK_RESPONSE_ACCEPT) + { + GValue *export, *dict, *array; + FILE *file; + gchar *dir; + + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + + // export the preset + dict = presets_get_dict(presetsPlist, indices, len); + + export = ghb_value_dup(dict); + array = ghb_array_value_new(1); + ghb_array_append(array, export); + presets_clear_default(array); + presets_customize(array); + export_xlat_presets(array); + + file = g_fopen(filename, "w"); + if (file != NULL) + { + ghb_plist_write(file, array); + fclose(file); + } + ghb_value_free(array); + + exportDir = ghb_settings_get_string(ud->settings, "ExportDirectory"); + dir = g_path_get_dirname(filename); + if (strcmp(dir, exportDir) != 0) + { + ghb_settings_set_string(ud->settings, "ExportDirectory", dir); + ghb_pref_save(ud->settings, "ExportDirectory"); + } + g_free(exportDir); + g_free(dir); + g_free(filename); + } + gtk_widget_destroy(dialog); + g_free(indices); +} + +G_MODULE_EXPORT void +presets_new_folder_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { GtkWidget *dialog; GtkEntry *entry; GtkTextView *desc; GtkResponseType response; - GValue *preset; + GValue *preset, *dict; const gchar *name = ""; + const gchar *description = ""; gint count, *indices, len; g_debug("presets_save_clicked_cb ()"); @@ -2651,12 +3554,20 @@ presets_save_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) name = g_value_get_string(ghb_array_get_nth(preset, count-1)); else count = 1; - // Clear the description + + indices = ghb_preset_indices_from_path(presetsPlist, preset, &len); + dict = presets_get_dict(presetsPlist, indices, len); + if (dict != NULL) + { + description = g_value_get_string( + ghb_dict_lookup(dict, "PresetDescription")); + ghb_ui_update(ud, "PresetDescription", ghb_string_value(description)); + } + desc = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "PresetDescription")); dialog = GHB_WIDGET(ud->builder, "preset_save_dialog"); entry = GTK_ENTRY(GHB_WIDGET(ud->builder, "PresetName")); gtk_entry_set_text(entry, name); - enforce_preset_type(ud, preset); response = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_hide(dialog); if (response == GTK_RESPONSE_OK) @@ -2665,13 +3576,61 @@ presets_save_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) const gchar *name = gtk_entry_get_text(entry); GValue *dest; - if (ghb_settings_get_boolean(ud->settings, "preset_type_folder")) + if (count > MAX_NESTED_PRESET-1) + count = MAX_NESTED_PRESET-1; + + dest = ghb_array_value_new(MAX_NESTED_PRESET); + if (indices != NULL) { - if (count > MAX_NESTED_PRESET-1) + gint ptype; + + ptype = ghb_presets_get_type(presetsPlist, indices, len); + if (ptype == PRESETS_CUSTOM) { - count = MAX_NESTED_PRESET-1; + ghb_array_copy(dest, preset, count-1); } } + ghb_array_append(dest, ghb_string_value_new(name)); + ghb_widget_to_setting(ud->settings, GTK_WIDGET(desc)); + folder_save(ud, dest); + ghb_value_free(dest); + } + if (indices != NULL) + g_free(indices); +} + +G_MODULE_EXPORT void +presets_save_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) +{ + GtkWidget *dialog; + GtkEntry *entry; + GtkTextView *desc; + GtkResponseType response; + GValue *preset; + const gchar *name = ""; + gint count, *indices, len; + + g_debug("presets_save_clicked_cb ()"); + preset = ghb_settings_get_value (ud->settings, "preset_selection"); + + count = ghb_array_len(preset); + if (count > 0) + name = g_value_get_string(ghb_array_get_nth(preset, count-1)); + else + count = 1; + + desc = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "PresetDescription")); + dialog = GHB_WIDGET(ud->builder, "preset_save_dialog"); + entry = GTK_ENTRY(GHB_WIDGET(ud->builder, "PresetName")); + gtk_entry_set_text(entry, name); + response = gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_hide(dialog); + if (response == GTK_RESPONSE_OK) + { + // save the preset + const gchar *name = gtk_entry_get_text(entry); + GValue *dest; + dest = ghb_array_value_new(MAX_NESTED_PRESET); indices = ghb_preset_indices_from_path(presetsPlist, preset, &len); if (indices) @@ -2683,47 +3642,27 @@ presets_save_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { ghb_array_copy(dest, preset, count-1); } + g_free(indices); } ghb_array_append(dest, ghb_string_value_new(name)); ghb_widget_to_setting(ud->settings, GTK_WIDGET(desc)); - if (ghb_settings_get_boolean(ud->settings, "preset_type_folder")) - { - folder_save(ud, dest); - } - else - { - // Construct the audio settings presets from the current audio list - update_audio_presets(ud); - settings_save(ud, dest); - } + + // Construct the audio settings presets from the current audio list + update_audio_presets(ud); + update_subtitle_presets(ud); + settings_save(ud, dest); ghb_value_free(dest); } } -void +G_MODULE_EXPORT void preset_type_changed_cb(GtkWidget *widget, signal_user_data_t *ud) { ghb_widget_to_setting(ud->settings, widget); } -void -preset_name_changed_cb(GtkWidget *entry, signal_user_data_t *ud) -{ - gchar *name; - GValue *preset, *dest; - gint count; - - preset = ghb_settings_get_value (ud->settings, "preset_selection"); - name = ghb_widget_string(entry); - dest = ghb_value_dup(preset); - count = ghb_array_len(dest); - ghb_array_replace(dest, count-1, ghb_string_value_new(name)); - enforce_preset_type(ud, dest); - ghb_value_free(dest); -} - -void +G_MODULE_EXPORT void presets_restore_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { GValue *preset; @@ -2737,7 +3676,7 @@ presets_restore_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) ghb_select_preset(ud->builder, preset); } -void +G_MODULE_EXPORT void presets_remove_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { GtkTreeView *treeview; @@ -2806,7 +3745,7 @@ presets_remove_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) } // controls where valid drop locations are -gboolean +G_MODULE_EXPORT gboolean presets_drag_motion_cb( GtkTreeView *tv, GdkDragContext *ctx, @@ -2826,6 +3765,11 @@ presets_drag_motion_cb( gboolean src_folder, dst_folder; GValue *preset; gint tree_depth, ii; + GtkWidget *widget; + + widget = gtk_drag_get_source_widget(ctx); + if (widget == NULL || widget != GTK_WIDGET(tv)) + return TRUE; // Get the type of the object being dragged srctv = GTK_TREE_VIEW(gtk_drag_get_source_widget(ctx)); @@ -2897,7 +3841,7 @@ presets_drag_motion_cb( return TRUE; } -void +G_MODULE_EXPORT void presets_drag_cb( GtkTreeView *dstwidget, GdkDragContext *dc, @@ -3037,7 +3981,7 @@ presets_drag_cb( dstpath = gtk_tree_model_get_path (dstmodel, &iter); dst_indices = gtk_tree_path_get_indices(dstpath); dst_len = gtk_tree_path_get_depth(dstpath); - presets_list_update_item(ud, dst_indices, dst_len); + presets_list_update_item(ud, dst_indices, dst_len, TRUE); gtk_tree_path_free(dstpath); store_presets(); @@ -3046,6 +3990,62 @@ presets_drag_cb( } } +void +presets_row_expanded_cb( + GtkTreeView *treeview, + GtkTreeIter *iter, + GtkTreePath *path, + signal_user_data_t *ud) +{ + gint *indices, len; + gboolean expanded, folder; + GValue *dict; + + expanded = gtk_tree_view_row_expanded(treeview, path); + indices = gtk_tree_path_get_indices(path); + len = gtk_tree_path_get_depth(path); + dict = presets_get_dict(presetsPlist, indices, len); + if (preset_folder_is_open(dict)) + { + if (expanded) + return; + } + else if (!expanded) + { + return; + } + folder = ghb_presets_get_folder(presetsPlist, indices, len); + if (folder) + { + presets_set_folder_open(expanded, indices, len); + } + + // Collapsing parent folder collapses all children + if (!expanded) + { + GValue *presets = NULL; + gint *more_indices, count, ii; + + more_indices = g_malloc((len+1)*sizeof(gint)); + memcpy(more_indices, indices, len*sizeof(gint)); + + presets = presets_get_folder(presetsPlist, indices, len); + count = ghb_array_len(presets); + for (ii = 0; ii < count; ii++) + { + dict = ghb_array_get_nth(presets, ii); + folder = ghb_preset_folder(dict); + if (folder) + { + more_indices[len] = ii; + presets_set_folder_open(expanded, more_indices, len+1); + } + } + g_free(more_indices); + } + store_presets(); +} + static void preset_update_title_deps(signal_user_data_t *ud, ghb_title_info_t *tinfo) { @@ -3054,10 +4054,11 @@ preset_update_title_deps(signal_user_data_t *ud, ghb_title_info_t *tinfo) ghb_ui_update(ud, "scale_width", ghb_int64_value(tinfo->width - tinfo->crop[2] - tinfo->crop[3])); // If anamorphic or keep_aspect, the hight will be automatically calculated - gboolean keep_aspect, anamorphic; + gboolean keep_aspect; + gint pic_par; keep_aspect = ghb_settings_get_boolean(ud->settings, "PictureKeepRatio"); - anamorphic = ghb_settings_get_boolean(ud->settings, "anamorphic"); - if (!(keep_aspect || anamorphic)) + pic_par = ghb_settings_combo_int(ud->settings, "PicturePAR"); + if (!(keep_aspect || pic_par) || pic_par == 3) { ghb_ui_update(ud, "scale_height", ghb_int64_value(tinfo->height - tinfo->crop[0] - tinfo->crop[1])); @@ -3086,6 +4087,74 @@ preset_update_title_deps(signal_user_data_t *ud, ghb_title_info_t *tinfo) } void +ghb_refresh_preset(signal_user_data_t *ud) +{ + ghb_title_info_t tinfo; + GValue *preset; + gint *indices, len; + + g_debug("ghb_refresh_preset ()"); + preset = ghb_settings_get_value(ud->settings, "preset_selection"); + indices = ghb_preset_indices_from_path(presetsPlist, preset, &len); + if (indices) + { + gboolean folder; + + folder = ghb_presets_get_folder(presetsPlist, indices, len); + if (!folder) + { + ud->dont_clear_presets = TRUE; + // Temporarily set the video_quality range to (0,100) + // This is needed so the video_quality value does not get + // truncated when set. The range will be readjusted below + GtkWidget *qp = GHB_WIDGET(ud->builder, "VideoQualitySlider"); + gtk_range_set_range (GTK_RANGE(qp), 0, 100); + gtk_scale_set_digits(GTK_SCALE(qp), 3); + // Clear the audio list prior to changing the preset. Existing + // audio can cause the container extension to be automatically + // changed when it shouldn't be + ghb_clear_audio_list(ud); + ghb_set_preset_from_indices(ud, indices, len); + gint titleindex; + titleindex = ghb_settings_combo_int(ud->settings, "title"); + ghb_set_pref_audio(titleindex, ud); + ghb_set_pref_subtitle(titleindex, ud); + ghb_settings_set_boolean(ud->settings, "preset_modified", FALSE); + if (ghb_get_title_info (&tinfo, titleindex)) + { + preset_update_title_deps(ud, &tinfo); + } + ghb_set_scale (ud, GHB_PIC_KEEP_PAR); + ud->dont_clear_presets = FALSE; + + gdouble vqmin, vqmax, step, page; + gint digits; + gboolean inverted; + + ghb_vquality_range(ud, &vqmin, &vqmax, &step, + &page, &digits, &inverted); + gtk_range_set_range (GTK_RANGE(qp), vqmin, vqmax); + gtk_range_set_increments (GTK_RANGE(qp), step, page); + gtk_scale_set_digits(GTK_SCALE(qp), digits); + gtk_range_set_inverted (GTK_RANGE(qp), inverted); + + gchar *text; + gint crop[4]; + GtkWidget *crop_widget; + crop[0] = ghb_settings_get_int(ud->settings, "PictureTopCrop"); + crop[1] = ghb_settings_get_int(ud->settings, "PictureBottomCrop"); + crop[2] = ghb_settings_get_int(ud->settings, "PictureLeftCrop"); + crop[3] = ghb_settings_get_int(ud->settings, "PictureRightCrop"); + crop_widget = GHB_WIDGET (ud->builder, "crop_values"); + text = g_strdup_printf("%d:%d:%d:%d", + crop[0], crop[1], crop[2], crop[3]); + gtk_label_set_text (GTK_LABEL(crop_widget), text); + g_free(text); + } + } +} + +G_MODULE_EXPORT void presets_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud) { GtkTreeModel *store; @@ -3124,24 +4193,28 @@ presets_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_ // changed when it shouldn't be ghb_clear_audio_list(ud); ghb_set_preset_from_indices(ud, indices, len); - gtk_tree_path_free(treepath); gint titleindex; titleindex = ghb_settings_combo_int(ud->settings, "title"); ghb_set_pref_audio(titleindex, ud); + ghb_set_pref_subtitle(titleindex, ud); ghb_settings_set_boolean(ud->settings, "preset_modified", FALSE); - ud->dont_clear_presets = FALSE; if (ghb_get_title_info (&tinfo, titleindex)) { preset_update_title_deps(ud, &tinfo); } - ghb_set_scale (ud, GHB_SCALE_KEEP_NONE); + ghb_set_scale (ud, GHB_PIC_KEEP_PAR); + ud->dont_clear_presets = FALSE; gdouble vqmin, vqmax, step, page; gint digits; - ghb_vquality_range(ud, &vqmin, &vqmax, &step, &page, &digits); + gboolean inverted; + + ghb_vquality_range(ud, &vqmin, &vqmax, &step, + &page, &digits, &inverted); gtk_range_set_range (GTK_RANGE(qp), vqmin, vqmax); gtk_range_set_increments (GTK_RANGE(qp), step, page); gtk_scale_set_digits(GTK_SCALE(qp), digits); + gtk_range_set_inverted (GTK_RANGE(qp), inverted); gchar *text; gint crop[4]; @@ -3156,6 +4229,7 @@ presets_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_ gtk_label_set_text (GTK_LABEL(crop_widget), text); g_free(text); } + gtk_tree_path_free(treepath); gtk_widget_set_sensitive(widget, TRUE); } else @@ -3163,6 +4237,21 @@ presets_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_ g_debug("No selection??? Perhaps unselected."); gtk_widget_set_sensitive(widget, FALSE); } + if (ghb_settings_combo_int(ud->settings, "PtoPType") == 0) + { + gint start, end; + start = ghb_settings_get_int(ud->settings, "start_point"); + end = ghb_settings_get_int(ud->settings, "end_point"); + widget = GHB_WIDGET (ud->builder, "ChapterMarkers"); + gtk_widget_set_sensitive(widget, TRUE); + if (start == end) + { + ud->dont_clear_presets = TRUE; + ghb_ui_update(ud, "ChapterMarkers", ghb_boolean_value(FALSE)); + ud->dont_clear_presets = FALSE; + gtk_widget_set_sensitive(widget, FALSE); + } + } } void @@ -3179,7 +4268,7 @@ ghb_clear_presets_selection(signal_user_data_t *ud) ghb_settings_set_boolean(ud->settings, "preset_modified", TRUE); } -void +G_MODULE_EXPORT void presets_frame_size_allocate_cb(GtkWidget *widget, GtkAllocation *allocation, signal_user_data_t *ud) { GtkTreeView *treeview; @@ -3199,7 +4288,7 @@ presets_frame_size_allocate_cb(GtkWidget *widget, GtkAllocation *allocation, sig } } -void +G_MODULE_EXPORT void presets_default_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { GValue *preset; @@ -3220,3 +4309,50 @@ presets_default_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) } } +G_MODULE_EXPORT void +preset_edited_cb( + GtkCellRendererText *cell, + gchar *path, + gchar *text, + signal_user_data_t *ud) +{ + GtkTreePath *treepath; + GtkTreeStore *store; + GtkTreeView *treeview; + GtkTreeIter iter; + gint *indices, len, count; + GValue *dict; + GValue *preset, *dest; + + g_debug("preset_edited_cb ()"); + g_debug("path (%s)", path); + g_debug("text (%s)", text); + + preset = ghb_settings_get_value (ud->settings, "preset_selection"); + dest = ghb_array_value_new(MAX_NESTED_PRESET); + count = ghb_array_len(preset); + ghb_array_copy(dest, preset, count-1); + ghb_array_append(dest, ghb_string_value_new(text)); + indices = ghb_preset_indices_from_path(presetsPlist, dest, &len); + ghb_value_free(dest); + if (indices != NULL) + { + // Already exists + g_free(indices); + return; + } + + treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "presets_list")); + store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview)); + treepath = gtk_tree_path_new_from_string (path); + indices = gtk_tree_path_get_indices(treepath); + len = gtk_tree_path_get_depth(treepath); + gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, treepath); + gtk_tree_store_set(store, &iter, 0, text, -1); + + dict = presets_get_dict(presetsPlist, indices, len); + ghb_dict_insert(dict, g_strdup("PresetName"), ghb_string_value_new(text)); + store_presets(); + gtk_tree_path_free (treepath); +} +