X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=gtk%2Fsrc%2Fpresets.c;h=5d64de1a287dfe380d388b8a6d8c142b6495e402;hb=a0edd875e0b50f5da69e99a71090e4c44ccf1238;hp=cbe539345849abb4a8631f37cabf1bc9d64599e7;hpb=e6480044b43e82c9cdb6a4b3dc4d9af39dacc029;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/gtk/src/presets.c b/gtk/src/presets.c index cbe53934..5d64de1a 100644 --- a/gtk/src/presets.c +++ b/gtk/src/presets.c @@ -20,6 +20,7 @@ #include "settings.h" #include "callbacks.h" #include "audiohandler.h" +#include "subtitlehandler.h" #include "hb-backend.h" #include "plist.h" #include "resources.h" @@ -38,10 +39,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* @@ -1019,7 +1034,7 @@ ghb_get_user_config_dir(gchar *subdir) gchar **split; gint ii; - split = g_strsplit(subdir, "/", -1); + split = g_strsplit(subdir, G_DIR_SEPARATOR_S, -1); for (ii = 0; split[ii] != NULL; ii++) { gchar *tmp; @@ -1118,14 +1133,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 @@ -1188,20 +1203,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); @@ -1210,8 +1248,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; } } @@ -1276,6 +1329,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) { @@ -1290,20 +1371,20 @@ 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); if (dir == NULL) { @@ -1311,8 +1392,20 @@ ghb_prefs_load(signal_user_data_t *ud) } ghb_dict_insert(dict, g_strdup("destination_dir"), ghb_value_dup(ghb_string_value(dir))); - store_plist(prefsPlist, "preferences"); - } +#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) @@ -1337,7 +1430,7 @@ ghb_prefs_load(signal_user_data_t *ud) g_free(indices); } ghb_dict_remove(dict, "default_preset"); - store_plist(prefsPlist, "preferences"); + store_prefs(); } } @@ -1651,7 +1744,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} @@ -1671,8 +1764,8 @@ value_map_t container_xlat[] = {"MP4 file", "mp4"}, {"M4V file", "m4v"}, {"MKV file", "mkv"}, - {"AVI file", "avi"}, - {"OGM file", "ogm"}, + {"AVI file", "mkv"}, + {"OGM file", "mkv"}, {NULL, NULL} }; @@ -1965,15 +2058,25 @@ export_value_xlat(GValue *dict) gval = export_value_xlat2(denoise_xlat, lin_val, G_TYPE_INT); if (gval) ghb_dict_insert(dict, g_strdup(key), gval); - 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); @@ -2040,13 +2143,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; } @@ -2093,19 +2217,82 @@ 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); + if (mac_val) + { + gchar *lang; + + gval = import_subtitle_xlat2(mac_val); + lang = ghb_value_string(gval); + if (lang && strcmp(lang, "none") != 0 && !slist) + { + slist = ghb_array_value_new(8); + sdict = ghb_dict_value_new(); + ghb_dict_insert(dict, g_strdup("SubtitleList"), slist); + 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)); + } + 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); @@ -2143,7 +2330,7 @@ import_xlat_preset(GValue *dict) { gboolean uses_max; gint uses_pic; - gint par; + gint par, par_width, par_height; gint vqtype; g_debug("import_xlat_preset ()"); @@ -2153,6 +2340,12 @@ import_xlat_preset(GValue *dict) preset_dict_get_value(dict, "UsesPictureSettings")); par = ghb_value_int(preset_dict_get_value(dict, "PicturePAR")); vqtype = ghb_value_int(preset_dict_get_value(dict, "VideoQualityType")); + par_width = ghb_value_int(preset_dict_get_value(dict, "PicturePARWidth")); + par_height = ghb_value_int(preset_dict_get_value(dict, "PicturePARHeight")); + ghb_dict_insert(dict, g_strdup("par_width"), + ghb_int_value_new(par_width)); + ghb_dict_insert(dict, g_strdup("par_height"), + ghb_int_value_new(par_height)); if (uses_max || uses_pic == 2) { @@ -2163,32 +2356,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 @@ -2250,7 +2437,6 @@ import_xlat_preset(GValue *dict) vquality = 51. - vquality * 51.; } break; - case HB_VCODEC_XVID: case HB_VCODEC_FFMPEG: { vquality = 31. - vquality * 30.; @@ -2302,18 +2488,21 @@ import_xlat_presets(GValue *presets) static void export_xlat_preset(GValue *dict) { - gboolean ana, round, autoscale, target, br, constant; + gboolean autoscale, target, br, constant; + gint par_width, par_height; 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( preset_dict_get_value(dict, "vquality_type_bitrate")); constant = ghb_value_boolean( preset_dict_get_value(dict, "vquality_type_constant")); + par_width = ghb_value_int( + preset_dict_get_value(dict, "par_width")); + par_height = ghb_value_int( + preset_dict_get_value(dict, "par_height")); if (autoscale) ghb_dict_insert(dict, g_strdup("UsesPictureSettings"), @@ -2322,20 +2511,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) { @@ -2352,12 +2527,17 @@ export_xlat_preset(GValue *dict) ghb_dict_insert(dict, g_strdup("VideoQualityType"), ghb_int_value_new(2)); } + ghb_dict_insert(dict, g_strdup("PicturePARWidth"), + ghb_int_value_new(par_width)); + ghb_dict_insert(dict, g_strdup("PicturePARHeight"), + ghb_int_value_new(par_height)); 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"); + ghb_dict_remove(dict, "par_width"); + ghb_dict_remove(dict, "par_height"); export_value_xlat(dict); } @@ -2388,6 +2568,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() { @@ -2399,6 +2589,22 @@ 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) { @@ -2411,7 +2617,7 @@ ghb_presets_reload(signal_user_data_t *ud) if (std_presets == NULL) return; remove_std_presets(ud); - indices = presets_find_default(presetsPlist, &len); + indices = presets_find_default(presetsPlist, &len); if (indices) { presets_clear_default(std_presets); @@ -2489,6 +2695,7 @@ settings_save(signal_user_data_t *ud, const GValue *path) GValue *value; gboolean autoscale; gint *indices, len, count; + gint *def_indices, def_len; const gchar *name; gboolean replace = FALSE; @@ -2579,7 +2786,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) + { + 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); + } else { ghb_dict_insert(dict, g_strdup("Default"), @@ -2725,6 +2941,29 @@ update_audio_presets(signal_user_data_t *ud) ghb_settings_set_value(ud->settings, "AudioList", audio_list); } +static void +update_subtitle_presets(signal_user_data_t *ud) +{ + g_debug("update_subtitle_presets"); + const GValue *subtitle_list, *subtitle; + GValue *slist, *dict; + gint count, ii; + + 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); + if (ghb_settings_get_boolean(subtitle, "SubtitleEnabled")) + { + dict = ghb_value_dup(subtitle); + ghb_array_append(slist, dict); + } + } + ghb_settings_set_value(ud->settings, "SubtitleList", slist); +} + void enforce_preset_type(signal_user_data_t *ud, const GValue *path) { @@ -2755,7 +2994,7 @@ enforce_preset_type(signal_user_data_t *ud, const GValue *path) } } -void +G_MODULE_EXPORT void presets_save_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { GtkWidget *dialog; @@ -2818,19 +3057,20 @@ presets_save_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { // 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 +G_MODULE_EXPORT void preset_name_changed_cb(GtkWidget *entry, signal_user_data_t *ud) { gchar *name; @@ -2846,7 +3086,7 @@ preset_name_changed_cb(GtkWidget *entry, signal_user_data_t *ud) ghb_value_free(dest); } -void +G_MODULE_EXPORT void presets_restore_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { GValue *preset; @@ -2860,7 +3100,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; @@ -2929,7 +3169,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, @@ -2949,6 +3189,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)); @@ -3020,7 +3265,7 @@ presets_drag_motion_cb( return TRUE; } -void +G_MODULE_EXPORT void presets_drag_cb( GtkTreeView *dstwidget, GdkDragContext *dc, @@ -3178,10 +3423,21 @@ presets_row_expanded_cb( { 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) { @@ -3192,7 +3448,6 @@ presets_row_expanded_cb( if (!expanded) { GValue *presets = NULL; - GValue *dict; gint *more_indices, count, ii; more_indices = g_malloc((len+1)*sizeof(gint)); @@ -3223,10 +3478,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])); @@ -3254,7 +3510,7 @@ preset_update_title_deps(signal_user_data_t *ud, ghb_title_info_t *tinfo) } } -void +G_MODULE_EXPORT void presets_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud) { GtkTreeModel *store; @@ -3297,13 +3553,14 @@ presets_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_ 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; @@ -3352,7 +3609,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; @@ -3372,7 +3629,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;