src/preferences.c

   1 /*
   2  * Copyright (C) 2006 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: John Ellis
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "main.h"
  23 #include "preferences.h"
  24
  25 #include "bar_exif.h"
  26 #include "bar_keywords.h"
  27 #include "cache.h"
  28 #include "cache_maint.h"
  29 #include "dnd.h"
  30 #include "editors.h"
  31 #include "exif.h"
  32 #include "filedata.h"
  33 #include "filefilter.h"
  34 #include "fullscreen.h"
  35 #include "image.h"
  36 #include "image-overlay.h"
  37 #include "color-man.h"
  38 #include "img-view.h"
  39 #include "layout_config.h"
  40 #include "layout_util.h"
  41 #include "metadata.h"
  42 #include "misc.h"
  43 #include "osd.h"
  44 #include "pixbuf_util.h"
  45 #include "rcfile.h"
  46 #include "slideshow.h"
  47 #include "toolbar.h"
  48 #include "trash.h"
  49 #include "utilops.h"
  50 #include "ui_fileops.h"
  51 #include "ui_misc.h"
  52 #include "ui_spinner.h"
  53 #include "ui_tabcomp.h"
  54 #include "ui_utildlg.h"
  55 #include "window.h"
  56 #include "zonedetect.h"
  57
  58 #ifdef HAVE_LCMS
  59 #ifdef HAVE_LCMS2
  60 #include <lcms2.h>
  61 #else
  62 #include <lcms.h>
  63 #endif
  64 #endif
  65
  66 #define EDITOR_NAME_MAX_LENGTH 32
  67 #define EDITOR_COMMAND_MAX_LENGTH 1024
  68
  69 static void image_overlay_set_text_colours();
  70
  71 GtkWidget *keyword_text;
  72 static void config_tab_keywords_save();
  73
  74 typedef struct _ThumbSize ThumbSize;
  75 struct _ThumbSize
  76 {
  77         gint w;
  78         gint h;
  79 };
  80
  81 static ThumbSize thumb_size_list[] =
  82 {
  83         { 24, 24 },
  84         { 32, 32 },
  85         { 48, 48 },
  86         { 64, 64 },
  87         { 96, 72 },
  88         { 96, 96 },
  89         { 128, 96 },
  90         { 128, 128 },
  91         { 160, 120 },
  92         { 160, 160 },
  93         { 192, 144 },
  94         { 192, 192 },
  95         { 256, 192 },
  96         { 256, 256 }
  97 };
  98
  99 enum {
 100         FE_ENABLE,
 101         FE_EXTENSION,
 102         FE_DESCRIPTION,
 103         FE_CLASS,
 104         FE_WRITABLE,
 105         FE_ALLOW_SIDECAR
 106 };
 107
 108 enum {
 109         AE_ACTION,
 110         AE_KEY,
 111         AE_TOOLTIP,
 112         AE_ACCEL
 113 };
 114
 115 enum {
 116         FILETYPES_COLUMN_FILTER = 0,
 117         FILETYPES_COLUMN_DESCRIPTION,
 118         FILETYPES_COLUMN_CLASS,
 119         FILETYPES_COLUMN_WRITABLE,
 120         FILETYPES_COLUMN_SIDECAR,
 121         FILETYPES_COLUMN_COUNT
 122 };
 123
 124 gchar *format_class_list[] = {
 125         N_("Unknown"),
 126         N_("Image"),
 127         N_("RAW Image"),
 128         N_("Metadata"),
 129         N_("Video"),
 130         N_("Collection"),
 131         N_("Document"),
 132         N_("Archive")
 133         };
 134
 135 /* config memory values */
 136 static ConfOptions *c_options = NULL;
 137
 138
 139 #ifdef DEBUG
 140 static gint debug_c;
 141 #endif
 142
 143 static GtkWidget *configwindow = NULL;
 144 static GtkListStore *filter_store = NULL;
 145 static GtkTreeStore *accel_store = NULL;
 146
 147 static GtkWidget *safe_delete_path_entry;
 148
 149 static GtkWidget *color_profile_input_file_entry[COLOR_PROFILE_INPUTS];
 150 static GtkWidget *color_profile_input_name_entry[COLOR_PROFILE_INPUTS];
 151 static GtkWidget *color_profile_screen_file_entry;
 152 static GtkWidget *external_preview_select_entry;
 153 static GtkWidget *external_preview_extract_entry;
 154
 155 static GtkWidget *sidecar_ext_entry;
 156 static GtkWidget *help_search_engine_entry;
 157
 158
 159 #define CONFIG_WINDOW_DEF_WIDTH         700
 160 #define CONFIG_WINDOW_DEF_HEIGHT        600
 161
 162 /*
 163  *-----------------------------------------------------------------------------
 164  * option widget callbacks (private)
 165  *-----------------------------------------------------------------------------
 166  */
 167
 168 static void zoom_increment_cb(GtkWidget *spin, gpointer data)
 169 {
 170         c_options->image.zoom_increment = (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) * 100.0 + 0.01);
 171 }
 172
 173 static void slideshow_delay_hours_cb(GtkWidget *spin, gpointer data)
 174 {
 175         gint mins_secs_tenths, delay;
 176
 177         mins_secs_tenths = c_options->slideshow.delay %
 178                                                 (3600 * SLIDESHOW_SUBSECOND_PRECISION);
 179
 180         delay = (gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) *
 181                                                                 (3600 * SLIDESHOW_SUBSECOND_PRECISION) +
 182                                                                 mins_secs_tenths);
 183
 184         c_options->slideshow.delay = delay > 0 ? delay : SLIDESHOW_MIN_SECONDS *
 185                                                                                                         SLIDESHOW_SUBSECOND_PRECISION;
 186 }
 187
 188 static void slideshow_delay_minutes_cb(GtkWidget *spin, gpointer data)
 189 {
 190         gint hours, secs_tenths, delay;
 191
 192         hours = c_options->slideshow.delay / (3600 * SLIDESHOW_SUBSECOND_PRECISION);
 193         secs_tenths = c_options->slideshow.delay % (60 * SLIDESHOW_SUBSECOND_PRECISION);
 194
 195         delay = hours * (3600 * SLIDESHOW_SUBSECOND_PRECISION) +
 196                                         (gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) *
 197                                         (60 * SLIDESHOW_SUBSECOND_PRECISION) + secs_tenths);
 198
 199         c_options->slideshow.delay = delay > 0 ? delay : SLIDESHOW_MIN_SECONDS *
 200                                                                                                         SLIDESHOW_SUBSECOND_PRECISION;
 201 }
 202
 203 static void slideshow_delay_seconds_cb(GtkWidget *spin, gpointer data)
 204 {
 205         gint hours_mins, delay;
 206
 207         hours_mins = c_options->slideshow.delay / (60 * SLIDESHOW_SUBSECOND_PRECISION);
 208
 209         delay = (hours_mins * (60 * SLIDESHOW_SUBSECOND_PRECISION)) +
 210                                                         (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin)) *
 211                                                         (gdouble)(SLIDESHOW_SUBSECOND_PRECISION) + 0.01);
 212
 213         c_options->slideshow.delay = delay > 0 ? delay : SLIDESHOW_MIN_SECONDS *
 214                                                                                                         SLIDESHOW_SUBSECOND_PRECISION;
 215 }
 216
 217 /*
 218  *-----------------------------------------------------------------------------
 219  * sync program to config window routine (private)
 220  *-----------------------------------------------------------------------------
 221  */
 222
 223 void config_entry_to_option(GtkWidget *entry, gchar **option, gchar *(*func)(const gchar *))
 224 {
 225         const gchar *buf;
 226
 227         g_free(*option);
 228         *option = NULL;
 229         buf = gtk_entry_get_text(GTK_ENTRY(entry));
 230         if (buf && strlen(buf) > 0)
 231                 {
 232                 if (func)
 233                         *option = func(buf);
 234                 else
 235                         *option = g_strdup(buf);
 236                 }
 237 }
 238
 239
 240 static gboolean accel_apply_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 241 {
 242         gchar *accel_path, *accel;
 243
 244         gtk_tree_model_get(model, iter, AE_ACCEL, &accel_path, AE_KEY, &accel, -1);
 245
 246         if (accel_path && accel_path[0])
 247                 {
 248                 GtkAccelKey key;
 249                 gtk_accelerator_parse(accel, &key.accel_key, &key.accel_mods);
 250                 gtk_accel_map_change_entry(accel_path, key.accel_key, key.accel_mods, TRUE);
 251                 }
 252
 253         g_free(accel_path);
 254         g_free(accel);
 255
 256         return FALSE;
 257 }
 258
 259
 260 static void config_window_apply(void)
 261 {
 262         gboolean refresh = FALSE;
 263 #ifdef HAVE_LCMS2
 264         int i = 0;
 265 #endif
 266
 267         config_entry_to_option(safe_delete_path_entry, &options->file_ops.safe_delete_path, remove_trailing_slash);
 268
 269         if (options->file_filter.show_hidden_files != c_options->file_filter.show_hidden_files) refresh = TRUE;
 270         if (options->file_filter.show_parent_directory != c_options->file_filter.show_parent_directory) refresh = TRUE;
 271         if (options->file_filter.show_dot_directory != c_options->file_filter.show_dot_directory) refresh = TRUE;
 272         if (options->file_sort.case_sensitive != c_options->file_sort.case_sensitive) refresh = TRUE;
 273         if (options->file_sort.natural != c_options->file_sort.natural) refresh = TRUE;
 274         if (options->file_filter.disable_file_extension_checks != c_options->file_filter.disable_file_extension_checks) refresh = TRUE;
 275         if (options->file_filter.disable != c_options->file_filter.disable) refresh = TRUE;
 276
 277         options->file_ops.confirm_delete = c_options->file_ops.confirm_delete;
 278         options->file_ops.enable_delete_key = c_options->file_ops.enable_delete_key;
 279         options->file_ops.confirm_move_to_trash = c_options->file_ops.confirm_move_to_trash;
 280         options->file_ops.use_system_trash = c_options->file_ops.use_system_trash;
 281         options->file_ops.no_trash = c_options->file_ops.no_trash;
 282         options->file_ops.safe_delete_folder_maxsize = c_options->file_ops.safe_delete_folder_maxsize;
 283         options->tools_restore_state = c_options->tools_restore_state;
 284         options->save_window_positions = c_options->save_window_positions;
 285         options->use_saved_window_positions_for_new_windows = c_options->use_saved_window_positions_for_new_windows;
 286         options->save_window_workspace = c_options->save_window_workspace;
 287         options->save_dialog_window_positions = c_options->save_dialog_window_positions;
 288         options->show_window_ids = c_options->show_window_ids;
 289         options->image.scroll_reset_method = c_options->image.scroll_reset_method;
 290         options->image.zoom_2pass = c_options->image.zoom_2pass;
 291         options->image.fit_window_to_image = c_options->image.fit_window_to_image;
 292         options->image.limit_window_size = c_options->image.limit_window_size;
 293         options->image.zoom_to_fit_allow_expand = c_options->image.zoom_to_fit_allow_expand;
 294         options->image.max_window_size = c_options->image.max_window_size;
 295         options->image.limit_autofit_size = c_options->image.limit_autofit_size;
 296         options->image.max_autofit_size = c_options->image.max_autofit_size;
 297         options->image.max_enlargement_size = c_options->image.max_enlargement_size;
 298         options->image.use_clutter_renderer = c_options->image.use_clutter_renderer;
 299         options->image.tile_size = c_options->image.tile_size;
 300         options->progressive_key_scrolling = c_options->progressive_key_scrolling;
 301         options->keyboard_scroll_step = c_options->keyboard_scroll_step;
 302
 303         if (options->thumbnails.max_width != c_options->thumbnails.max_width
 304             || options->thumbnails.max_height != c_options->thumbnails.max_height
 305             || options->thumbnails.quality != c_options->thumbnails.quality)
 306                 {
 307                 thumb_format_changed = TRUE;
 308                 refresh = TRUE;
 309                 options->thumbnails.max_width = c_options->thumbnails.max_width;
 310                 options->thumbnails.max_height = c_options->thumbnails.max_height;
 311                 options->thumbnails.quality = c_options->thumbnails.quality;
 312                 }
 313         options->thumbnails.enable_caching = c_options->thumbnails.enable_caching;
 314         options->thumbnails.cache_into_dirs = c_options->thumbnails.cache_into_dirs;
 315         options->thumbnails.use_exif = c_options->thumbnails.use_exif;
 316         options->thumbnails.use_color_management = c_options->thumbnails.use_color_management;
 317         options->thumbnails.collection_preview = c_options->thumbnails.collection_preview;
 318         options->thumbnails.use_ft_metadata = c_options->thumbnails.use_ft_metadata;
 319 //      options->thumbnails.use_ft_metadata_small = c_options->thumbnails.use_ft_metadata_small;
 320         options->thumbnails.spec_standard = c_options->thumbnails.spec_standard;
 321         options->metadata.enable_metadata_dirs = c_options->metadata.enable_metadata_dirs;
 322         options->file_filter.show_hidden_files = c_options->file_filter.show_hidden_files;
 323         options->file_filter.show_parent_directory = c_options->file_filter.show_parent_directory;
 324         options->file_filter.show_dot_directory = c_options->file_filter.show_dot_directory;
 325         options->file_filter.disable_file_extension_checks = c_options->file_filter.disable_file_extension_checks;
 326
 327         options->file_sort.case_sensitive = c_options->file_sort.case_sensitive;
 328         options->file_sort.natural = c_options->file_sort.natural;
 329         options->file_filter.disable = c_options->file_filter.disable;
 330
 331         config_entry_to_option(sidecar_ext_entry, &options->sidecar.ext, NULL);
 332         sidecar_ext_parse(options->sidecar.ext);
 333
 334         options->slideshow.random = c_options->slideshow.random;
 335         options->slideshow.repeat = c_options->slideshow.repeat;
 336         options->slideshow.delay = c_options->slideshow.delay;
 337
 338         options->mousewheel_scrolls = c_options->mousewheel_scrolls;
 339         options->image_lm_click_nav = c_options->image_lm_click_nav;
 340         options->image_l_click_archive = c_options->image_l_click_archive;
 341         options->image_l_click_video = c_options->image_l_click_video;
 342         options->image_l_click_video_editor = c_options->image_l_click_video_editor;
 343
 344         options->file_ops.enable_in_place_rename = c_options->file_ops.enable_in_place_rename;
 345
 346         options->image.tile_cache_max = c_options->image.tile_cache_max;
 347         options->image.image_cache_max = c_options->image.image_cache_max;
 348
 349         options->image.zoom_quality = c_options->image.zoom_quality;
 350
 351         options->image.zoom_increment = c_options->image.zoom_increment;
 352
 353         options->image.zoom_style = c_options->image.zoom_style;
 354
 355         options->image.enable_read_ahead = c_options->image.enable_read_ahead;
 356
 357
 358         if (options->image.use_custom_border_color != c_options->image.use_custom_border_color
 359             || options->image.use_custom_border_color_in_fullscreen != c_options->image.use_custom_border_color_in_fullscreen
 360             || !gdk_color_equal(&options->image.border_color, &c_options->image.border_color))
 361                 {
 362                 options->image.use_custom_border_color_in_fullscreen = c_options->image.use_custom_border_color_in_fullscreen;
 363                 options->image.use_custom_border_color = c_options->image.use_custom_border_color;
 364                 options->image.border_color = c_options->image.border_color;
 365                 layout_colors_update();
 366                 view_window_colors_update();
 367                 }
 368
 369         options->image.alpha_color_1 = c_options->image.alpha_color_1;
 370         options->image.alpha_color_2 = c_options->image.alpha_color_2;
 371
 372         options->fullscreen.screen = c_options->fullscreen.screen;
 373         options->fullscreen.clean_flip = c_options->fullscreen.clean_flip;
 374         options->fullscreen.disable_saver = c_options->fullscreen.disable_saver;
 375         options->fullscreen.above = c_options->fullscreen.above;
 376         if (c_options->image_overlay.template_string)
 377                 set_image_overlay_template_string(&options->image_overlay.template_string,
 378                                                   c_options->image_overlay.template_string);
 379         if (c_options->image_overlay.font)
 380                 set_image_overlay_font_string(&options->image_overlay.font,
 381                                                   c_options->image_overlay.font);
 382         options->image_overlay.text_red = c_options->image_overlay.text_red;
 383         options->image_overlay.text_green = c_options->image_overlay.text_green;
 384         options->image_overlay.text_blue = c_options->image_overlay.text_blue;
 385         options->image_overlay.text_alpha = c_options->image_overlay.text_alpha;
 386         options->image_overlay.background_red = c_options->image_overlay.background_red;
 387         options->image_overlay.background_green = c_options->image_overlay.background_green;
 388         options->image_overlay.background_blue = c_options->image_overlay.background_blue;
 389         options->image_overlay.background_alpha = c_options->image_overlay.background_alpha;
 390         options->update_on_time_change = c_options->update_on_time_change;
 391
 392         options->duplicates_similarity_threshold = c_options->duplicates_similarity_threshold;
 393         options->rot_invariant_sim = c_options->rot_invariant_sim;
 394
 395         options->tree_descend_subdirs = c_options->tree_descend_subdirs;
 396
 397         options->view_dir_list_single_click_enter = c_options->view_dir_list_single_click_enter;
 398         options->circular_selection_lists = c_options->circular_selection_lists;
 399
 400         options->open_recent_list_maxsize = c_options->open_recent_list_maxsize;
 401         options->dnd_icon_size = c_options->dnd_icon_size;
 402         options->clipboard_selection = c_options->clipboard_selection;
 403         options->dnd_default_action = c_options->dnd_default_action;
 404
 405         options->metadata.save_in_image_file = c_options->metadata.save_in_image_file;
 406         options->metadata.save_legacy_IPTC = c_options->metadata.save_legacy_IPTC;
 407         options->metadata.warn_on_write_problems = c_options->metadata.warn_on_write_problems;
 408         options->metadata.save_legacy_format = c_options->metadata.save_legacy_format;
 409         options->metadata.sync_grouped_files = c_options->metadata.sync_grouped_files;
 410         options->metadata.confirm_write = c_options->metadata.confirm_write;
 411         options->metadata.sidecar_extended_name = c_options->metadata.sidecar_extended_name;
 412         options->metadata.confirm_timeout = c_options->metadata.confirm_timeout;
 413         options->metadata.confirm_after_timeout = c_options->metadata.confirm_after_timeout;
 414         options->metadata.confirm_on_image_change = c_options->metadata.confirm_on_image_change;
 415         options->metadata.confirm_on_dir_change = c_options->metadata.confirm_on_dir_change;
 416         options->metadata.keywords_case_sensitive = c_options->metadata.keywords_case_sensitive;
 417         options->metadata.write_orientation = c_options->metadata.write_orientation;
 418         options->stereo.mode = (c_options->stereo.mode & (PR_STEREO_HORIZ | PR_STEREO_VERT | PR_STEREO_FIXED | PR_STEREO_ANAGLYPH | PR_STEREO_HALF)) |
 419                                (c_options->stereo.tmp.mirror_right ? PR_STEREO_MIRROR_RIGHT : 0) |
 420                                (c_options->stereo.tmp.flip_right   ? PR_STEREO_FLIP_RIGHT : 0) |
 421                                (c_options->stereo.tmp.mirror_left  ? PR_STEREO_MIRROR_LEFT : 0) |
 422                                (c_options->stereo.tmp.flip_left    ? PR_STEREO_FLIP_LEFT : 0) |
 423                                (c_options->stereo.tmp.swap         ? PR_STEREO_SWAP : 0) |
 424                                (c_options->stereo.tmp.temp_disable ? PR_STEREO_TEMP_DISABLE : 0);
 425         options->stereo.fsmode = (c_options->stereo.fsmode & (PR_STEREO_HORIZ | PR_STEREO_VERT | PR_STEREO_FIXED | PR_STEREO_ANAGLYPH | PR_STEREO_HALF)) |
 426                                (c_options->stereo.tmp.fs_mirror_right ? PR_STEREO_MIRROR_RIGHT : 0) |
 427                                (c_options->stereo.tmp.fs_flip_right   ? PR_STEREO_FLIP_RIGHT : 0) |
 428                                (c_options->stereo.tmp.fs_mirror_left  ? PR_STEREO_MIRROR_LEFT : 0) |
 429                                (c_options->stereo.tmp.fs_flip_left    ? PR_STEREO_FLIP_LEFT : 0) |
 430                                (c_options->stereo.tmp.fs_swap         ? PR_STEREO_SWAP : 0) |
 431                                (c_options->stereo.tmp.fs_temp_disable ? PR_STEREO_TEMP_DISABLE : 0);
 432         options->stereo.enable_fsmode = c_options->stereo.enable_fsmode;
 433         options->stereo.fixed_w = c_options->stereo.fixed_w;
 434         options->stereo.fixed_h = c_options->stereo.fixed_h;
 435         options->stereo.fixed_x1 = c_options->stereo.fixed_x1;
 436         options->stereo.fixed_y1 = c_options->stereo.fixed_y1;
 437         options->stereo.fixed_x2 = c_options->stereo.fixed_x2;
 438         options->stereo.fixed_y2 = c_options->stereo.fixed_y2;
 439
 440         options->info_keywords.height = c_options->info_keywords.height;
 441         options->info_title.height = c_options->info_title.height;
 442         options->info_comment.height = c_options->info_comment.height;
 443         options->info_rating.height = c_options->info_rating.height;
 444
 445         options->show_predefined_keyword_tree = c_options->show_predefined_keyword_tree;
 446         options->expand_menu_toolbar = c_options->expand_menu_toolbar;
 447
 448         options->marks_save = c_options->marks_save;
 449         options->with_rename = c_options->with_rename;
 450         options->collections_on_top = c_options->collections_on_top;
 451         options->hide_window_in_fullscreen = c_options->hide_window_in_fullscreen;
 452         config_entry_to_option(help_search_engine_entry, &options->help_search_engine, NULL);
 453
 454         options->external_preview.enable = c_options->external_preview.enable;
 455         config_entry_to_option(external_preview_select_entry, &options->external_preview.select, NULL);
 456         config_entry_to_option(external_preview_extract_entry, &options->external_preview.extract, NULL);
 457
 458         options->read_metadata_in_idle = c_options->read_metadata_in_idle;
 459
 460         options->star_rating.star = c_options->star_rating.star;
 461         options->star_rating.rejected = c_options->star_rating.rejected;
 462
 463         options->threads.duplicates = c_options->threads.duplicates > 0 ? c_options->threads.duplicates : -1;
 464
 465 #ifdef DEBUG
 466         set_debug_level(debug_c);
 467 #endif
 468
 469 #ifdef HAVE_LCMS
 470         for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
 471                 {
 472                 config_entry_to_option(color_profile_input_name_entry[i], &options->color_profile.input_name[i], NULL);
 473                 config_entry_to_option(color_profile_input_file_entry[i], &options->color_profile.input_file[i], NULL);
 474                 }
 475         config_entry_to_option(color_profile_screen_file_entry, &options->color_profile.screen_file, NULL);
 476         options->color_profile.use_x11_screen_profile = c_options->color_profile.use_x11_screen_profile;
 477         if (options->color_profile.render_intent != c_options->color_profile.render_intent)
 478                 {
 479                 options->color_profile.render_intent = c_options->color_profile.render_intent;
 480                 color_man_update();
 481                 }
 482 #endif
 483
 484         options->mouse_button_8 = c_options->mouse_button_8;
 485         options->mouse_button_9 = c_options->mouse_button_9;
 486
 487         options->override_disable_gpu = c_options->override_disable_gpu;
 488
 489         config_tab_keywords_save();
 490
 491         image_options_sync();
 492
 493         if (refresh)
 494                 {
 495                 filter_rebuild();
 496                 layout_refresh(NULL);
 497                 }
 498
 499         if (accel_store) gtk_tree_model_foreach(GTK_TREE_MODEL(accel_store), accel_apply_cb, NULL);
 500
 501         toolbar_apply(TOOLBAR_MAIN);
 502         toolbar_apply(TOOLBAR_STATUS);
 503 }
 504
 505 /*
 506  *-----------------------------------------------------------------------------
 507  * config window main button callbacks (private)
 508  *-----------------------------------------------------------------------------
 509  */
 510
 511 static void config_window_close_cb(GtkWidget *widget, gpointer data)
 512 {
 513         gtk_widget_destroy(configwindow);
 514         configwindow = NULL;
 515         filter_store = NULL;
 516 }
 517
 518 static void config_window_help_cb(GtkWidget *widget, gpointer data)
 519 {
 520         GtkWidget *notebook = data;
 521         gint i;
 522
 523         static gchar *html_section[] =
 524         {
 525         "GuideOptionsGeneral.html",
 526         "GuideOptionsImage.html",
 527         "GuideOptionsOSD.html",
 528         "GuideOptionsWindow.html",
 529         "GuideOptionsKeyboard.html",
 530         "GuideOptionsFiltering.html",
 531         "GuideOptionsMetadata.html",
 532         "GuideOptionsKeywords.html",
 533         "GuideOptionsColor.html",
 534         "GuideOptionsStereo.html",
 535         "GuideOptionsBehavior.html",
 536         "GuideOptionsToolbar.html",
 537         "GuideOptionsToolbar.html",
 538         "GuideOptionsAdvanced.html"
 539         };
 540
 541         i = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
 542         help_window_show(html_section[i]);
 543 }
 544
 545 static gboolean config_window_delete(GtkWidget *widget, GdkEventAny *event, gpointer data)
 546 {
 547         config_window_close_cb(NULL, NULL);
 548         return TRUE;
 549 }
 550
 551 static void config_window_ok_cb(GtkWidget *widget, gpointer data)
 552 {
 553         LayoutWindow *lw;
 554         GtkNotebook *notebook = data;
 555         GdkWindow *window;
 556         gint x;
 557         gint y;
 558         gint w;
 559         gint h;
 560         gint page_number;
 561
 562         lw = layout_window_list->data;
 563
 564         window = gtk_widget_get_window(widget);
 565         gdk_window_get_root_origin(window, &x, &y);
 566         w = gdk_window_get_width(window);
 567         h = gdk_window_get_height(window);
 568         page_number = gtk_notebook_get_current_page(notebook);
 569
 570         lw->options.preferences_window.x = x;
 571         lw->options.preferences_window.y = y;
 572         lw->options.preferences_window.w = w;
 573         lw->options.preferences_window.h = h;
 574         lw->options.preferences_window.page_number = page_number;
 575
 576         config_window_apply();
 577         layout_util_sync(lw);
 578         save_options(options);
 579         config_window_close_cb(NULL, NULL);
 580 }
 581
 582 /*
 583  *-----------------------------------------------------------------------------
 584  * config window setup (private)
 585  *-----------------------------------------------------------------------------
 586  */
 587
 588 static void quality_menu_cb(GtkWidget *combo, gpointer data)
 589 {
 590         gint *option = data;
 591
 592         switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
 593                 {
 594                 case 0:
 595                 default:
 596                         *option = GDK_INTERP_NEAREST;
 597                         break;
 598                 case 1:
 599                         *option = GDK_INTERP_TILES;
 600                         break;
 601                 case 2:
 602                         *option = GDK_INTERP_BILINEAR;
 603                         break;
 604                 }
 605 }
 606
 607 static void dnd_default_action_selection_menu_cb(GtkWidget *combo, gpointer data)
 608 {
 609         gint *option = data;
 610
 611         switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
 612                 {
 613                 case 0:
 614                 default:
 615                         *option = DND_ACTION_ASK;
 616                         break;
 617                 case 1:
 618                         *option = DND_ACTION_COPY;
 619                         break;
 620                 case 2:
 621                         *option = DND_ACTION_MOVE;
 622                         break;
 623                 }
 624 }
 625 static void clipboard_selection_menu_cb(GtkWidget *combo, gpointer data)
 626 {
 627         gint *option = data;
 628
 629         switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
 630                 {
 631                 case 0:
 632                         *option = CLIPBOARD_PRIMARY;
 633                         break;
 634                 case 1:
 635                         *option = CLIPBOARD_CLIPBOARD;
 636                         break;
 637                 case 2:
 638                         *option = CLIPBOARD_BOTH;
 639                         break;
 640                 default:
 641                         *option = CLIPBOARD_BOTH;
 642                 }
 643 }
 644
 645 static void add_quality_menu(GtkWidget *table, gint column, gint row, const gchar *text,
 646                              guint option, guint *option_c)
 647 {
 648         GtkWidget *combo;
 649         gint current = 0;
 650
 651         *option_c = option;
 652
 653         pref_table_label(table, column, row, text, 0.0);
 654
 655         combo = gtk_combo_box_text_new();
 656
 657         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Nearest (worst, but fastest)"));
 658         if (option == GDK_INTERP_NEAREST) current = 0;
 659         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Tiles"));
 660         if (option == GDK_INTERP_TILES) current = 1;
 661         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Bilinear (best, but slowest)"));
 662         if (option == GDK_INTERP_BILINEAR) current = 2;
 663
 664         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
 665
 666         g_signal_connect(G_OBJECT(combo), "changed",
 667                          G_CALLBACK(quality_menu_cb), option_c);
 668
 669         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
 670         gtk_widget_show(combo);
 671 }
 672
 673 static void add_dnd_default_action_selection_menu(GtkWidget *table, gint column, gint row, const gchar *text, DnDAction option, DnDAction *option_c)
 674 {
 675         GtkWidget *combo;
 676         gint current = 0;
 677
 678         *option_c = option;
 679
 680         pref_table_label(table, column, row, text, 0.0);
 681
 682         combo = gtk_combo_box_text_new();
 683
 684         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Ask"));
 685         if (option == DND_ACTION_ASK) current = 0;
 686         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Copy"));
 687         if (option == DND_ACTION_COPY) current = 1;
 688         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Move"));
 689         if (option == DND_ACTION_MOVE) current = 2;
 690
 691         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
 692
 693         g_signal_connect(G_OBJECT(combo), "changed",
 694                          G_CALLBACK(dnd_default_action_selection_menu_cb), option_c);
 695
 696         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
 697         gtk_widget_show(combo);
 698 }
 699
 700 static void add_clipboard_selection_menu(GtkWidget *table, gint column, gint row, const gchar *text,
 701                              gint option, gint *option_c)
 702 {
 703         GtkWidget *combo;
 704         gint current = 0;
 705
 706         *option_c = option;
 707
 708         pref_table_label(table, column, row, text, 0.0);
 709
 710         combo = gtk_combo_box_text_new();
 711
 712         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Primary"));
 713         if (option == CLIPBOARD_PRIMARY) current = 0;
 714         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Clipboard"));
 715         if (option == CLIPBOARD_CLIPBOARD) current = 1;
 716         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Both"));
 717         if (option == CLIPBOARD_BOTH) current = 2;
 718
 719         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
 720
 721         g_signal_connect(G_OBJECT(combo), "changed",
 722                          G_CALLBACK(clipboard_selection_menu_cb), option_c);
 723
 724         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
 725         gtk_widget_show(combo);
 726 }
 727
 728 static void zoom_style_selection_menu_cb(GtkWidget *combo, gpointer data)
 729 {
 730         gint *option = data;
 731
 732         switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
 733                 {
 734                 case 0:
 735                         *option = ZOOM_GEOMETRIC;
 736                         break;
 737                 case 1:
 738                         *option = ZOOM_ARITHMETIC;
 739                         break;
 740                 default:
 741                         *option = ZOOM_GEOMETRIC;
 742                 }
 743 }
 744
 745 static void add_zoom_style_selection_menu(GtkWidget *table, gint column, gint row, const gchar *text, ZoomStyle option, ZoomStyle *option_c)
 746 {
 747         GtkWidget *combo;
 748         gint current = 0;
 749
 750         *option_c = option;
 751
 752         pref_table_label(table, column, row, text, 0.0);
 753
 754         combo = gtk_combo_box_text_new();
 755
 756         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Geometric"));
 757         if (option == ZOOM_GEOMETRIC) current = 0;
 758         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Arithmetic"));
 759         if (option == ZOOM_ARITHMETIC) current = 1;
 760
 761         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
 762
 763         g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(zoom_style_selection_menu_cb), option_c);
 764
 765         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
 766         gtk_widget_show(combo);
 767 }
 768
 769 typedef struct _UseableMouseItems UseableMouseItems;
 770 struct _UseableMouseItems
 771 {
 772         gchar *name; /* GtkActionEntry terminology */
 773         gchar *label;
 774         gchar *stock_id;
 775 };
 776
 777 static const UseableMouseItems useable_mouse_items[] = {
 778         {"", "", NULL},
 779         {"FirstImage",  N_("First Image"), GTK_STOCK_GOTO_TOP},
 780         {"PrevImage",   N_("Previous Image"), GTK_STOCK_GO_UP},
 781         {"NextImage",   N_("Next Image"), GTK_STOCK_GO_DOWN},
 782         {"LastImage",   N_("Last Image"), GTK_STOCK_GOTO_BOTTOM},
 783         {"Back",        N_("Back"), GTK_STOCK_GO_BACK},
 784         {"Forward",     N_("Forward"), GTK_STOCK_GO_FORWARD},
 785         {"Home",        N_("Home"), GTK_STOCK_HOME},
 786         {"Up",  N_("Up"), GTK_STOCK_GO_UP},
 787         {"FirstPage",   N_("First page"), GTK_STOCK_MEDIA_PREVIOUS},
 788         {"LastPage",    N_("Last Page"), GTK_STOCK_MEDIA_NEXT},
 789         {"NextPage",    N_("Next page"), GTK_STOCK_MEDIA_FORWARD},
 790         {"PrevPage",    N_("Previous Page"), GTK_STOCK_MEDIA_REWIND},
 791         {"NewWindow",   N_("New _window"), GTK_STOCK_NEW},
 792         {"NewCollection",       N_("New collection"), GTK_STOCK_INDEX},
 793         {"OpenCollection",      N_("Open collection"), GTK_STOCK_OPEN},
 794         {"Search",      N_("Search"), GTK_STOCK_FIND},
 795         {"FindDupes",   N_("Find duplicates"), GTK_STOCK_FIND},
 796         {"NewFolder",   N_("New folder"),GTK_STOCK_DIRECTORY},
 797         {"Copy",        N_("Copy"), GTK_STOCK_COPY},
 798         {"Move",        N_("Move"), PIXBUF_INLINE_ICON_MOVE},
 799         {"Rename",      N_("Rename"), PIXBUF_INLINE_ICON_RENAME},
 800         {"Delete",      N_("Delete"), GTK_STOCK_DELETE},
 801         {"CloseWindow", N_("Close Window"), GTK_STOCK_CLOSE},
 802         {"PanView",     N_("Pan view"), PIXBUF_INLINE_ICON_PANORAMA},
 803         {"SelectAll",   N_("Select all"), PIXBUF_INLINE_ICON_SELECT_ALL},
 804         {"SelectNone",  N_("Select none"), PIXBUF_INLINE_ICON_SELECT_NONE},
 805         {"SelectInvert",        N_("Select invert"), PIXBUF_INLINE_ICON_SELECT_INVERT},
 806         {"ShowFileFilter",      N_("Show file filter"), PIXBUF_INLINE_ICON_FILE_FILTER},
 807         {"RectangularSelection",        N_("Select rectangle"), PIXBUF_INLINE_ICON_SELECT_RECTANGLE},
 808         {"Print",       N_("Print"), GTK_STOCK_PRINT},
 809         {"Preferences", N_("Preferences"), GTK_STOCK_PREFERENCES},
 810         {"LayoutConfig",        N_("Configure this window"), GTK_STOCK_PREFERENCES},
 811         {"Maintenance", N_("Cache maintenance"), PIXBUF_INLINE_ICON_MAINTENANCE},
 812         {"RotateCW",    N_("Rotate clockwise 90°"), PIXBUF_INLINE_ICON_CW},
 813         {"RotateCCW",   N_("Rotate counterclockwise 90°"), PIXBUF_INLINE_ICON_CCW},
 814         {"Rotate180",   N_("Rotate 180°"), PIXBUF_INLINE_ICON_180},
 815         {"Mirror",      N_("Mirror"), PIXBUF_INLINE_ICON_MIRROR},
 816         {"Flip",        N_("Flip"), PIXBUF_INLINE_ICON_FLIP},
 817         {"AlterNone",   N_("Original state"), PIXBUF_INLINE_ICON_ORIGINAL},
 818         {"ZoomIn",      N_("Zoom in"), GTK_STOCK_ZOOM_IN},
 819         {"ZoomOut",     N_("Zoom out"), GTK_STOCK_ZOOM_OUT},
 820         {"Zoom100",     N_("Zoom 1:1"), GTK_STOCK_ZOOM_100},
 821         {"ZoomFit",     N_("Zoom to fit"), GTK_STOCK_ZOOM_FIT},
 822         {"ZoomFillHor", N_("Fit Horizontaly"), PIXBUF_INLINE_ICON_ZOOMFILLHOR},
 823         {"ZoomFillVert",        N_("Fit vertically"), PIXBUF_INLINE_ICON_ZOOMFILLVERT},
 824         {"Zoom200",     N_("Zoom 2:1"), GTK_STOCK_FILE},
 825         {"Zoom300",     N_("Zoom 3:1"), GTK_STOCK_FILE},
 826         {"Zoom400",     N_("Zoom 4:1"), GTK_STOCK_FILE},
 827         {"Zoom50",      N_("Zoom 1:2"), GTK_STOCK_FILE},
 828         {"Zoom33",      N_("Zoom1:3"), GTK_STOCK_FILE},
 829         {"Zoom25",      N_("Zoom 1:4"), GTK_STOCK_FILE},
 830         {"ConnectZoomIn",       N_("Connected Zoom in"), GTK_STOCK_ZOOM_IN},
 831         {"SplitPaneSync",       N_("Split Pane Sync"), PIXBUF_INLINE_SPLIT_PANE_SYNC},
 832         {"Grayscale",   N_("Grayscale"), PIXBUF_INLINE_ICON_GRAYSCALE},
 833         {"OverUnderExposed",    N_("Over Under Exposed"), PIXBUF_INLINE_ICON_EXPOSURE},
 834         {"HideTools",   N_("Hide file list"), PIXBUF_INLINE_ICON_HIDETOOLS},
 835         {"SlideShowPause",      N_("Pause slideshow"), GTK_STOCK_MEDIA_PAUSE},
 836         {"SlideShowFaster",     N_("Slideshow Faster"), GTK_STOCK_FILE},
 837         {"SlideShowSlower",     N_("Slideshow Slower"), GTK_STOCK_FILE},
 838         {"Refresh",     N_("Refresh"), GTK_STOCK_REFRESH},
 839         {"HelpContents",        N_("Help"), GTK_STOCK_HELP},
 840         {"ExifWin",     N_("Exif window"), PIXBUF_INLINE_ICON_EXIF},
 841         {"Thumbnails",  N_("Show thumbnails"), PIXBUF_INLINE_ICON_THUMB},
 842         {"ShowMarks",   N_("Show marks"), PIXBUF_INLINE_ICON_MARKS},
 843         {"DrawRectangle",       N_("Draw Rectangle"), PIXBUF_INLINE_ICON_DRAW_RECTANGLE},
 844         {"FloatTools",  N_("Float file list"), PIXBUF_INLINE_ICON_FLOAT},
 845         {"SBar",        N_("Info sidebar"), PIXBUF_INLINE_ICON_INFO},
 846         {"SBarSort",    N_("Sort manager"), PIXBUF_INLINE_ICON_SORT},
 847         {"Quit",        N_("Quit"), GTK_STOCK_QUIT},
 848         {NULL,          NULL, NULL}
 849 };
 850
 851 static void mouse_buttons_selection_menu_cb(GtkWidget *combo, gpointer data)
 852 {
 853         gchar **option = data;
 854         gchar *label;
 855
 856         label = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
 857
 858         const UseableMouseItems *list = useable_mouse_items;
 859
 860         while (list->name)
 861                 {
 862                 if (g_strcmp0(list->label, label) == 0)
 863                         {
 864                         break;
 865                         }
 866                 list++;
 867                 }
 868
 869         g_free(*option);
 870         *option = g_strdup(list->name);
 871         g_free(label);
 872 }
 873
 874 static void add_mouse_selection_menu(GtkWidget *table, gint column, gint row, const gchar *text,
 875                              gchar *option, gchar **option_c)
 876 {
 877         GtkWidget *combo;
 878         gint current = 0;
 879         gint i = 0;
 880
 881         *option_c = option;
 882
 883         pref_table_label(table, column, row, text, 0.0);
 884
 885         combo = gtk_combo_box_text_new();
 886
 887         const UseableMouseItems *list = useable_mouse_items;
 888
 889         while (list->name)
 890                 {
 891                 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), list->label);
 892                 if (g_strcmp0(list->name, option) == 0)
 893                         {
 894                         current = i;
 895                         }
 896                 i++;
 897                 list++;
 898                 }
 899
 900         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
 901
 902         g_signal_connect(G_OBJECT(combo), "changed",
 903                          G_CALLBACK(mouse_buttons_selection_menu_cb), option_c);
 904
 905         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
 906         gtk_widget_show(combo);
 907 }
 908
 909 static void thumb_size_menu_cb(GtkWidget *combo, gpointer data)
 910 {
 911         gint n;
 912
 913         n = gtk_combo_box_get_active(GTK_COMBO_BOX(combo));
 914         if (n < 0) return;
 915
 916         if ((guint) n < sizeof(thumb_size_list) / sizeof(ThumbSize))
 917                 {
 918                 c_options->thumbnails.max_width = thumb_size_list[n].w;
 919                 c_options->thumbnails.max_height = thumb_size_list[n].h;
 920                 }
 921         else
 922                 {
 923                 c_options->thumbnails.max_width = options->thumbnails.max_width;
 924                 c_options->thumbnails.max_height = options->thumbnails.max_height;
 925                 }
 926 }
 927
 928 static void add_thumb_size_menu(GtkWidget *table, gint column, gint row, gchar *text)
 929 {
 930         GtkWidget *combo;
 931         gint current;
 932         gint i;
 933
 934         c_options->thumbnails.max_width = options->thumbnails.max_width;
 935         c_options->thumbnails.max_height = options->thumbnails.max_height;
 936
 937         pref_table_label(table, column, row, text, 0.0);
 938
 939         combo = gtk_combo_box_text_new();
 940
 941         current = -1;
 942         for (i = 0; (guint) i < sizeof(thumb_size_list) / sizeof(ThumbSize); i++)
 943                 {
 944                 gint w, h;
 945                 gchar *buf;
 946
 947                 w = thumb_size_list[i].w;
 948                 h = thumb_size_list[i].h;
 949
 950                 buf = g_strdup_printf("%d x %d", w, h);
 951                 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), buf);
 952                 g_free(buf);
 953
 954                 if (w == options->thumbnails.max_width && h == options->thumbnails.max_height) current = i;
 955                 }
 956
 957         if (current == -1)
 958                 {
 959                 gchar *buf;
 960
 961                 buf = g_strdup_printf("%s %d x %d", _("Custom"), options->thumbnails.max_width, options->thumbnails.max_height);
 962                 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), buf);
 963                 g_free(buf);
 964
 965                 current = i;
 966                 }
 967
 968         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
 969         g_signal_connect(G_OBJECT(combo), "changed",
 970                          G_CALLBACK(thumb_size_menu_cb), NULL);
 971
 972         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
 973         gtk_widget_show(combo);
 974 }
 975
 976 static void stereo_mode_menu_cb(GtkWidget *combo, gpointer data)
 977 {
 978         gint *option = data;
 979
 980         switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
 981                 {
 982                 case 0:
 983                 default:
 984                         *option = PR_STEREO_NONE;
 985                         break;
 986                 case 1:
 987                         *option = PR_STEREO_ANAGLYPH_RC;
 988                         break;
 989                 case 2:
 990                         *option = PR_STEREO_ANAGLYPH_GM;
 991                         break;
 992                 case 3:
 993                         *option = PR_STEREO_ANAGLYPH_YB;
 994                         break;
 995                 case 4:
 996                         *option = PR_STEREO_ANAGLYPH_GRAY_RC;
 997                         break;
 998                 case 5:
 999                         *option = PR_STEREO_ANAGLYPH_GRAY_GM;
1000                         break;
1001                 case 6:
1002                         *option = PR_STEREO_ANAGLYPH_GRAY_YB;
1003                         break;
1004                 case 7:
1005                         *option = PR_STEREO_ANAGLYPH_DB_RC;
1006                         break;
1007                 case 8:
1008                         *option = PR_STEREO_ANAGLYPH_DB_GM;
1009                         break;
1010                 case 9:
1011                         *option = PR_STEREO_ANAGLYPH_DB_YB;
1012                         break;
1013                 case 10:
1014                         *option = PR_STEREO_HORIZ;
1015                         break;
1016                 case 11:
1017                         *option = PR_STEREO_HORIZ | PR_STEREO_HALF;
1018                         break;
1019                 case 12:
1020                         *option = PR_STEREO_VERT;
1021                         break;
1022                 case 13:
1023                         *option = PR_STEREO_VERT | PR_STEREO_HALF;
1024                         break;
1025                 case 14:
1026                         *option = PR_STEREO_FIXED;
1027                         break;
1028                 }
1029 }
1030
1031 static void add_stereo_mode_menu(GtkWidget *table, gint column, gint row, const gchar *text,
1032                              gint option, gint *option_c, gboolean add_fixed)
1033 {
1034         GtkWidget *combo;
1035         gint current = 0;
1036
1037         *option_c = option;
1038
1039         pref_table_label(table, column, row, text, 0.0);
1040
1041         combo = gtk_combo_box_text_new();
1042
1043         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Single image"));
1044
1045         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Red-Cyan"));
1046         if (option & PR_STEREO_ANAGLYPH_RC) current = 1;
1047         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Green-Magenta"));
1048         if (option & PR_STEREO_ANAGLYPH_GM) current = 2;
1049         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Yellow-Blue"));
1050         if (option & PR_STEREO_ANAGLYPH_YB) current = 3;
1051         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Gray Red-Cyan"));
1052         if (option & PR_STEREO_ANAGLYPH_GRAY_RC) current = 4;
1053         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Gray Green-Magenta"));
1054         if (option & PR_STEREO_ANAGLYPH_GRAY_GM) current = 5;
1055         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Gray Yellow-Blue"));
1056         if (option & PR_STEREO_ANAGLYPH_GRAY_YB) current = 6;
1057         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Dubois Red-Cyan"));
1058         if (option & PR_STEREO_ANAGLYPH_DB_RC) current = 7;
1059         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Dubois Green-Magenta"));
1060         if (option & PR_STEREO_ANAGLYPH_DB_GM) current = 8;
1061         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Anaglyph Dubois Yellow-Blue"));
1062         if (option & PR_STEREO_ANAGLYPH_DB_YB) current = 9;
1063
1064         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Side by Side"));
1065         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Side by Side Half size"));
1066         if (option & PR_STEREO_HORIZ)
1067                 {
1068                 current = 10;
1069                 if (option & PR_STEREO_HALF) current = 11;
1070                 }
1071
1072         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Top - Bottom"));
1073         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Top - Bottom Half size"));
1074         if (option & PR_STEREO_VERT)
1075                 {
1076                 current = 12;
1077                 if (option & PR_STEREO_HALF) current = 13;
1078                 }
1079
1080         if (add_fixed)
1081                 {
1082                 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Fixed position"));
1083                 if (option & PR_STEREO_FIXED) current = 14;
1084                 }
1085
1086         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
1087
1088         g_signal_connect(G_OBJECT(combo), "changed",
1089                          G_CALLBACK(stereo_mode_menu_cb), option_c);
1090
1091         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
1092         gtk_widget_show(combo);
1093 }
1094
1095 static void video_menu_cb(GtkWidget *combo, gpointer data)
1096 {
1097         gchar **option = data;
1098
1099         EditorDescription *ed = g_list_nth_data(editor_list_get(), gtk_combo_box_get_active(GTK_COMBO_BOX(combo)));
1100         *option = ed->key;
1101 }
1102
1103 static void video_menu_populate(gpointer data, gpointer user_data)
1104 {
1105         GtkWidget *combo = user_data;
1106         EditorDescription *ed = data;
1107
1108         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), ed->name);
1109 }
1110
1111 static void add_video_menu(GtkWidget *table, gint column, gint row, const gchar *text,
1112                              gchar *option, gchar **option_c)
1113 {
1114         GtkWidget *combo;
1115         gint current;
1116 /* use lists since they are sorted */
1117         GList *eds = editor_list_get();
1118
1119         *option_c = option;
1120
1121         pref_table_label(table, column, row, text, 0.0);
1122
1123         combo = gtk_combo_box_text_new();
1124         g_list_foreach(eds,video_menu_populate,(gpointer)combo);
1125         current = option ? g_list_index(eds,g_hash_table_lookup(editors,option)): -1;
1126
1127         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
1128
1129         g_signal_connect(G_OBJECT(combo), "changed",
1130                          G_CALLBACK(video_menu_cb), option_c);
1131
1132         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
1133         gtk_widget_show(combo);
1134 }
1135
1136 static void filter_store_populate(void)
1137 {
1138         GList *work;
1139
1140         if (!filter_store) return;
1141
1142         gtk_list_store_clear(filter_store);
1143
1144         work = filter_get_list();
1145         while (work)
1146                 {
1147                 FilterEntry *fe;
1148                 GtkTreeIter iter;
1149
1150                 fe = work->data;
1151                 work = work->next;
1152
1153                 gtk_list_store_append(filter_store, &iter);
1154                 gtk_list_store_set(filter_store, &iter, 0, fe, -1);
1155                 }
1156 }
1157
1158 static void filter_store_ext_edit_cb(GtkCellRendererText *cell, gchar *path_str,
1159                                      gchar *new_text, gpointer data)
1160 {
1161         GtkWidget *model = data;
1162         FilterEntry *fe = data;
1163         GtkTreePath *tpath;
1164         GtkTreeIter iter;
1165
1166         if (!new_text || strlen(new_text) < 1) return;
1167
1168         tpath = gtk_tree_path_new_from_string(path_str);
1169         gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, tpath);
1170         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &fe, -1);
1171
1172         g_free(fe->extensions);
1173         fe->extensions = g_strdup(new_text);
1174
1175         gtk_tree_path_free(tpath);
1176         filter_rebuild();
1177 }
1178
1179 static void filter_store_class_edit_cb(GtkCellRendererText *cell, gchar *path_str,
1180                                        gchar *new_text, gpointer data)
1181 {
1182         GtkWidget *model = data;
1183         FilterEntry *fe = data;
1184         GtkTreePath *tpath;
1185         GtkTreeIter iter;
1186         gint i;
1187
1188         if (!new_text || !new_text[0]) return;
1189
1190         tpath = gtk_tree_path_new_from_string(path_str);
1191         gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, tpath);
1192         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &fe, -1);
1193
1194         for (i = 0; i < FILE_FORMAT_CLASSES; i++)
1195                 {
1196                 if (strcmp(new_text, _(format_class_list[i])) == 0)
1197                         {
1198                         fe->file_class = i;
1199                         break;
1200                         }
1201                 }
1202
1203         gtk_tree_path_free(tpath);
1204         filter_rebuild();
1205 }
1206
1207 static void filter_store_desc_edit_cb(GtkCellRendererText *cell, gchar *path_str,
1208                                       gchar *new_text, gpointer data)
1209 {
1210         GtkWidget *model = data;
1211         FilterEntry *fe;
1212         GtkTreePath *tpath;
1213         GtkTreeIter iter;
1214
1215         if (!new_text || !new_text[0]) return;
1216
1217         tpath = gtk_tree_path_new_from_string(path_str);
1218         gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, tpath);
1219         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &fe, -1);
1220
1221         g_free(fe->description);
1222         fe->description = g_strdup(new_text);
1223
1224         gtk_tree_path_free(tpath);
1225 }
1226
1227 static void filter_store_enable_cb(GtkCellRendererToggle *renderer,
1228                                    gchar *path_str, gpointer data)
1229 {
1230         GtkWidget *model = data;
1231         FilterEntry *fe;
1232         GtkTreePath *tpath;
1233         GtkTreeIter iter;
1234
1235         tpath = gtk_tree_path_new_from_string(path_str);
1236         gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, tpath);
1237         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &fe, -1);
1238
1239         fe->enabled = !fe->enabled;
1240
1241         gtk_tree_path_free(tpath);
1242         filter_rebuild();
1243 }
1244
1245 static void filter_store_writable_cb(GtkCellRendererToggle *renderer,
1246                                      gchar *path_str, gpointer data)
1247 {
1248         GtkWidget *model = data;
1249         FilterEntry *fe;
1250         GtkTreePath *tpath;
1251         GtkTreeIter iter;
1252
1253         tpath = gtk_tree_path_new_from_string(path_str);
1254         gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, tpath);
1255         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &fe, -1);
1256
1257         fe->writable = !fe->writable;
1258         if (fe->writable) fe->allow_sidecar = FALSE;
1259
1260         gtk_tree_path_free(tpath);
1261         filter_rebuild();
1262 }
1263
1264 static void filter_store_sidecar_cb(GtkCellRendererToggle *renderer,
1265                                     gchar *path_str, gpointer data)
1266 {
1267         GtkWidget *model = data;
1268         FilterEntry *fe;
1269         GtkTreePath *tpath;
1270         GtkTreeIter iter;
1271
1272         tpath = gtk_tree_path_new_from_string(path_str);
1273         gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, tpath);
1274         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, 0, &fe, -1);
1275
1276         fe->allow_sidecar = !fe->allow_sidecar;
1277         if (fe->allow_sidecar) fe->writable = FALSE;
1278
1279         gtk_tree_path_free(tpath);
1280         filter_rebuild();
1281 }
1282
1283 static void filter_set_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
1284                             GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
1285 {
1286         FilterEntry *fe;
1287
1288         gtk_tree_model_get(tree_model, iter, 0, &fe, -1);
1289
1290         switch (GPOINTER_TO_INT(data))
1291                 {
1292                 case FE_ENABLE:
1293                         g_object_set(GTK_CELL_RENDERER(cell),
1294                                      "active", fe->enabled, NULL);
1295                         break;
1296                 case FE_EXTENSION:
1297                         g_object_set(GTK_CELL_RENDERER(cell),
1298                                      "text", fe->extensions, NULL);
1299                         break;
1300                 case FE_DESCRIPTION:
1301                         g_object_set(GTK_CELL_RENDERER(cell),
1302                                      "text", fe->description, NULL);
1303                         break;
1304                 case FE_CLASS:
1305                         g_object_set(GTK_CELL_RENDERER(cell),
1306                                      "text", _(format_class_list[fe->file_class]), NULL);
1307                         break;
1308                 case FE_WRITABLE:
1309                         g_object_set(GTK_CELL_RENDERER(cell),
1310                                      "active", fe->writable, NULL);
1311                         break;
1312                 case FE_ALLOW_SIDECAR:
1313                         g_object_set(GTK_CELL_RENDERER(cell),
1314                                      "active", fe->allow_sidecar, NULL);
1315                         break;
1316                 }
1317 }
1318
1319 static gboolean filter_add_scroll(gpointer data)
1320 {
1321         GtkTreePath *path;
1322         GList *list_cells;
1323         GtkCellRenderer *cell;
1324         GtkTreeViewColumn *column;
1325         gint rows;
1326
1327         rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(filter_store), NULL);
1328         path = gtk_tree_path_new_from_indices(rows-1, -1);
1329
1330         column = gtk_tree_view_get_column(GTK_TREE_VIEW(data), 0);
1331
1332         list_cells = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
1333         cell = g_list_last(list_cells)->data;
1334
1335         gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(data),
1336                                                                 path, column, FALSE, 0.0, 0.0 );
1337         gtk_tree_view_set_cursor_on_cell(GTK_TREE_VIEW(data),
1338                                                                 path, column, cell, TRUE);
1339
1340         gtk_tree_path_free(path);
1341         g_list_free(list_cells);
1342
1343         return(FALSE);
1344 }
1345
1346 static void filter_add_cb(GtkWidget *widget, gpointer data)
1347 {
1348         filter_add_unique("description", ".new", FORMAT_CLASS_IMAGE, TRUE, FALSE, TRUE);
1349         filter_store_populate();
1350
1351         g_idle_add((GSourceFunc)filter_add_scroll, data);
1352 }
1353
1354 static void filter_remove_cb(GtkWidget *widget, gpointer data)
1355 {
1356         GtkWidget *filter_view = data;
1357         GtkTreeSelection *selection;
1358         GtkTreeIter iter;
1359         FilterEntry *fe;
1360
1361         if (!filter_store) return;
1362         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(filter_view));
1363         if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return;
1364         gtk_tree_model_get(GTK_TREE_MODEL(filter_store), &iter, 0, &fe, -1);
1365         if (!fe) return;
1366
1367         filter_remove_entry(fe);
1368         filter_rebuild();
1369         filter_store_populate();
1370 }
1371
1372 static gboolean filter_default_ok_scroll(GtkTreeView *data)
1373 {
1374         GtkTreeIter iter;
1375         GtkTreePath *path;
1376         GtkTreeViewColumn *column;
1377
1378         gtk_tree_model_get_iter_first(GTK_TREE_MODEL(filter_store), &iter);
1379         path = gtk_tree_model_get_path(GTK_TREE_MODEL(filter_store), &iter);
1380         column = gtk_tree_view_get_column(GTK_TREE_VIEW(data),0);
1381
1382         gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(data),
1383                                      path, column,
1384                                      FALSE, 0.0, 0.0);
1385
1386         gtk_tree_path_free(path);
1387
1388         return(FALSE);
1389 }
1390
1391 static void filter_default_ok_cb(GenericDialog *gd, gpointer data)
1392 {
1393         filter_reset();
1394         filter_add_defaults();
1395         filter_rebuild();
1396         filter_store_populate();
1397
1398         g_idle_add((GSourceFunc)filter_default_ok_scroll, gd->data);
1399 }
1400
1401 static void dummy_cancel_cb(GenericDialog *gd, gpointer data)
1402 {
1403         /* no op, only so cancel button appears */
1404 }
1405
1406 static void filter_default_cb(GtkWidget *widget, gpointer data)
1407 {
1408         GenericDialog *gd;
1409
1410         gd = generic_dialog_new(_("Reset filters"),
1411                                 "reset_filter", widget, TRUE,
1412                                 dummy_cancel_cb, data);
1413         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Reset filters"),
1414                                    _("This will reset the file filters to the defaults.\nContinue?"), TRUE);
1415         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, filter_default_ok_cb, TRUE);
1416         gtk_widget_show(gd->dialog);
1417 }
1418
1419 static void filter_disable_cb(GtkWidget *widget, gpointer data)
1420 {
1421         GtkWidget *frame = data;
1422
1423         gtk_widget_set_sensitive(frame,
1424                                  !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
1425 }
1426
1427 static void safe_delete_view_cb(GtkWidget *widget, gpointer data)
1428 {
1429         layout_set_path(NULL, gtk_entry_get_text(GTK_ENTRY(safe_delete_path_entry)));
1430 }
1431
1432 static void safe_delete_clear_ok_cb(GenericDialog *gd, gpointer data)
1433 {
1434         file_util_trash_clear();
1435 }
1436
1437 static void safe_delete_clear_cb(GtkWidget *widget, gpointer data)
1438 {
1439         GenericDialog *gd;
1440         GtkWidget *entry;
1441         gd = generic_dialog_new(_("Clear trash"),
1442                                 "clear_trash", widget, TRUE,
1443                                 dummy_cancel_cb, NULL);
1444         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Clear trash"),
1445                                     _("This will remove the trash contents."), FALSE);
1446         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, safe_delete_clear_ok_cb, TRUE);
1447         entry = gtk_entry_new();
1448         gtk_widget_set_can_focus(entry, FALSE);
1449         gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
1450         if (options->file_ops.safe_delete_path) gtk_entry_set_text(GTK_ENTRY(entry), options->file_ops.safe_delete_path);
1451         gtk_box_pack_start(GTK_BOX(gd->vbox), entry, FALSE, FALSE, 0);
1452         gtk_widget_show(entry);
1453         gtk_widget_show(gd->dialog);
1454 }
1455
1456 static void image_overlay_template_view_changed_cb(GtkWidget *widget, gpointer data)
1457 {
1458         GtkWidget *pTextView;
1459         GtkTextBuffer *pTextBuffer;
1460         GtkTextIter iStart;
1461         GtkTextIter iEnd;
1462
1463         pTextView = GTK_WIDGET(data);
1464
1465         pTextBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pTextView));
1466         gtk_text_buffer_get_start_iter(pTextBuffer, &iStart);
1467         gtk_text_buffer_get_end_iter(pTextBuffer, &iEnd);
1468
1469         set_image_overlay_template_string(&c_options->image_overlay.template_string,
1470                                           gtk_text_buffer_get_text(pTextBuffer, &iStart, &iEnd, TRUE));
1471 }
1472
1473 static void image_overlay_default_template_ok_cb(GenericDialog *gd, gpointer data)
1474 {
1475         GtkTextView *text_view = data;
1476         GtkTextBuffer *buffer;
1477
1478         set_default_image_overlay_template_string(&options->image_overlay.template_string);
1479         if (!configwindow) return;
1480
1481         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
1482         gtk_text_buffer_set_text(buffer, options->image_overlay.template_string, -1);
1483 }
1484
1485 static void image_overlay_default_template_cb(GtkWidget *widget, gpointer data)
1486 {
1487         GenericDialog *gd;
1488
1489         gd = generic_dialog_new(_("Reset image overlay template string"),
1490                                 "reset_image_overlay_template_string", widget, TRUE,
1491                                 dummy_cancel_cb, data);
1492         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, _("Reset image overlay template string"),
1493                                    _("This will reset the image overlay template string to the default.\nContinue?"), TRUE);
1494         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, image_overlay_default_template_ok_cb, TRUE);
1495         gtk_widget_show(gd->dialog);
1496 }
1497
1498 static void image_overlay_help_cb(GtkWidget *widget, gpointer data)
1499 {
1500         help_window_show("GuideOptionsOSD.html");
1501 }
1502
1503 static void image_overlay_set_font_cb(GtkWidget *widget, gpointer data)
1504 {
1505 #if GTK_CHECK_VERSION(3,4,0)
1506         GtkWidget *dialog;
1507         char *font;
1508         PangoFontDescription *font_desc;
1509
1510         dialog = gtk_font_chooser_dialog_new("Image Overlay Font", GTK_WINDOW(gtk_widget_get_toplevel(widget)));
1511         gtk_font_chooser_set_font(GTK_FONT_CHOOSER(dialog), options->image_overlay.font);
1512
1513         if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL)
1514                 {
1515                 font_desc = gtk_font_chooser_get_font_desc(GTK_FONT_CHOOSER(dialog));
1516                 font = pango_font_description_to_string(font_desc);
1517                 g_free(c_options->image_overlay.font);
1518                 c_options->image_overlay.font = g_strdup(font);
1519                 g_free(font);
1520                 }
1521
1522         gtk_widget_destroy(dialog);
1523 #else
1524         const char *font;
1525
1526         font = gtk_font_button_get_font_name(GTK_FONT_BUTTON(widget));
1527         c_options->image_overlay.font = g_strdup(font);
1528 #endif
1529 }
1530
1531 static void image_overlay_set_text_colour_cb(GtkWidget *widget, gpointer data)
1532 {
1533         GtkWidget *dialog;
1534 #if GTK_CHECK_VERSION(3,4,0)
1535         GdkRGBA colour;
1536
1537         dialog = gtk_color_chooser_dialog_new("Image Overlay Text Colour", GTK_WINDOW(gtk_widget_get_toplevel(widget)));
1538         colour.red = options->image_overlay.text_red;
1539         colour.green = options->image_overlay.text_green;
1540         colour.blue = options->image_overlay.text_blue;
1541         colour.alpha = options->image_overlay.text_alpha;
1542         gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(dialog), &colour);
1543         gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(dialog), TRUE);
1544
1545         if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL)
1546                 {
1547                 gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(dialog), &colour);
1548                 c_options->image_overlay.text_red = colour.red*255;
1549                 c_options->image_overlay.text_green = colour.green*255;
1550                 c_options->image_overlay.text_blue = colour.blue*255;
1551                 c_options->image_overlay.text_alpha = colour.alpha*255;
1552                 }
1553         gtk_widget_destroy(dialog);
1554 #else
1555         GdkColor colour;
1556         GtkColorSelection *colorsel;
1557
1558         dialog = gtk_color_selection_dialog_new("Image Overlay Text Colour");
1559         gtk_window_set_keep_above(GTK_WINDOW(dialog),TRUE);
1560         colour.red = options->image_overlay.text_red*257;
1561         colour.green = options->image_overlay.text_green*257;
1562         colour.blue = options->image_overlay.text_blue*257;
1563         colorsel = GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(dialog)));
1564         gtk_color_selection_set_has_opacity_control(colorsel, TRUE);
1565         gtk_color_selection_set_current_color(colorsel, &colour);
1566         gtk_color_selection_set_current_alpha(colorsel, options->image_overlay.text_alpha*257);
1567
1568         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
1569                 {
1570                 gtk_color_selection_get_current_color(colorsel, &colour);
1571                 c_options->image_overlay.text_red = colour.red/257;
1572                 c_options->image_overlay.text_green = colour.green/257;
1573                 c_options->image_overlay.text_blue = colour.blue/257;
1574                 c_options->image_overlay.text_alpha = gtk_color_selection_get_current_alpha(colorsel)/257;
1575                 }
1576         gtk_widget_destroy (dialog);
1577 #endif
1578 }
1579
1580
1581 static void image_overlay_set_background_colour_cb(GtkWidget *widget, gpointer data)
1582 {
1583         GtkWidget *dialog;
1584 #if GTK_CHECK_VERSION(3,4,0)
1585         GdkRGBA colour;
1586
1587         dialog = gtk_color_chooser_dialog_new("Image Overlay Background Colour", GTK_WINDOW(gtk_widget_get_toplevel(widget)));
1588         colour.red = options->image_overlay.background_red;
1589         colour.green = options->image_overlay.background_green;
1590         colour.blue = options->image_overlay.background_blue;
1591         colour.alpha = options->image_overlay.background_alpha;
1592         gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(dialog), &colour);
1593         gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(dialog), TRUE);
1594
1595         if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_CANCEL)
1596                 {
1597                 gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(dialog), &colour);
1598                 c_options->image_overlay.background_red = colour.red*255;
1599                 c_options->image_overlay.background_green = colour.green*255;
1600                 c_options->image_overlay.background_blue = colour.blue*255;
1601                 c_options->image_overlay.background_alpha = colour.alpha*255;
1602                 }
1603         gtk_widget_destroy(dialog);
1604 #else
1605         GdkColor colour;
1606         GtkColorSelection *colorsel;
1607
1608         dialog = gtk_color_selection_dialog_new("Image Overlay Background Colour");
1609         gtk_window_set_keep_above(GTK_WINDOW(dialog),TRUE);
1610         colour.red = options->image_overlay.background_red*257;
1611         colour.green = options->image_overlay.background_green*257;
1612         colour.blue = options->image_overlay.background_blue*257;
1613         colorsel = GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(dialog)));
1614         gtk_color_selection_set_has_opacity_control(colorsel, TRUE);
1615         gtk_color_selection_set_current_color(colorsel, &colour);
1616         gtk_color_selection_set_current_alpha(colorsel, options->image_overlay.background_alpha*257);
1617
1618         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
1619                 {
1620                 gtk_color_selection_get_current_color(colorsel, &colour);
1621                 c_options->image_overlay.background_red = colour.red/257;
1622                 c_options->image_overlay.background_green = colour.green/257;
1623                 c_options->image_overlay.background_blue = colour.blue/257;
1624                 c_options->image_overlay.background_alpha = gtk_color_selection_get_current_alpha(colorsel)/257;
1625                 }
1626         gtk_widget_destroy(dialog);
1627 #endif
1628 }
1629
1630 static void accel_store_populate(void)
1631 {
1632         LayoutWindow *lw;
1633         GList *groups, *actions;
1634         GtkAction *action;
1635         const gchar *accel_path;
1636         GtkAccelKey key;
1637         GtkTreeIter iter;
1638
1639         if (!accel_store || !layout_window_list || !layout_window_list->data) return;
1640
1641         gtk_tree_store_clear(accel_store);
1642         lw = layout_window_list->data; /* get the actions from the first window, it should not matter, they should be the same in all windows */
1643
1644         g_assert(lw && lw->ui_manager);
1645         groups = gtk_ui_manager_get_action_groups(lw->ui_manager);
1646         while (groups)
1647                 {
1648                 actions = gtk_action_group_list_actions(GTK_ACTION_GROUP(groups->data));
1649                 while (actions)
1650                         {
1651                         action = GTK_ACTION(actions->data);
1652                         accel_path = gtk_action_get_accel_path(action);
1653                         if (accel_path && gtk_accel_map_lookup_entry(accel_path, &key))
1654                                 {
1655                                 gchar *label, *label2, *tooltip, *accel;
1656                                 g_object_get(action,
1657                                              "tooltip", &tooltip,
1658                                              "label", &label,
1659                                              NULL);
1660
1661                                 if (pango_parse_markup(label, -1, '_', NULL, &label2, NULL, NULL) && label2)
1662                                         {
1663                                         g_free(label);
1664                                         label = label2;
1665                                         }
1666
1667                                 accel = gtk_accelerator_name(key.accel_key, key.accel_mods);
1668
1669                                 if (tooltip)
1670                                         {
1671                                         gtk_tree_store_append(accel_store, &iter, NULL);
1672                                         gtk_tree_store_set(accel_store, &iter,
1673                                                            AE_ACTION, label,
1674                                                            AE_KEY, accel,
1675                                                            AE_TOOLTIP, tooltip ? tooltip : "",
1676                                                            AE_ACCEL, accel_path,
1677                                                            -1);
1678                                         }
1679
1680                                 g_free(accel);
1681                                 g_free(label);
1682                                 g_free(tooltip);
1683                                 }
1684                         actions = actions->next;
1685                         }
1686
1687                 groups = groups->next;
1688                 }
1689 }
1690
1691 static void accel_store_cleared_cb(GtkCellRendererAccel *accel, gchar *path_string, gpointer user_data)
1692 {
1693
1694 }
1695
1696 static gboolean accel_remove_key_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
1697 {
1698         gchar *accel1 = data;
1699         gchar *accel2;
1700         GtkAccelKey key1;
1701         GtkAccelKey key2;
1702
1703         gtk_tree_model_get(model, iter, AE_KEY, &accel2, -1);
1704
1705         gtk_accelerator_parse(accel1, &key1.accel_key, &key1.accel_mods);
1706         gtk_accelerator_parse(accel2, &key2.accel_key, &key2.accel_mods);
1707
1708         if (key1.accel_key == key2.accel_key && key1.accel_mods == key2.accel_mods)
1709                 {
1710                 gtk_tree_store_set(accel_store, iter, AE_KEY, "",  -1);
1711                 DEBUG_1("accelerator key '%s' is already used, removing.", accel1);
1712                 }
1713
1714         g_free(accel2);
1715
1716         return FALSE;
1717 }
1718
1719
1720 static void accel_store_edited_cb(GtkCellRendererAccel *accel, gchar *path_string, guint accel_key, GdkModifierType accel_mods, guint hardware_keycode, gpointer user_data)
1721 {
1722         GtkTreeModel *model = (GtkTreeModel *)accel_store;
1723         GtkTreeIter iter;
1724         gchar *acc;
1725         gchar *accel_path;
1726         GtkAccelKey old_key, key;
1727         GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
1728
1729         gtk_tree_model_get_iter(model, &iter, path);
1730         gtk_tree_model_get(model, &iter, AE_ACCEL, &accel_path, -1);
1731
1732         /* test if the accelerator can be stored without conflicts*/
1733         gtk_accel_map_lookup_entry(accel_path, &old_key);
1734
1735         /* change the key and read it back (change may fail on keys hardcoded in gtk)*/
1736         gtk_accel_map_change_entry(accel_path, accel_key, accel_mods, TRUE);
1737         gtk_accel_map_lookup_entry(accel_path, &key);
1738
1739         /* restore the original for now, the key will be really changed when the changes are confirmed */
1740         gtk_accel_map_change_entry(accel_path, old_key.accel_key, old_key.accel_mods, TRUE);
1741
1742         acc = gtk_accelerator_name(key.accel_key, key.accel_mods);
1743         gtk_tree_model_foreach(GTK_TREE_MODEL(accel_store), accel_remove_key_cb, acc);
1744
1745         gtk_tree_store_set(accel_store, &iter, AE_KEY, acc, -1);
1746         gtk_tree_path_free(path);
1747         g_free(acc);
1748 }
1749
1750 static gboolean accel_default_scroll(GtkTreeView *data)
1751 {
1752         GtkTreeIter iter;
1753         GtkTreePath *path;
1754         GtkTreeViewColumn *column;
1755
1756         gtk_tree_model_get_iter_first(GTK_TREE_MODEL(accel_store), &iter);
1757         path = gtk_tree_model_get_path(GTK_TREE_MODEL(accel_store), &iter);
1758         column = gtk_tree_view_get_column(GTK_TREE_VIEW(data),0);
1759
1760         gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(data),
1761                                      path, column,
1762                                      FALSE, 0.0, 0.0);
1763
1764         gtk_tree_path_free(path);
1765
1766         return(FALSE);
1767 }
1768
1769 static void accel_default_cb(GtkWidget *widget, gpointer data)
1770 {
1771         accel_store_populate();
1772
1773         g_idle_add((GSourceFunc)accel_default_scroll, data);
1774 }
1775
1776 void accel_remove_selection(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
1777 {
1778         gtk_tree_store_set(accel_store, iter, AE_KEY, "", -1);
1779 }
1780
1781 void accel_reset_selection(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
1782 {
1783         GtkAccelKey key;
1784         gchar *accel_path, *accel;
1785
1786         gtk_tree_model_get(model, iter, AE_ACCEL, &accel_path, -1);
1787         gtk_accel_map_lookup_entry(accel_path, &key);
1788         accel = gtk_accelerator_name(key.accel_key, key.accel_mods);
1789
1790         gtk_tree_model_foreach(GTK_TREE_MODEL(accel_store), accel_remove_key_cb, accel);
1791
1792         gtk_tree_store_set(accel_store, iter, AE_KEY, accel, -1);
1793         g_free(accel_path);
1794         g_free(accel);
1795 }
1796
1797 static void accel_reset_cb(GtkWidget *widget, gpointer data)
1798 {
1799         GtkTreeSelection *selection;
1800
1801         if (!accel_store) return;
1802         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data));
1803         gtk_tree_selection_selected_foreach(selection, &accel_reset_selection, NULL);
1804 }
1805
1806
1807
1808 static GtkWidget *scrolled_notebook_page(GtkWidget *notebook, const gchar *title)
1809 {
1810         GtkWidget *label;
1811         GtkWidget *vbox;
1812         GtkWidget *scrolled;
1813         GtkWidget *viewport;
1814
1815         scrolled = gtk_scrolled_window_new(NULL, NULL);
1816         gtk_container_set_border_width(GTK_CONTAINER(scrolled), PREF_PAD_BORDER);
1817         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1818                                        GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1819         label = gtk_label_new(title);
1820         gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled, label);
1821         gtk_widget_show(scrolled);
1822
1823         viewport = gtk_viewport_new(NULL, NULL);
1824         gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
1825         gtk_container_add(GTK_CONTAINER(scrolled), viewport);
1826         gtk_widget_show(viewport);
1827
1828         vbox = gtk_vbox_new(FALSE, 0);
1829         gtk_container_add(GTK_CONTAINER(viewport), vbox);
1830         gtk_widget_show(vbox);
1831
1832         return vbox;
1833 }
1834
1835 static void cache_standard_cb(GtkWidget *widget, gpointer data)
1836 {
1837         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
1838                 {
1839                 c_options->thumbnails.spec_standard =TRUE;
1840                 c_options->thumbnails.cache_into_dirs = FALSE;
1841                 }
1842 }
1843
1844 static void cache_geeqie_cb(GtkWidget *widget, gpointer data)
1845 {
1846         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
1847                 {
1848                 c_options->thumbnails.spec_standard =FALSE;
1849                 c_options->thumbnails.cache_into_dirs = FALSE;
1850                 }
1851 }
1852
1853 static void cache_local_cb(GtkWidget *widget, gpointer data)
1854 {
1855         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
1856                 {
1857                 c_options->thumbnails.cache_into_dirs = TRUE;
1858                 c_options->thumbnails.spec_standard =FALSE;
1859                 }
1860 }
1861
1862 static void help_search_engine_entry_icon_cb(GtkEntry *entry, GtkEntryIconPosition pos,
1863                                                                         GdkEvent *event, gpointer userdata)
1864 {
1865         if (pos == GTK_ENTRY_ICON_PRIMARY)
1866                 {
1867                 gtk_entry_set_text(GTK_ENTRY(userdata), HELP_SEARCH_ENGINE);
1868                 }
1869         else
1870                 {
1871                 gtk_entry_set_text(GTK_ENTRY(userdata), "");
1872                 }
1873 }
1874
1875 static void star_rating_star_icon_cb(GtkEntry *entry, GtkEntryIconPosition pos,
1876                                                                         GdkEvent *event, gpointer userdata)
1877 {
1878         gchar *rating_symbol;
1879
1880         if (pos == GTK_ENTRY_ICON_PRIMARY)
1881                 {
1882                 rating_symbol = g_strdup_printf("U+%X", STAR_RATING_STAR);
1883                 gtk_entry_set_text(GTK_ENTRY(userdata), rating_symbol);
1884                 g_free(rating_symbol);
1885                 }
1886         else
1887                 {
1888                 gtk_entry_set_text(GTK_ENTRY(userdata), "U+");
1889                 gtk_widget_grab_focus(GTK_WIDGET(userdata));
1890                 gtk_editable_select_region(GTK_EDITABLE(userdata), 2, 2);
1891                 }
1892 }
1893
1894 static void star_rating_rejected_icon_cb(GtkEntry *entry, GtkEntryIconPosition pos,
1895                                                                         GdkEvent *event, gpointer userdata)
1896 {
1897         gchar *rating_symbol;
1898
1899         if (pos == GTK_ENTRY_ICON_PRIMARY)
1900                 {
1901                 rating_symbol = g_strdup_printf("U+%X", STAR_RATING_REJECTED);
1902                 gtk_entry_set_text(GTK_ENTRY(userdata), rating_symbol);
1903                 g_free(rating_symbol);
1904                 }
1905         else
1906                 {
1907                 gtk_entry_set_text(GTK_ENTRY(userdata), "U+");
1908                 gtk_widget_grab_focus(GTK_WIDGET(userdata));
1909                 gtk_editable_select_region(GTK_EDITABLE(userdata), 2, 2);
1910                 }
1911 }
1912
1913 static guint star_rating_symbol_test(GtkWidget *widget, gpointer data)
1914 {
1915         GtkContainer *hbox = data;
1916         GString *str = g_string_new(NULL);
1917         GtkEntry *hex_code_entry;
1918         gchar *hex_code_full;
1919         gchar **hex_code;
1920         GList *list;
1921         guint64 hex_value = 0;
1922
1923         list = gtk_container_get_children(hbox);
1924
1925         hex_code_entry = g_list_nth_data(list, 2);
1926         hex_code_full = g_strdup(gtk_entry_get_text(hex_code_entry));
1927
1928         hex_code = g_strsplit(hex_code_full, "+", 2);
1929         if (hex_code[0] && hex_code[1])
1930                 {
1931                 hex_value = strtoull(hex_code[1], NULL, 16);
1932                 }
1933         if (!hex_value || hex_value > 0x10FFFF)
1934                 {
1935                 hex_value = 0x003F; // Unicode 'Question Mark'
1936                 }
1937         str = g_string_append_unichar(str, (gunichar)hex_value);
1938         gtk_label_set_text(g_list_nth_data(list, 1), str->str);
1939
1940         g_strfreev(hex_code);
1941         g_string_free(str, TRUE);
1942         g_free(hex_code_full);
1943
1944         return hex_value;
1945 }
1946
1947 static void star_rating_star_test_cb(GtkWidget *widget, gpointer data)
1948 {
1949         guint64 star_symbol;
1950
1951         star_symbol = star_rating_symbol_test(widget, data);
1952         c_options->star_rating.star = star_symbol;
1953 }
1954
1955 static void star_rating_rejected_test_cb(GtkWidget *widget, gpointer data)
1956 {
1957         guint64 rejected_symbol;
1958
1959         rejected_symbol = star_rating_symbol_test(widget, data);
1960         c_options->star_rating.rejected = rejected_symbol;
1961 }
1962
1963 /* general options tab */
1964 static void timezone_database_install_cb(GtkWidget *widget, gpointer data);
1965 typedef struct _TZData TZData;
1966 struct _TZData
1967 {
1968         GenericDialog *gd;
1969         GCancellable *cancellable;
1970
1971         GtkWidget *progress;
1972         GFile *tmp_g_file;
1973         GFile *timezone_database_gq;
1974         gchar *timezone_database_user;
1975 };
1976
1977 static void config_tab_general(GtkWidget *notebook)
1978 {
1979         GtkWidget *vbox;
1980         GtkWidget *hbox;
1981         GtkWidget *group;
1982         GtkWidget *group_frame;
1983         GtkWidget *subgroup;
1984         GtkWidget *button;
1985         GtkWidget *ct_button;
1986         GtkWidget *table;
1987         GtkWidget *spin;
1988         gint hours, minutes, remainder;
1989         gdouble seconds;
1990         GtkWidget *star_rating_entry;
1991         GString *str;
1992         gchar *rating_symbol;
1993         gchar *path;
1994         gchar *basename;
1995         gchar *download_locn;
1996         GNetworkMonitor *net_mon;
1997         GSocketConnectable *geeqie_org;
1998         gboolean internet_available;
1999         TZData *tz;
2000
2001         vbox = scrolled_notebook_page(notebook, _("General"));
2002
2003         group = pref_group_new(vbox, FALSE, _("Thumbnails"), GTK_ORIENTATION_VERTICAL);
2004
2005         table = pref_table_new(group, 2, 2, FALSE, FALSE);
2006         add_thumb_size_menu(table, 0, 0, _("Size:"));
2007         add_quality_menu(table, 0, 1, _("Quality:"), options->thumbnails.quality, &c_options->thumbnails.quality);
2008
2009         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2010         pref_label_new(hbox, _("Custom size: "));
2011         pref_spin_new_int(hbox, _("Width:"), NULL, 1, 512, 1, options->thumbnails.max_width, &c_options->thumbnails.max_width);
2012         pref_spin_new_int(hbox, _("Height:"), NULL, 1, 512, 1, options->thumbnails.max_height, &c_options->thumbnails.max_height);
2013
2014         ct_button = pref_checkbox_new_int(group, _("Cache thumbnails and sim. files"),
2015                                           options->thumbnails.enable_caching, &c_options->thumbnails.enable_caching);
2016
2017         subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2018         pref_checkbox_link_sensitivity(ct_button, subgroup);
2019
2020         c_options->thumbnails.spec_standard = options->thumbnails.spec_standard;
2021         c_options->thumbnails.cache_into_dirs = options->thumbnails.cache_into_dirs;
2022         group_frame = pref_frame_new(subgroup, TRUE, _("Use Geeqie thumbnail style and cache"),
2023                                                                                 GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2024         button = pref_radiobutton_new(group_frame, NULL,  get_thumbnails_cache_dir(),
2025                                                         !options->thumbnails.spec_standard && !options->thumbnails.cache_into_dirs,
2026                                                         G_CALLBACK(cache_geeqie_cb), NULL);
2027
2028         group_frame = pref_frame_new(subgroup, TRUE,
2029                                                         _("Store thumbnails local to image folder (non-standard)"),
2030                                                         GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2031         pref_radiobutton_new(group_frame, button, "*/.thumbnails",
2032                                                         !options->thumbnails.spec_standard && options->thumbnails.cache_into_dirs,
2033                                                         G_CALLBACK(cache_local_cb), NULL);
2034
2035         group_frame = pref_frame_new(subgroup, TRUE,
2036                                                         _("Use standard thumbnail style and cache, shared with other applications"),
2037                                                         GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2038         pref_radiobutton_new(group_frame, button, get_thumbnails_standard_cache_dir(),
2039                                                         options->thumbnails.spec_standard && !options->thumbnails.cache_into_dirs,
2040                                                         G_CALLBACK(cache_standard_cb), NULL);
2041
2042         pref_checkbox_new_int(group, _("Use EXIF thumbnails when available (EXIF thumbnails may be outdated)"),
2043                               options->thumbnails.use_exif, &c_options->thumbnails.use_exif);
2044
2045         pref_checkbox_new_int(group, _("Thumbnail color management"),
2046                                 options->thumbnails.use_color_management, &c_options->thumbnails.use_color_management);
2047
2048         spin = pref_spin_new_int(group, _("Collection preview:"), NULL,
2049                                  1, 999, 1,
2050                                  options->thumbnails.collection_preview, &c_options->thumbnails.collection_preview);
2051         gtk_widget_set_tooltip_text(spin, _("The maximum number of thumbnails shown in a Collection preview montage"));
2052
2053 #ifdef HAVE_FFMPEGTHUMBNAILER_METADATA
2054         pref_checkbox_new_int(group, _("Use embedded metadata in video files as thumbnails when available"),
2055                               options->thumbnails.use_ft_metadata, &c_options->thumbnails.use_ft_metadata);
2056
2057 //      pref_checkbox_new_int(group, _("Ignore embedded metadata if size is too small"),
2058 //                            options->thumbnails.use_ft_metadata_small, &c_options->thumbnails.use_ft_metadata_small);
2059 #endif
2060
2061         pref_spacer(group, PREF_PAD_GROUP);
2062
2063         group = pref_group_new(vbox, FALSE, _("Star Rating"), GTK_ORIENTATION_VERTICAL);
2064
2065         c_options->star_rating.star = options->star_rating.star;
2066         c_options->star_rating.rejected = options->star_rating.rejected;
2067
2068         str = g_string_new(NULL);
2069         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2070         pref_label_new(hbox, _("Star character: "));
2071         str = g_string_append_unichar(str, options->star_rating.star);
2072         pref_label_new(hbox, g_strdup(str->str));
2073         rating_symbol = g_strdup_printf("U+%X", options->star_rating.star);
2074         star_rating_entry = gtk_entry_new();
2075         gtk_entry_set_text(GTK_ENTRY(star_rating_entry), rating_symbol);
2076         gtk_box_pack_start(GTK_BOX(hbox), star_rating_entry, FALSE, FALSE, 0);
2077         gtk_entry_set_width_chars(GTK_ENTRY(star_rating_entry), 15);
2078         gtk_widget_show(star_rating_entry);
2079         button = pref_button_new(NULL, NULL, _("Set"), FALSE,
2080                                         G_CALLBACK(star_rating_star_test_cb), hbox);
2081         gtk_widget_set_tooltip_text(button, _("Display selected character"));
2082         gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2083         gtk_widget_show(button);
2084         gtk_widget_set_tooltip_text(star_rating_entry, _("Hexadecimal representation of a Unicode character. A list of all Unicode characters may be found on the Internet."));
2085         gtk_entry_set_icon_from_stock(GTK_ENTRY(star_rating_entry),
2086                                                 GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
2087         gtk_entry_set_icon_tooltip_text (GTK_ENTRY(star_rating_entry),
2088                                                 GTK_ENTRY_ICON_SECONDARY, _("Clear"));
2089         gtk_entry_set_icon_from_stock(GTK_ENTRY(star_rating_entry),
2090                                                 GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_REVERT_TO_SAVED);
2091         gtk_entry_set_icon_tooltip_text (GTK_ENTRY(star_rating_entry),
2092                                                 GTK_ENTRY_ICON_PRIMARY, _("Default"));
2093         g_signal_connect(GTK_ENTRY(star_rating_entry), "icon-press",
2094                                                 G_CALLBACK(star_rating_star_icon_cb),
2095                                                 star_rating_entry);
2096
2097         g_string_free(str, TRUE);
2098         g_free(rating_symbol);
2099
2100         str = g_string_new(NULL);
2101         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2102         pref_label_new(hbox, _("Rejected character: "));
2103         str = g_string_append_unichar(str, options->star_rating.rejected);
2104         pref_label_new(hbox, g_strdup(str->str));
2105         rating_symbol = g_strdup_printf("U+%X", options->star_rating.rejected);
2106         star_rating_entry = gtk_entry_new();
2107         gtk_entry_set_text(GTK_ENTRY(star_rating_entry), rating_symbol);
2108         gtk_box_pack_start(GTK_BOX(hbox), star_rating_entry, FALSE, FALSE, 0);
2109         gtk_entry_set_width_chars(GTK_ENTRY(star_rating_entry), 15);
2110         gtk_widget_show(star_rating_entry);
2111         button = pref_button_new(NULL, NULL, _("Set"), FALSE,
2112                                         G_CALLBACK(star_rating_rejected_test_cb), hbox);
2113         gtk_widget_set_tooltip_text(button, _("Display selected character"));
2114         gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2115         gtk_widget_show(button);
2116         gtk_widget_set_tooltip_text(star_rating_entry, _("Hexadecimal representation of a Unicode character. A list of all Unicode characters may be found on the Internet."));
2117         gtk_entry_set_icon_from_stock(GTK_ENTRY(star_rating_entry),
2118                                                 GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
2119         gtk_entry_set_icon_tooltip_text (GTK_ENTRY(star_rating_entry),
2120                                                 GTK_ENTRY_ICON_SECONDARY, _("Clear"));
2121         gtk_entry_set_icon_from_stock(GTK_ENTRY(star_rating_entry),
2122                                                 GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_REVERT_TO_SAVED);
2123         gtk_entry_set_icon_tooltip_text (GTK_ENTRY(star_rating_entry),
2124                                                 GTK_ENTRY_ICON_PRIMARY, _("Default"));
2125         g_signal_connect(GTK_ENTRY(star_rating_entry), "icon-press",
2126                                                 G_CALLBACK(star_rating_rejected_icon_cb),
2127                                                 star_rating_entry);
2128
2129         g_string_free(str, TRUE);
2130         g_free(rating_symbol);
2131
2132         pref_spacer(group, PREF_PAD_GROUP);
2133
2134         group = pref_group_new(vbox, FALSE, _("Slide show"), GTK_ORIENTATION_VERTICAL);
2135
2136         c_options->slideshow.delay = options->slideshow.delay;
2137         hours = options->slideshow.delay / (3600 * SLIDESHOW_SUBSECOND_PRECISION);
2138         remainder = options->slideshow.delay % (3600 * SLIDESHOW_SUBSECOND_PRECISION);
2139         minutes = remainder / (60 * SLIDESHOW_SUBSECOND_PRECISION);
2140         seconds = (gdouble)(remainder % (60 * SLIDESHOW_SUBSECOND_PRECISION)) /
2141                                                                                         SLIDESHOW_SUBSECOND_PRECISION;
2142
2143         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2144
2145         spin = pref_spin_new(hbox, _("Delay between image change hrs:mins:secs.dec"), NULL,
2146                                                                                 0, 23, 1.0, 0,
2147                                                                                 options->slideshow.delay ? hours : 0.0,
2148                                                                                 G_CALLBACK(slideshow_delay_hours_cb), NULL);
2149         gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
2150         spin = pref_spin_new(hbox, ":" , NULL,
2151                                                                                 0, 59, 1.0, 0,
2152                                                                                 options->slideshow.delay ? minutes: 0.0,
2153                                                                                 G_CALLBACK(slideshow_delay_minutes_cb), NULL);
2154         gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
2155         spin = pref_spin_new(hbox, ":", NULL,
2156                                                                                 SLIDESHOW_MIN_SECONDS, 59, 1.0, 1,
2157                                                                                 options->slideshow.delay ? seconds : 10.0,
2158                                                                                 G_CALLBACK(slideshow_delay_seconds_cb), NULL);
2159         gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
2160
2161         pref_checkbox_new_int(group, _("Random"), options->slideshow.random, &c_options->slideshow.random);
2162         pref_checkbox_new_int(group, _("Repeat"), options->slideshow.repeat, &c_options->slideshow.repeat);
2163
2164         pref_spacer(group, PREF_PAD_GROUP);
2165
2166         group = pref_group_new(vbox, FALSE, _("Image loading and caching"), GTK_ORIENTATION_VERTICAL);
2167
2168         pref_spin_new_int(group, _("Decoded image cache size (MiB):"), NULL,
2169                           0, 99999, 1, options->image.image_cache_max, &c_options->image.image_cache_max);
2170         pref_checkbox_new_int(group, _("Preload next image"),
2171                               options->image.enable_read_ahead, &c_options->image.enable_read_ahead);
2172
2173         pref_checkbox_new_int(group, _("Refresh on file change"),
2174                               options->update_on_time_change, &c_options->update_on_time_change);
2175
2176
2177         pref_spacer(group, PREF_PAD_GROUP);
2178
2179         group = pref_group_new(vbox, FALSE, _("Expand menu and toolbar"), GTK_ORIENTATION_VERTICAL);
2180
2181         pref_checkbox_new_int(group, _("Expand menu and toolbar (NOTE! Geeqie must be restarted for change to take effect)"),
2182                                 options->expand_menu_toolbar, &c_options->expand_menu_toolbar);
2183         gtk_widget_set_tooltip_text(group, _("Expand the menu and toolbar to the full width of the window"));
2184
2185         pref_spacer(group, PREF_PAD_GROUP);
2186
2187         net_mon = g_network_monitor_get_default();
2188         geeqie_org = g_network_address_parse_uri(GQ_WEBSITE, 80, NULL);
2189         internet_available = g_network_monitor_can_reach(net_mon, geeqie_org, NULL, NULL);
2190         g_object_unref(geeqie_org);
2191
2192         group = pref_group_new(vbox, FALSE, _("Timezone database"), GTK_ORIENTATION_VERTICAL);
2193         hbox = pref_box_new(group, TRUE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2194
2195         if (!internet_available)
2196                 {
2197                 gtk_widget_set_sensitive(group, FALSE);
2198                 }
2199
2200         tz = g_new0(TZData, 1);
2201
2202         path = path_from_utf8(TIMEZONE_DATABASE_WEB);
2203         basename = g_path_get_basename(path);
2204         tz->timezone_database_user = g_build_filename(get_rc_dir(), TIMEZONE_DATABASE_FILE, NULL);
2205         g_free(path);
2206         g_free(basename);
2207
2208         if (isfile(tz->timezone_database_user))
2209                 {
2210                 button = pref_button_new(GTK_WIDGET(hbox), NULL, _("Update"), FALSE, G_CALLBACK(timezone_database_install_cb), tz);
2211                 }
2212         else
2213                 {
2214                 button = pref_button_new(GTK_WIDGET(hbox), NULL, _("Install"), FALSE, G_CALLBACK(timezone_database_install_cb), tz);
2215                 }
2216
2217         download_locn = g_strconcat(_("Download database from: "), TIMEZONE_DATABASE_WEB, NULL);
2218         pref_label_new(GTK_WIDGET(hbox), download_locn);
2219         g_free(download_locn);
2220
2221         if (!internet_available)
2222                 {
2223                 gtk_widget_set_tooltip_text(button, _("No Internet connection!\nThe timezone database is used to display exif time and date\ncorrected for UTC offset and Daylight Saving Time"));
2224                 }
2225         else
2226                 {
2227                 gtk_widget_set_tooltip_text(button, _("The timezone database is used to display exif time and date\ncorrected for UTC offset and Daylight Saving Time"));
2228                 }
2229         gtk_widget_show(button);
2230
2231         pref_spacer(group, PREF_PAD_GROUP);
2232
2233         group = pref_group_new(vbox, FALSE, _("On-line help search engine"), GTK_ORIENTATION_VERTICAL);
2234
2235         help_search_engine_entry = gtk_entry_new();
2236         gtk_entry_set_text(GTK_ENTRY(help_search_engine_entry), options->help_search_engine);
2237         gtk_box_pack_start(GTK_BOX(group), help_search_engine_entry, FALSE, FALSE, 0);
2238         gtk_widget_show(help_search_engine_entry);
2239
2240         gtk_widget_set_tooltip_text(help_search_engine_entry, _("The format varies between search engines, e.g the format may be:\nhttps://www.search_engine.com/search?q=site:geeqie.org/help\nhttps://www.search_engine.com/?q=site:geeqie.org/help"));
2241
2242         gtk_entry_set_icon_from_stock(GTK_ENTRY(help_search_engine_entry),
2243                                                 GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
2244         gtk_entry_set_icon_tooltip_text (GTK_ENTRY(help_search_engine_entry),
2245                                                 GTK_ENTRY_ICON_SECONDARY, _("Clear"));
2246         gtk_entry_set_icon_from_stock(GTK_ENTRY(help_search_engine_entry),
2247                                                 GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_REVERT_TO_SAVED);
2248         gtk_entry_set_icon_tooltip_text (GTK_ENTRY(help_search_engine_entry),
2249                                                 GTK_ENTRY_ICON_PRIMARY, _("Default"));
2250         g_signal_connect(GTK_ENTRY(help_search_engine_entry), "icon-press",
2251                                                 G_CALLBACK(help_search_engine_entry_icon_cb),
2252                                                 help_search_engine_entry);
2253 }
2254
2255 /* image tab */
2256 static void config_tab_image(GtkWidget *notebook)
2257 {
2258         GtkWidget *hbox;
2259         GtkWidget *vbox;
2260         GtkWidget *group;
2261         GtkWidget *ct_button;
2262         GtkWidget *enlargement_button;
2263         GtkWidget *table;
2264         GtkWidget *spin;
2265         GtkWidget *two_pass;
2266 #ifdef HAVE_CLUTTER
2267         GtkWidget *gpu_accel;
2268 #endif
2269
2270         vbox = scrolled_notebook_page(notebook, _("Image"));
2271
2272         group = pref_group_new(vbox, FALSE, _("Zoom"), GTK_ORIENTATION_VERTICAL);
2273
2274         table = pref_table_new(group, 2, 1, FALSE, FALSE);
2275         add_quality_menu(table, 0, 0, _("Quality:"), options->image.zoom_quality, &c_options->image.zoom_quality);
2276         if (options->image.use_clutter_renderer && !options->disable_gpu)
2277                 {
2278                 gtk_widget_set_sensitive(table, FALSE);
2279                 }
2280
2281 #ifdef HAVE_CLUTTER
2282         gpu_accel = pref_checkbox_new_int(group, _("Use GPU acceleration via Clutter library (Requires restart)"),
2283                               options->image.use_clutter_renderer, &c_options->image.use_clutter_renderer);
2284         if (options->disable_gpu && !options->override_disable_gpu)
2285                 {
2286                 gtk_widget_set_sensitive(gpu_accel, FALSE);
2287                 }
2288 #endif
2289
2290         two_pass = pref_checkbox_new_int(group, _("Two pass rendering (apply HQ zoom and color correction in second pass)"),
2291                               options->image.zoom_2pass, &c_options->image.zoom_2pass);
2292         if (options->image.use_clutter_renderer && !options->disable_gpu)
2293                 {
2294                 gtk_widget_set_sensitive(two_pass, FALSE);
2295                 }
2296
2297         c_options->image.zoom_increment = options->image.zoom_increment;
2298         spin = pref_spin_new(group, _("Zoom increment:"), NULL,
2299                              0.01, 4.0, 0.01, 2, (gdouble)options->image.zoom_increment / 100.0,
2300                              G_CALLBACK(zoom_increment_cb), NULL);
2301         gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
2302
2303         c_options->image.zoom_style = options->image.zoom_style;
2304         table = pref_table_new(group, 2, 1, FALSE, FALSE);
2305         add_zoom_style_selection_menu(table, 0, 0, _("Zoom style:"), options->image.zoom_style, &c_options->image.zoom_style);
2306
2307         group = pref_group_new(vbox, FALSE, _("Fit image to window"), GTK_ORIENTATION_VERTICAL);
2308
2309         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2310         enlargement_button = pref_checkbox_new_int(hbox, _("Allow enlargement of image (max. size in %)"),
2311                               options->image.zoom_to_fit_allow_expand, &c_options->image.zoom_to_fit_allow_expand);
2312         spin = pref_spin_new_int(hbox, NULL, NULL,
2313                                  100, 999, 1,
2314                                  options->image.max_enlargement_size, &c_options->image.max_enlargement_size);
2315         pref_checkbox_link_sensitivity(enlargement_button, spin);
2316         gtk_widget_set_tooltip_text(GTK_WIDGET(hbox), _("Enable this to allow Geeqie to increase the image size for images that are smaller than the current view area when the zoom is set to \"Fit image to window\". This value sets the maximum expansion permitted in percent i.e. 100% is full-size."));
2317
2318         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2319         ct_button = pref_checkbox_new_int(hbox, _("Virtual window size (% of actual window):"),
2320                                           options->image.limit_autofit_size, &c_options->image.limit_autofit_size);
2321         spin = pref_spin_new_int(hbox, NULL, NULL,
2322                                  10, 150, 1,
2323                                  options->image.max_autofit_size, &c_options->image.max_autofit_size);
2324         pref_checkbox_link_sensitivity(ct_button, spin);
2325         gtk_widget_set_tooltip_text(GTK_WIDGET(hbox), _("This value will set the virtual size of the window when \"Fit image to window\" is set. Instead of using the actual size of the window, the specified percentage of the window will be used. It allows one to keep a border around the image (values lower than 100%) or to auto zoom the image (values greater than 100%). It affects fullscreen mode too."));
2326
2327         group = pref_group_new(vbox, FALSE, _("Tile size"), GTK_ORIENTATION_VERTICAL);
2328         gtk_widget_set_sensitive(group, !options->image.use_clutter_renderer);
2329
2330         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2331         spin = pref_spin_new_int(hbox, _("Pixels"), _("(Requires restart)"),
2332                                  128, 4096, 128,
2333                                  options->image.tile_size, &c_options->image.tile_size);
2334         gtk_widget_set_tooltip_text(GTK_WIDGET(hbox), _("This value changes the size of the tiles large images are split into. Increasing the size of the tiles will reduce the tiling effect seen on image changes, but will also slightly increase the delay before the first part of a large image is seen."));
2335
2336         group = pref_group_new(vbox, FALSE, _("Appearance"), GTK_ORIENTATION_VERTICAL);
2337
2338         pref_checkbox_new_int(group, _("Use custom border color in window mode"),
2339                               options->image.use_custom_border_color, &c_options->image.use_custom_border_color);
2340
2341         pref_checkbox_new_int(group, _("Use custom border color in fullscreen mode"),
2342                               options->image.use_custom_border_color_in_fullscreen, &c_options->image.use_custom_border_color_in_fullscreen);
2343
2344         pref_color_button_new(group, _("Border color"), &options->image.border_color,
2345                               G_CALLBACK(pref_color_button_set_cb), &c_options->image.border_color);
2346
2347         c_options->image.border_color = options->image.border_color;
2348
2349         pref_color_button_new(group, _("Alpha channel color 1"), &options->image.alpha_color_1,
2350                               G_CALLBACK(pref_color_button_set_cb), &c_options->image.alpha_color_1);
2351
2352         pref_color_button_new(group, _("Alpha channel color 2"), &options->image.alpha_color_2,
2353                               G_CALLBACK(pref_color_button_set_cb), &c_options->image.alpha_color_2);
2354
2355         c_options->image.alpha_color_1 = options->image.alpha_color_1;
2356         c_options->image.alpha_color_2 = options->image.alpha_color_2;
2357 }
2358
2359 /* windows tab */
2360
2361 static void save_default_window_layout_cb(GtkWidget *widget, gpointer data)
2362 {
2363         LayoutWindow *lw = NULL;
2364         gchar *default_path;
2365         gchar *tmp_id;
2366
2367         /* Get current lw */
2368         layout_valid(&lw);
2369
2370         tmp_id = lw->options.id;
2371         lw->options.id = g_strdup("lw_default");
2372
2373         default_path = g_build_filename(get_rc_dir(), DEFAULT_WINDOW_LAYOUT, NULL);
2374         save_default_layout_options_to_file(default_path, options, lw);
2375         g_free(lw->options.id);
2376         lw->options.id = tmp_id;
2377         g_free(default_path);
2378 }
2379
2380 #if GTK_CHECK_VERSION(3,22,0)
2381 static gboolean popover_cb(gpointer data)
2382 {
2383         GtkPopover *popover = data;
2384
2385         gtk_popover_popdown(popover);
2386
2387         return FALSE;
2388 }
2389
2390 static void default_layout_changed_cb(GtkWidget *button, GtkPopover *popover)
2391 {
2392         gtk_popover_popup(popover);
2393
2394         g_timeout_add(2000, popover_cb, popover);
2395 }
2396
2397 static GtkWidget *create_popover(GtkWidget *parent, GtkWidget *child, GtkPositionType pos)
2398 {
2399         GtkWidget *popover;
2400
2401         popover = gtk_popover_new(parent);
2402         gtk_popover_set_position(GTK_POPOVER (popover), pos);
2403         gtk_container_add (GTK_CONTAINER(popover), child);
2404         gtk_container_set_border_width(GTK_CONTAINER (popover), 6);
2405         gtk_widget_show (child);
2406
2407         return popover;
2408 }
2409 #endif
2410
2411 static void config_tab_windows(GtkWidget *notebook)
2412 {
2413         GtkWidget *hbox;
2414         GtkWidget *vbox;
2415         GtkWidget *group;
2416         GtkWidget *subgroup;
2417         GtkWidget *button;
2418         GtkWidget *ct_button;
2419         GtkWidget *spin;
2420
2421         vbox = scrolled_notebook_page(notebook, _("Windows"));
2422
2423         group = pref_group_new(vbox, FALSE, _("State"), GTK_ORIENTATION_VERTICAL);
2424
2425         ct_button = pref_checkbox_new_int(group, _("Remember session"),
2426                                           options->save_window_positions, &c_options->save_window_positions);
2427
2428         button = pref_checkbox_new_int(group, _("Use saved window positions also for new windows"),
2429                                        options->use_saved_window_positions_for_new_windows, &c_options->use_saved_window_positions_for_new_windows);
2430         pref_checkbox_link_sensitivity(ct_button, button);
2431
2432         button = pref_checkbox_new_int(group, _("Remember window workspace"),
2433                               options->save_window_workspace, &c_options->save_window_workspace);
2434         pref_checkbox_link_sensitivity(ct_button, button);
2435
2436         pref_checkbox_new_int(group, _("Remember tool state (float/hidden)"),
2437                               options->tools_restore_state, &c_options->tools_restore_state);
2438
2439         pref_checkbox_new_int(group, _("Remember dialog window positions"),
2440                               options->save_dialog_window_positions, &c_options->save_dialog_window_positions);
2441
2442         pref_checkbox_new_int(group, _("Show window IDs"),
2443                               options->show_window_ids, &c_options->show_window_ids);
2444
2445         subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2446         pref_label_new(subgroup, _("Use current layout for default: "));
2447         button = pref_button_new(subgroup, NULL, _("Set"), FALSE, G_CALLBACK(save_default_window_layout_cb), NULL);
2448
2449 #if GTK_CHECK_VERSION(3,22,0)
2450         GtkWidget *popover;
2451
2452         popover = create_popover(button, gtk_label_new(_("Current window layout\nhas been set as default")), GTK_POS_TOP);
2453         gtk_popover_set_modal(GTK_POPOVER (popover), FALSE);
2454         g_signal_connect(button, "clicked", G_CALLBACK(default_layout_changed_cb), popover);
2455 #endif
2456
2457         group = pref_group_new(vbox, FALSE, _("Size"), GTK_ORIENTATION_VERTICAL);
2458
2459         pref_checkbox_new_int(group, _("Fit window to image when tools are hidden/floating"),
2460                               options->image.fit_window_to_image, &c_options->image.fit_window_to_image);
2461
2462         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2463         ct_button = pref_checkbox_new_int(hbox, _("Limit size when auto-sizing window (%):"),
2464                                           options->image.limit_window_size, &c_options->image.limit_window_size);
2465         spin = pref_spin_new_int(hbox, NULL, NULL,
2466                                  10, 150, 1,
2467                                  options->image.max_window_size, &c_options->image.max_window_size);
2468         pref_checkbox_link_sensitivity(ct_button, spin);
2469
2470         group = pref_group_new(vbox, FALSE, _("Full screen"), GTK_ORIENTATION_VERTICAL);
2471
2472         c_options->fullscreen.screen = options->fullscreen.screen;
2473         c_options->fullscreen.above = options->fullscreen.above;
2474         hbox = fullscreen_prefs_selection_new(_("Location:"), &c_options->fullscreen.screen, &c_options->fullscreen.above);
2475         gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
2476         gtk_widget_show(hbox);
2477
2478         pref_checkbox_new_int(group, _("Smooth image flip"),
2479                               options->fullscreen.clean_flip, &c_options->fullscreen.clean_flip);
2480         pref_checkbox_new_int(group, _("Disable screen saver"),
2481                               options->fullscreen.disable_saver, &c_options->fullscreen.disable_saver);
2482 }
2483
2484 #define PRE_FORMATTED_COLUMNS 5
2485 static void config_tab_osd(GtkWidget *notebook)
2486 {
2487         GtkWidget *hbox;
2488         GtkWidget *vbox;
2489         GtkWidget *group;
2490         GtkWidget *button;
2491         GtkWidget *image_overlay_template_view;
2492         GtkWidget *scrolled;
2493         GtkWidget *scrolled_pre_formatted;
2494         GtkTextBuffer *buffer;
2495         GtkWidget *label;
2496         GtkWidget *subgroup;
2497
2498         vbox = scrolled_notebook_page(notebook, _("OSD"));
2499
2500         image_overlay_template_view = gtk_text_view_new();
2501
2502         group = pref_group_new(vbox, FALSE, _("Overlay Screen Display"), GTK_ORIENTATION_VERTICAL);
2503
2504         subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2505
2506         scrolled_pre_formatted = osd_new(PRE_FORMATTED_COLUMNS, image_overlay_template_view);
2507         gtk_widget_set_size_request(scrolled_pre_formatted, 200, 150);
2508         gtk_box_pack_start(GTK_BOX(subgroup), scrolled_pre_formatted, FALSE, FALSE, 0);
2509         gtk_widget_show(scrolled_pre_formatted);
2510         gtk_widget_show(subgroup);
2511
2512         pref_line(group, PREF_PAD_GAP);
2513
2514         pref_label_new(group, _("Image overlay template"));
2515
2516         scrolled = gtk_scrolled_window_new(NULL, NULL);
2517         gtk_widget_set_size_request(scrolled, 200, 150);
2518         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
2519         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
2520                                                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2521         gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 5);
2522         gtk_widget_show(scrolled);
2523
2524         gtk_widget_set_tooltip_markup(image_overlay_template_view,
2525                                         _("Extensive formatting options are shown in the Help file"));
2526
2527         gtk_container_add(GTK_CONTAINER(scrolled), image_overlay_template_view);
2528         gtk_widget_show(image_overlay_template_view);
2529
2530         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
2531
2532 #if GTK_CHECK_VERSION(3,4,0)
2533         button = pref_button_new(NULL, GTK_STOCK_SELECT_FONT, _("Font"), FALSE,
2534                                  G_CALLBACK(image_overlay_set_font_cb), notebook);
2535 #else
2536         button = gtk_font_button_new();
2537         gtk_font_button_set_title(GTK_FONT_BUTTON(button), "Image Overlay Font");
2538         gtk_font_button_set_font_name(GTK_FONT_BUTTON(button), options->image_overlay.font);
2539         g_signal_connect(G_OBJECT(button), "font-set",
2540                                  G_CALLBACK(image_overlay_set_font_cb),NULL);
2541 #endif
2542         gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2543         gtk_widget_show(button);
2544
2545         button = pref_button_new(NULL, GTK_STOCK_COLOR_PICKER, _("Text"), FALSE,
2546                                  G_CALLBACK(image_overlay_set_text_colour_cb), NULL);
2547         gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2548         gtk_widget_show(button);
2549
2550         button = pref_button_new(NULL, GTK_STOCK_COLOR_PICKER, _("Background"), FALSE,
2551                                  G_CALLBACK(image_overlay_set_background_colour_cb), NULL);
2552         gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2553         gtk_widget_show(button);
2554         image_overlay_set_text_colours();
2555
2556         button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
2557                                  G_CALLBACK(image_overlay_default_template_cb), image_overlay_template_view);
2558         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2559         gtk_widget_show(button);
2560
2561         button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
2562                                  G_CALLBACK(image_overlay_help_cb), NULL);
2563         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2564         gtk_widget_show(button);
2565
2566         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(image_overlay_template_view));
2567         if (options->image_overlay.template_string) gtk_text_buffer_set_text(buffer, options->image_overlay.template_string, -1);
2568         g_signal_connect(G_OBJECT(buffer), "changed",
2569                          G_CALLBACK(image_overlay_template_view_changed_cb), image_overlay_template_view);
2570
2571         pref_line(group, PREF_PAD_GAP);
2572
2573         group = pref_group_new(vbox, FALSE, _("Exif, XMP or IPTC tags"), GTK_ORIENTATION_VERTICAL);
2574         hbox = gtk_hbox_new(FALSE, 0);
2575         gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
2576         gtk_widget_show(hbox);
2577         label = gtk_label_new(_("%Exif.Image.Orientation%"));
2578         gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
2579         gtk_widget_show(label);
2580         pref_spacer(group,TRUE);
2581
2582         group = pref_group_new(vbox, FALSE, _("Field separators"), GTK_ORIENTATION_VERTICAL);
2583         hbox = gtk_hbox_new(FALSE, 0);
2584         gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
2585         gtk_widget_show(hbox);
2586         label = gtk_label_new(_("Separator shown only if both fields are non-null:\n%formatted.ShutterSpeed%|%formatted.ISOSpeedRating%"));
2587         gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
2588         gtk_widget_show(label);
2589         pref_spacer(group,TRUE);
2590
2591         group = pref_group_new(vbox, FALSE, _("Field maximum length"), GTK_ORIENTATION_VERTICAL);
2592         hbox = gtk_hbox_new(FALSE, 0);
2593         gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
2594         gtk_widget_show(hbox);
2595         label = gtk_label_new(_("%path:39%"));
2596         gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
2597         gtk_widget_show(label);
2598         pref_spacer(group,TRUE);
2599
2600         group = pref_group_new(vbox, FALSE, _("Pre- and post- text"), GTK_ORIENTATION_VERTICAL);
2601         hbox = gtk_hbox_new(FALSE, 0);
2602         gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
2603         gtk_widget_show(hbox);
2604         label = gtk_label_new(_("Text shown only if the field is non-null:\n%formatted.Aperture:F no. * setting%\n %formatted.Aperture:10:F no. * setting%"));
2605         gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
2606         gtk_widget_show(label);
2607         pref_spacer(group,TRUE);
2608
2609         group = pref_group_new(vbox, FALSE, _("Pango markup"), GTK_ORIENTATION_VERTICAL);
2610         hbox = gtk_hbox_new(FALSE, 0);
2611         gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
2612         gtk_widget_show(hbox);
2613         label = gtk_label_new(_("<b>bold</b>\n<u>underline</u>\n<i>italic</i>\n<s>strikethrough</s>"));
2614         gtk_box_pack_start(GTK_BOX(hbox),label, FALSE,FALSE,0);
2615         gtk_widget_show(label);
2616 }
2617
2618 static GtkTreeModel *create_class_model(void)
2619 {
2620         GtkListStore *model;
2621         GtkTreeIter iter;
2622         gint i;
2623
2624         /* create list store */
2625         model = gtk_list_store_new(1, G_TYPE_STRING);
2626         for (i = 0; i < FILE_FORMAT_CLASSES; i++)
2627                 {
2628                 gtk_list_store_append(model, &iter);
2629                 gtk_list_store_set(model, &iter, 0, _(format_class_list[i]), -1);
2630                 }
2631         return GTK_TREE_MODEL (model);
2632 }
2633
2634
2635 /* filtering tab */
2636 static gint filter_table_sort_cb(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer data)
2637 {
2638         gint n = GPOINTER_TO_INT(data);
2639         gint ret = 0;
2640         FilterEntry *filter_a;
2641         FilterEntry *filter_b;
2642
2643         gtk_tree_model_get(model, a, 0, &filter_a, -1);
2644         gtk_tree_model_get(model, b, 0, &filter_b, -1);
2645
2646         switch (n)
2647                 {
2648                 case FILETYPES_COLUMN_DESCRIPTION:
2649                         {
2650                         ret = g_utf8_collate(filter_a->description, filter_b->description);
2651                         break;
2652                         }
2653                 case FILETYPES_COLUMN_CLASS:
2654                         {
2655                         ret = g_strcmp0(format_class_list[filter_a->file_class], format_class_list[filter_b->file_class]);
2656                         break;
2657                         }
2658                 case FILETYPES_COLUMN_WRITABLE:
2659                         {
2660                         ret = filter_a->writable - filter_b->writable;
2661                         break;
2662                         }
2663                 case FILETYPES_COLUMN_SIDECAR:
2664                         {
2665                         ret = filter_a->allow_sidecar - filter_b->allow_sidecar;
2666                         break;
2667                         }
2668                 default:
2669                         g_return_val_if_reached(0);
2670                 }
2671
2672         return ret;
2673 }
2674
2675 static gboolean search_function_cb(GtkTreeModel *model, gint column, const gchar *key, GtkTreeIter *iter, gpointer search_data)
2676 {
2677         FilterEntry *fe;
2678         gboolean ret = TRUE;
2679
2680         gtk_tree_model_get(model, iter, 0, &fe, -1);
2681
2682         if (g_strstr_len(fe->extensions, -1, key))
2683                 {
2684                 ret = FALSE;
2685                 }
2686
2687         return ret;
2688 }
2689
2690 static void config_tab_files(GtkWidget *notebook)
2691 {
2692         GtkWidget *hbox;
2693         GtkWidget *frame;
2694         GtkWidget *vbox;
2695         GtkWidget *group;
2696         GtkWidget *button;
2697         GtkWidget *ct_button;
2698         GtkWidget *scrolled;
2699         GtkWidget *filter_view;
2700         GtkCellRenderer *renderer;
2701         GtkTreeSelection *selection;
2702         GtkTreeViewColumn *column;
2703
2704         vbox = scrolled_notebook_page(notebook, _("Files"));
2705
2706         group = pref_box_new(vbox, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2707
2708         pref_checkbox_new_int(group, _("Show hidden files or folders"),
2709                               options->file_filter.show_hidden_files, &c_options->file_filter.show_hidden_files);
2710         pref_checkbox_new_int(group, _("Show parent folder (..)"),
2711                               options->file_filter.show_parent_directory, &c_options->file_filter.show_parent_directory);
2712         pref_checkbox_new_int(group, _("Case sensitive sort"),
2713                               options->file_sort.case_sensitive, &c_options->file_sort.case_sensitive);
2714         pref_checkbox_new_int(group, _("Natural sort order"),
2715                                           options->file_sort.natural, &c_options->file_sort.natural);
2716         pref_checkbox_new_int(group, _("Disable file extension checks"),
2717                               options->file_filter.disable_file_extension_checks, &c_options->file_filter.disable_file_extension_checks);
2718
2719         ct_button = pref_checkbox_new_int(group, _("Disable File Filtering"),
2720                                           options->file_filter.disable, &c_options->file_filter.disable);
2721
2722
2723         group = pref_group_new(vbox, FALSE, _("Grouping sidecar extensions"), GTK_ORIENTATION_VERTICAL);
2724
2725         sidecar_ext_entry = gtk_entry_new();
2726         gtk_entry_set_text(GTK_ENTRY(sidecar_ext_entry), options->sidecar.ext);
2727         gtk_box_pack_start(GTK_BOX(group), sidecar_ext_entry, FALSE, FALSE, 0);
2728         gtk_widget_show(sidecar_ext_entry);
2729
2730         group = pref_group_new(vbox, TRUE, _("File types"), GTK_ORIENTATION_VERTICAL);
2731
2732         frame = pref_group_parent(group);
2733         g_signal_connect(G_OBJECT(ct_button), "toggled",
2734                          G_CALLBACK(filter_disable_cb), frame);
2735         gtk_widget_set_sensitive(frame, !options->file_filter.disable);
2736
2737         scrolled = gtk_scrolled_window_new(NULL, NULL);
2738         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
2739         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
2740         gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
2741         gtk_widget_show(scrolled);
2742
2743         filter_store = gtk_list_store_new(1, G_TYPE_POINTER);
2744         filter_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(filter_store));
2745         g_object_unref(filter_store);
2746         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(filter_view));
2747         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
2748
2749         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(filter_view), FALSE);
2750
2751         column = gtk_tree_view_column_new();
2752         gtk_tree_view_column_set_title(column, _("Filter"));
2753         gtk_tree_view_column_set_resizable(column, TRUE);
2754
2755         renderer = gtk_cell_renderer_toggle_new();
2756         g_signal_connect(G_OBJECT(renderer), "toggled",
2757                          G_CALLBACK(filter_store_enable_cb), filter_store);
2758         gtk_tree_view_column_pack_start(column, renderer, FALSE);
2759         gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
2760                                                 GINT_TO_POINTER(FE_ENABLE), NULL);
2761
2762         renderer = gtk_cell_renderer_text_new();
2763         g_signal_connect(G_OBJECT(renderer), "edited",
2764                          G_CALLBACK(filter_store_ext_edit_cb), filter_store);
2765         gtk_tree_view_column_pack_start(column, renderer, TRUE);
2766         g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
2767         gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
2768                                                 GINT_TO_POINTER(FE_EXTENSION), NULL);
2769         gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
2770
2771         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(filter_view), TRUE);
2772         gtk_tree_view_set_search_column(GTK_TREE_VIEW(filter_view), FILETYPES_COLUMN_FILTER);
2773         gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(filter_view), search_function_cb, NULL, NULL);
2774
2775         column = gtk_tree_view_column_new();
2776         gtk_tree_view_column_set_title(column, _("Description"));
2777         gtk_tree_view_column_set_resizable(column, TRUE);
2778         gtk_tree_view_column_set_fixed_width(column, 200);
2779         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
2780
2781         renderer = gtk_cell_renderer_text_new();
2782         g_signal_connect(G_OBJECT(renderer), "edited",
2783                          G_CALLBACK(filter_store_desc_edit_cb), filter_store);
2784         g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
2785         gtk_tree_view_column_pack_start(column, renderer, FALSE);
2786         gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
2787                                                 GINT_TO_POINTER(FE_DESCRIPTION), NULL);
2788         gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
2789         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_DESCRIPTION, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_DESCRIPTION), NULL);
2790         gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_DESCRIPTION);
2791
2792         column = gtk_tree_view_column_new();
2793         gtk_tree_view_column_set_title(column, _("Class"));
2794         gtk_tree_view_column_set_resizable(column, TRUE);
2795         renderer = gtk_cell_renderer_combo_new();
2796         g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE,
2797                                          "model", create_class_model(),
2798                                          "text-column", 0,
2799                                          "has-entry", FALSE,
2800                                          NULL);
2801
2802         g_signal_connect(G_OBJECT(renderer), "edited",
2803                          G_CALLBACK(filter_store_class_edit_cb), filter_store);
2804         gtk_tree_view_column_pack_start(column, renderer, TRUE);
2805         gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
2806                                                 GINT_TO_POINTER(FE_CLASS), NULL);
2807         gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
2808         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_CLASS, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_CLASS), NULL);
2809         gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_CLASS);
2810
2811         column = gtk_tree_view_column_new();
2812         gtk_tree_view_column_set_title(column, _("Writable"));
2813         gtk_tree_view_column_set_resizable(column, FALSE);
2814         renderer = gtk_cell_renderer_toggle_new();
2815         g_signal_connect(G_OBJECT(renderer), "toggled",
2816                          G_CALLBACK(filter_store_writable_cb), filter_store);
2817         gtk_tree_view_column_pack_start(column, renderer, FALSE);
2818         gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
2819                                                 GINT_TO_POINTER(FE_WRITABLE), NULL);
2820         gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
2821         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_WRITABLE, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_WRITABLE), NULL);
2822         gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_WRITABLE);
2823
2824         column = gtk_tree_view_column_new();
2825         gtk_tree_view_column_set_title(column, _("Sidecar is allowed"));
2826         gtk_tree_view_column_set_resizable(column, FALSE);
2827         renderer = gtk_cell_renderer_toggle_new();
2828         g_signal_connect(G_OBJECT(renderer), "toggled",
2829                          G_CALLBACK(filter_store_sidecar_cb), filter_store);
2830         gtk_tree_view_column_pack_start(column, renderer, FALSE);
2831         gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
2832                                                 GINT_TO_POINTER(FE_ALLOW_SIDECAR), NULL);
2833         gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
2834         gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(filter_store), FILETYPES_COLUMN_SIDECAR, filter_table_sort_cb, GINT_TO_POINTER(FILETYPES_COLUMN_SIDECAR), NULL);
2835         gtk_tree_view_column_set_sort_column_id(column, FILETYPES_COLUMN_SIDECAR);
2836
2837         filter_store_populate();
2838         gtk_container_add(GTK_CONTAINER(scrolled), filter_view);
2839         gtk_widget_show(filter_view);
2840
2841         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
2842
2843         button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
2844                                  G_CALLBACK(filter_default_cb), filter_view);
2845         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2846         gtk_widget_show(button);
2847
2848         button = pref_button_new(NULL, GTK_STOCK_REMOVE, NULL, FALSE,
2849                                  G_CALLBACK(filter_remove_cb), filter_view);
2850         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2851         gtk_widget_show(button);
2852
2853         button = pref_button_new(NULL, GTK_STOCK_ADD, NULL, FALSE,
2854                                  G_CALLBACK(filter_add_cb), filter_view);
2855         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
2856         gtk_widget_show(button);
2857 }
2858
2859 /* metadata tab */
2860 static void config_tab_metadata(GtkWidget *notebook)
2861 {
2862         GtkWidget *vbox;
2863         GtkWidget *hbox;
2864         GtkWidget *group;
2865         GtkWidget *ct_button;
2866         GtkWidget *label;
2867         gchar *text;
2868
2869         vbox = scrolled_notebook_page(notebook, _("Metadata"));
2870
2871
2872         group = pref_group_new(vbox, FALSE, _("Metadata writing process"), GTK_ORIENTATION_VERTICAL);
2873 #ifndef HAVE_EXIV2
2874         label = pref_label_new(group, _("Warning: Geeqie is built without Exiv2. Some options are disabled."));
2875 #endif
2876         label = pref_label_new(group, _("Metadata are written in the following order. The process ends after first success."));
2877 #if GTK_CHECK_VERSION(3,16,0)
2878         gtk_label_set_xalign(GTK_LABEL(label), 0.0);
2879         gtk_label_set_yalign(GTK_LABEL(label), 0.5);
2880 #else
2881         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2882 #endif
2883
2884         ct_button = pref_checkbox_new_int(group, _("1) Save metadata in image files, or sidecar files, according to the XMP standard"),
2885                               options->metadata.save_in_image_file, &c_options->metadata.save_in_image_file);
2886 #ifndef HAVE_EXIV2
2887         gtk_widget_set_sensitive(ct_button, FALSE);
2888 #endif
2889
2890         pref_checkbox_new_int(group, _("2) Save metadata in '.metadata' folder, local to image folder (non-standard)"),
2891                               options->metadata.enable_metadata_dirs, &c_options->metadata.enable_metadata_dirs);
2892
2893         text = g_strdup_printf(_("3) Save metadata in Geeqie private directory '%s'"), get_metadata_cache_dir());
2894         label = pref_label_new(group, text);
2895 #if GTK_CHECK_VERSION(3,16,0)
2896         gtk_label_set_xalign(GTK_LABEL(label), 0.0);
2897         gtk_label_set_yalign(GTK_LABEL(label), 0.5);
2898 #else
2899         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
2900 #endif
2901         gtk_misc_set_padding(GTK_MISC(label), 22, 0);
2902         g_free(text);
2903
2904         group = pref_group_new(vbox, FALSE, _("Step 1: Write to image files"), GTK_ORIENTATION_VERTICAL);
2905 #ifndef HAVE_EXIV2
2906         gtk_widget_set_sensitive(group, FALSE);
2907 #endif
2908
2909         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_SPACE);
2910         pref_checkbox_link_sensitivity(ct_button, hbox);
2911
2912         pref_checkbox_new_int(hbox, _("Store metadata also in legacy IPTC tags (converted according to IPTC4XMP standard)"),
2913                               options->metadata.save_legacy_IPTC, &c_options->metadata.save_legacy_IPTC);
2914
2915         pref_checkbox_new_int(hbox, _("Warn if the image files are unwritable"),
2916                               options->metadata.warn_on_write_problems, &c_options->metadata.warn_on_write_problems);
2917
2918         pref_checkbox_new_int(hbox, _("Ask before writing to image files"),
2919                               options->metadata.confirm_write, &c_options->metadata.confirm_write);
2920
2921         pref_checkbox_new_int(hbox, _("Create sidecar files named image.ext.xmp (as opposed to image.xmp)"),
2922                               options->metadata.sidecar_extended_name, &c_options->metadata.sidecar_extended_name);
2923
2924         group = pref_group_new(vbox, FALSE, _("Step 2 and 3: write to Geeqie private files"), GTK_ORIENTATION_VERTICAL);
2925 #ifndef HAVE_EXIV2
2926         gtk_widget_set_sensitive(group, FALSE);
2927 #endif
2928
2929         pref_checkbox_new_int(group, _("Use GQview legacy metadata format (supports only keywords and comments) instead of XMP"),
2930                               options->metadata.save_legacy_format, &c_options->metadata.save_legacy_format);
2931
2932
2933         group = pref_group_new(vbox, FALSE, _("Miscellaneous"), GTK_ORIENTATION_VERTICAL);
2934         pref_checkbox_new_int(group, _("Write the same description tags (keywords, comment, etc.) to all grouped sidecars"),
2935                               options->metadata.sync_grouped_files, &c_options->metadata.sync_grouped_files);
2936
2937         pref_checkbox_new_int(group, _("Allow keywords to differ only in case"),
2938                               options->metadata.keywords_case_sensitive, &c_options->metadata.keywords_case_sensitive);
2939
2940         ct_button = pref_checkbox_new_int(group, _("Write altered image orientation to the metadata"),
2941                               options->metadata.write_orientation, &c_options->metadata.write_orientation);
2942 #ifndef HAVE_EXIV2
2943         gtk_widget_set_sensitive(ct_button, FALSE);
2944 #endif
2945
2946         group = pref_group_new(vbox, FALSE, _("Auto-save options"), GTK_ORIENTATION_VERTICAL);
2947
2948         ct_button = pref_checkbox_new_int(group, _("Write metadata after timeout"),
2949                               options->metadata.confirm_after_timeout, &c_options->metadata.confirm_after_timeout);
2950
2951         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2952         pref_checkbox_link_sensitivity(ct_button, hbox);
2953
2954         pref_spin_new_int(hbox, _("Timeout (seconds):"), NULL, 0, 900, 1,
2955                               options->metadata.confirm_timeout, &c_options->metadata.confirm_timeout);
2956
2957         pref_checkbox_new_int(group, _("Write metadata on image change"),
2958                               options->metadata.confirm_on_image_change, &c_options->metadata.confirm_on_image_change);
2959
2960         pref_checkbox_new_int(group, _("Write metadata on directory change"),
2961                               options->metadata.confirm_on_dir_change, &c_options->metadata.confirm_on_dir_change);
2962
2963         group = pref_group_new(vbox, FALSE, _("Pre-load metadata"), GTK_ORIENTATION_VERTICAL);
2964
2965         ct_button = pref_checkbox_new_int(group, _("Read metadata in background"),
2966                                           options->read_metadata_in_idle, &c_options->read_metadata_in_idle);
2967         gtk_widget_set_tooltip_text(ct_button,"On folder change, read DateTimeOriginal, DateTimeDigitized and Star Rating in the idle loop.\nIf this is not selected, initial loading of the folder will be faster but sorting on these items will be slower");
2968 }
2969
2970 /* keywords tab */
2971
2972 typedef struct _KeywordFindData KeywordFindData;
2973 struct _KeywordFindData
2974 {
2975         GenericDialog *gd;
2976
2977         GList *list;
2978         GList *list_dir;
2979
2980         GtkWidget *button_close;
2981         GtkWidget *button_stop;
2982         GtkWidget *button_start;
2983         GtkWidget *progress;
2984         GtkWidget *spinner;
2985
2986         GtkWidget *group;
2987         GtkWidget *entry;
2988
2989         gboolean recurse;
2990
2991         guint idle_id; /* event source id */
2992 };
2993
2994 #define KEYWORD_DIALOG_WIDTH 400
2995
2996 static void keywords_find_folder(KeywordFindData *kfd, FileData *dir_fd)
2997 {
2998         GList *list_d = NULL;
2999         GList *list_f = NULL;
3000
3001         if (kfd->recurse)
3002                 {
3003                 filelist_read(dir_fd, &list_f, &list_d);
3004                 }
3005         else
3006                 {
3007                 filelist_read(dir_fd, &list_f, NULL);
3008                 }
3009
3010         list_f = filelist_filter(list_f, FALSE);
3011         list_d = filelist_filter(list_d, TRUE);
3012
3013         kfd->list = g_list_concat(list_f, kfd->list);
3014         kfd->list_dir = g_list_concat(list_d, kfd->list_dir);
3015 }
3016
3017 static void keywords_find_reset(KeywordFindData *kfd)
3018 {
3019         filelist_free(kfd->list);
3020         kfd->list = NULL;
3021
3022         filelist_free(kfd->list_dir);
3023         kfd->list_dir = NULL;
3024 }
3025
3026 static void keywords_find_close_cb(GenericDialog *fd, gpointer data)
3027 {
3028         KeywordFindData *kfd = data;
3029
3030         if (!gtk_widget_get_sensitive(kfd->button_close)) return;
3031
3032         keywords_find_reset(kfd);
3033         generic_dialog_close(kfd->gd);
3034         g_free(kfd);
3035 }
3036
3037 static void keywords_find_finish(KeywordFindData *kfd)
3038 {
3039         keywords_find_reset(kfd);
3040
3041         gtk_entry_set_text(GTK_ENTRY(kfd->progress), _("done"));
3042         spinner_set_interval(kfd->spinner, -1);
3043
3044         gtk_widget_set_sensitive(kfd->group, TRUE);
3045         gtk_widget_set_sensitive(kfd->button_start, TRUE);
3046         gtk_widget_set_sensitive(kfd->button_stop, FALSE);
3047         gtk_widget_set_sensitive(kfd->button_close, TRUE);
3048 }
3049
3050 static void keywords_find_stop_cb(GenericDialog *fd, gpointer data)
3051 {
3052         KeywordFindData *kfd = data;
3053
3054         g_idle_remove_by_data(kfd);
3055
3056         keywords_find_finish(kfd);
3057 }
3058
3059 static gboolean keywords_find_file(gpointer data)
3060 {
3061         KeywordFindData *kfd = data;
3062         GtkTextIter iter;
3063         GtkTextBuffer *buffer;
3064         gchar *tmp;
3065         GList *keywords;
3066
3067         if (kfd->list)
3068                 {
3069                 FileData *fd;
3070
3071                 fd = kfd->list->data;
3072                 kfd->list = g_list_remove(kfd->list, fd);
3073
3074                 keywords = metadata_read_list(fd, KEYWORD_KEY, METADATA_PLAIN);
3075                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(keyword_text));
3076
3077                 while (keywords)
3078                         {
3079                         gtk_text_buffer_get_end_iter(buffer, &iter);
3080                         tmp = g_strconcat(keywords->data, "\n", NULL);
3081                         gtk_text_buffer_insert(buffer, &iter, tmp, -1);
3082                         g_free(tmp);
3083                         keywords = keywords->next;
3084                         }
3085
3086                 gtk_entry_set_text(GTK_ENTRY(kfd->progress), fd->path);
3087                 file_data_unref(fd);
3088                 string_list_free(keywords);
3089
3090                 return (TRUE);
3091                 }
3092         else if (kfd->list_dir)
3093                 {
3094                 FileData *fd;
3095
3096                 fd = kfd->list_dir->data;
3097                 kfd->list_dir = g_list_remove(kfd->list_dir, fd);
3098
3099                 keywords_find_folder(kfd, fd);
3100
3101                 file_data_unref(fd);
3102
3103                 return TRUE;
3104                 }
3105
3106         keywords_find_finish(kfd);
3107
3108         return FALSE;
3109 }
3110
3111 static void keywords_find_start_cb(GenericDialog *fd, gpointer data)
3112 {
3113         KeywordFindData *kfd = data;
3114         gchar *path;
3115
3116         if (kfd->list || !gtk_widget_get_sensitive(kfd->button_start)) return;
3117
3118         path = remove_trailing_slash((gtk_entry_get_text(GTK_ENTRY(kfd->entry))));
3119         parse_out_relatives(path);
3120
3121         if (!isdir(path))
3122                 {
3123                 warning_dialog(_("Invalid folder"),
3124                                 _("The specified folder can not be found."),
3125                                 GTK_STOCK_DIALOG_WARNING, kfd->gd->dialog);
3126                 }
3127         else
3128                 {
3129                 FileData *dir_fd;
3130
3131                 gtk_widget_set_sensitive(kfd->group, FALSE);
3132                 gtk_widget_set_sensitive(kfd->button_start, FALSE);
3133                 gtk_widget_set_sensitive(kfd->button_stop, TRUE);
3134                 gtk_widget_set_sensitive(kfd->button_close, FALSE);
3135                 spinner_set_interval(kfd->spinner, SPINNER_SPEED);
3136
3137                 dir_fd = file_data_new_dir(path);
3138                 keywords_find_folder(kfd, dir_fd);
3139                 file_data_unref(dir_fd);
3140                 kfd->idle_id = g_idle_add(keywords_find_file, kfd);
3141                 }
3142
3143         g_free(path);
3144 }
3145
3146 static void keywords_find_dialog(GtkWidget *widget, const gchar *path)
3147 {
3148         KeywordFindData *kfd;
3149         GtkWidget *hbox;
3150         GtkWidget *label;
3151
3152         kfd = g_new0(KeywordFindData, 1);
3153
3154         kfd->gd = generic_dialog_new(_("Search for keywords"),
3155                                                                         "search_for_keywords",
3156                                                                         widget, FALSE,
3157                                                                         NULL, kfd);
3158         gtk_window_set_default_size(GTK_WINDOW(kfd->gd->dialog), KEYWORD_DIALOG_WIDTH, -1);
3159         kfd->gd->cancel_cb = keywords_find_close_cb;
3160         kfd->button_close = generic_dialog_add_button(kfd->gd, GTK_STOCK_CLOSE, NULL,
3161                                                      keywords_find_close_cb, FALSE);
3162         kfd->button_start = generic_dialog_add_button(kfd->gd, GTK_STOCK_OK, _("S_tart"),
3163                                                      keywords_find_start_cb, FALSE);
3164         kfd->button_stop = generic_dialog_add_button(kfd->gd, GTK_STOCK_STOP, NULL,
3165                                                     keywords_find_stop_cb, FALSE);
3166         gtk_widget_set_sensitive(kfd->button_stop, FALSE);
3167
3168         generic_dialog_add_message(kfd->gd, NULL, _("Search for keywords"), NULL, FALSE);
3169
3170         hbox = pref_box_new(kfd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
3171         pref_spacer(hbox, PREF_PAD_INDENT);
3172         kfd->group = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
3173
3174         hbox = pref_box_new(kfd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
3175         pref_label_new(hbox, _("Folder:"));
3176
3177         label = tab_completion_new(&kfd->entry, path, NULL, NULL, NULL, NULL);
3178         tab_completion_add_select_button(kfd->entry,_("Select folder") , TRUE);
3179         gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
3180         gtk_widget_show(label);
3181
3182         pref_checkbox_new_int(kfd->group, _("Include subfolders"), FALSE, &kfd->recurse);
3183
3184         pref_line(kfd->gd->vbox, PREF_PAD_SPACE);
3185         hbox = pref_box_new(kfd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
3186
3187         kfd->progress = gtk_entry_new();
3188         gtk_widget_set_can_focus(kfd->progress, FALSE);
3189         gtk_editable_set_editable(GTK_EDITABLE(kfd->progress), FALSE);
3190         gtk_entry_set_text(GTK_ENTRY(kfd->progress), _("click start to begin"));
3191         gtk_box_pack_start(GTK_BOX(hbox), kfd->progress, TRUE, TRUE, 0);
3192         gtk_widget_show(kfd->progress);
3193
3194         kfd->spinner = spinner_new(NULL, -1);
3195         gtk_box_pack_start(GTK_BOX(hbox), kfd->spinner, FALSE, FALSE, 0);
3196         gtk_widget_show(kfd->spinner);
3197
3198         kfd->list = NULL;
3199
3200         gtk_widget_show(kfd->gd->dialog);
3201 }
3202
3203 static void keywords_find_cb(GtkWidget *widget, gpointer data)
3204 {
3205         const gchar *path = layout_get_path(NULL);
3206
3207         if (!path || !*path) path = homedir();
3208         keywords_find_dialog(widget, path);
3209 }
3210
3211 static void config_tab_keywords_save()
3212 {
3213         GtkTextIter start, end;
3214         GtkTextBuffer *buffer;
3215         GList *kw_list = NULL;
3216         GList *work;
3217         gchar *buffer_text;
3218         gchar *kw_split;
3219         gboolean found;
3220
3221         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(keyword_text));
3222         gtk_text_buffer_get_bounds(buffer, &start, &end);
3223
3224         buffer_text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
3225
3226         kw_split = strtok(buffer_text, "\n");
3227         while (kw_split != NULL)
3228                 {
3229                 work = kw_list;
3230                 found = FALSE;
3231                 while (work)
3232                         {
3233                         if (g_strcmp0(work->data, kw_split) == 0)
3234                                 {
3235                                 found = TRUE;
3236                                 break;
3237                                 }
3238                         work = work->next;
3239                         }
3240                 if (!found)
3241                         {
3242                         kw_list = g_list_append(kw_list, g_strdup(kw_split));
3243                         }
3244                 kw_split = strtok(NULL, "\n");
3245                 }
3246
3247         keyword_list_set(kw_list);
3248
3249         string_list_free(kw_list);
3250         g_free(buffer_text);
3251 }
3252
3253 static void config_tab_keywords(GtkWidget *notebook)
3254 {
3255         GtkWidget *hbox;
3256         GtkWidget *vbox;
3257         GtkWidget *group;
3258         GtkWidget *button;
3259         GtkWidget *scrolled;
3260         GtkTextIter iter;
3261         GtkTextBuffer *buffer;
3262         gchar *tmp;
3263
3264         vbox = scrolled_notebook_page(notebook, _("Keywords"));
3265
3266         group = pref_group_new(vbox, TRUE, _("Edit keywords autocompletion list"), GTK_ORIENTATION_VERTICAL);
3267
3268         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
3269
3270         button = pref_button_new(hbox, GTK_STOCK_EXECUTE, _("Search"), FALSE,
3271                                    G_CALLBACK(keywords_find_cb), keyword_text);
3272         gtk_widget_set_tooltip_text(button, "Search for existing keywords");
3273
3274
3275         keyword_text = gtk_text_view_new();
3276         gtk_widget_set_size_request(keyword_text, 20, 20);
3277         scrolled = gtk_scrolled_window_new(NULL, NULL);
3278         gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
3279         gtk_widget_show(scrolled);
3280
3281         gtk_container_add(GTK_CONTAINER(scrolled), keyword_text);
3282         gtk_widget_show(keyword_text);
3283
3284         gtk_text_view_set_editable(GTK_TEXT_VIEW(keyword_text), TRUE);
3285
3286         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(keyword_text));
3287         gtk_text_buffer_create_tag(buffer, "monospace",
3288                                 "family", "monospace", NULL);
3289
3290         gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(keyword_text), GTK_WRAP_WORD);
3291         gtk_text_buffer_get_start_iter(buffer, &iter);
3292         gtk_text_buffer_create_mark(buffer, "end", &iter, FALSE);
3293         gchar *path;
3294
3295         path = g_build_filename(get_rc_dir(), "keywords", NULL);
3296
3297         GList *kwl = keyword_list_get();
3298         kwl = g_list_first(kwl);
3299         while (kwl)
3300         {
3301                 gtk_text_buffer_get_end_iter (buffer, &iter);
3302             tmp = g_strconcat(kwl->data, "\n", NULL);
3303                 gtk_text_buffer_insert(buffer, &iter, tmp, -1);
3304                 kwl = kwl->next;
3305                 g_free(tmp);
3306         }
3307
3308         gtk_text_buffer_set_modified(buffer, FALSE);
3309
3310         g_free(path);
3311 }
3312
3313 /* metadata tab */
3314 #ifdef HAVE_LCMS
3315 static void intent_menu_cb(GtkWidget *combo, gpointer data)
3316 {
3317         gint *option = data;
3318
3319         switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
3320                 {
3321                 case 0:
3322                 default:
3323                         *option = INTENT_PERCEPTUAL;
3324                         break;
3325                 case 1:
3326                         *option = INTENT_RELATIVE_COLORIMETRIC;
3327                         break;
3328                 case 2:
3329                         *option = INTENT_SATURATION;
3330                         break;
3331                 case 3:
3332                         *option = INTENT_ABSOLUTE_COLORIMETRIC;
3333                         break;
3334                 }
3335 }
3336
3337 static void add_intent_menu(GtkWidget *table, gint column, gint row, const gchar *text,
3338                              gint option, gint *option_c)
3339 {
3340         GtkWidget *combo;
3341         gint current = 0;
3342
3343         *option_c = option;
3344
3345         pref_table_label(table, column, row, text, 0.0);
3346
3347         combo = gtk_combo_box_text_new();
3348
3349         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Perceptual"));
3350         if (option == INTENT_PERCEPTUAL) current = 0;
3351         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Relative Colorimetric"));
3352         if (option == INTENT_RELATIVE_COLORIMETRIC) current = 1;
3353         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Saturation"));
3354         if (option == INTENT_SATURATION) current = 2;
3355         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Absolute Colorimetric"));
3356         if (option == INTENT_ABSOLUTE_COLORIMETRIC) current = 3;
3357
3358         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), current);
3359
3360         gtk_widget_set_tooltip_text(combo,"Refer to the lcms documentation for the defaults used when the selected Intent is not available");
3361
3362         g_signal_connect(G_OBJECT(combo), "changed",
3363                          G_CALLBACK(intent_menu_cb), option_c);
3364
3365         gtk_table_attach(GTK_TABLE(table), combo, column + 1, column + 2, row, row + 1, GTK_SHRINK, 0, 0, 0);
3366         gtk_widget_show(combo);
3367 }
3368 #endif
3369
3370 static void config_tab_color(GtkWidget *notebook)
3371 {
3372         GtkWidget *label;
3373         GtkWidget *vbox;
3374         GtkWidget *group;
3375         GtkWidget *tabcomp;
3376         GtkWidget *table;
3377         gint i;
3378
3379         vbox = scrolled_notebook_page(notebook, _("Color management"));
3380
3381         group =  pref_group_new(vbox, FALSE, _("Input profiles"), GTK_ORIENTATION_VERTICAL);
3382 #ifndef HAVE_LCMS
3383         gtk_widget_set_sensitive(pref_group_parent(group), FALSE);
3384 #endif
3385
3386         table = pref_table_new(group, 3, COLOR_PROFILE_INPUTS + 1, FALSE, FALSE);
3387         gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
3388
3389         label = pref_table_label(table, 0, 0, _("Type"), 0.0);
3390         pref_label_bold(label, TRUE, FALSE);
3391
3392         label = pref_table_label(table, 1, 0, _("Menu name"), 0.0);
3393         pref_label_bold(label, TRUE, FALSE);
3394
3395         label = pref_table_label(table, 2, 0, _("File"), 0.0);
3396         pref_label_bold(label, TRUE, FALSE);
3397
3398         for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
3399                 {
3400                 GtkWidget *entry;
3401                 gchar *buf;
3402
3403                 buf = g_strdup_printf(_("Input %d:"), i + COLOR_PROFILE_FILE);
3404                 pref_table_label(table, 0, i + 1, buf, 1.0);
3405                 g_free(buf);
3406
3407                 entry = gtk_entry_new();
3408                 gtk_entry_set_max_length(GTK_ENTRY(entry), EDITOR_NAME_MAX_LENGTH);
3409                 if (options->color_profile.input_name[i])
3410                         {
3411                         gtk_entry_set_text(GTK_ENTRY(entry), options->color_profile.input_name[i]);
3412                         }
3413                 gtk_table_attach(GTK_TABLE(table), entry, 1, 2, i + 1, i + 2,
3414                                  GTK_FILL | GTK_EXPAND, 0, 0, 0);
3415                 gtk_widget_show(entry);
3416                 color_profile_input_name_entry[i] = entry;
3417
3418                 tabcomp = tab_completion_new(&entry, options->color_profile.input_file[i], NULL, ".icc", "ICC Files", NULL);
3419                 tab_completion_add_select_button(entry, _("Select color profile"), FALSE);
3420                 gtk_widget_set_size_request(entry, 160, -1);
3421                 gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3, i + 1, i + 2,
3422                                  GTK_FILL | GTK_EXPAND, 0, 0, 0);
3423                 gtk_widget_show(tabcomp);
3424                 color_profile_input_file_entry[i] = entry;
3425                 }
3426
3427         group =  pref_group_new(vbox, FALSE, _("Screen profile"), GTK_ORIENTATION_VERTICAL);
3428 #ifndef HAVE_LCMS
3429         gtk_widget_set_sensitive(pref_group_parent(group), FALSE);
3430 #endif
3431         pref_checkbox_new_int(group, _("Use system screen profile if available"),
3432                               options->color_profile.use_x11_screen_profile, &c_options->color_profile.use_x11_screen_profile);
3433
3434         table = pref_table_new(group, 2, 1, FALSE, FALSE);
3435
3436         pref_table_label(table, 0, 0, _("Screen:"), 1.0);
3437         tabcomp = tab_completion_new(&color_profile_screen_file_entry,
3438                                      options->color_profile.screen_file, NULL, ".icc", "ICC Files", NULL);
3439         tab_completion_add_select_button(color_profile_screen_file_entry, _("Select color profile"), FALSE);
3440         gtk_widget_set_size_request(color_profile_screen_file_entry, 160, -1);
3441 #ifdef HAVE_LCMS
3442         add_intent_menu(table, 0, 1, _("Render Intent:"), options->color_profile.render_intent, &c_options->color_profile.render_intent);
3443 #endif
3444         gtk_table_attach(GTK_TABLE(table), tabcomp, 1, 2,
3445                          0, 1,
3446                          GTK_FILL | GTK_EXPAND, 0, 0, 0);
3447
3448         gtk_widget_show(tabcomp);
3449 }
3450
3451 /* advanced entry tab */
3452 static void use_geeqie_trash_cb(GtkWidget *widget, gpointer data)
3453 {
3454         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
3455                 {
3456                 c_options->file_ops.use_system_trash = FALSE;
3457                 c_options->file_ops.no_trash = FALSE;
3458                 }
3459 }
3460
3461 static void use_system_trash_cb(GtkWidget *widget, gpointer data)
3462 {
3463         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
3464                 {
3465                 c_options->file_ops.use_system_trash = TRUE;
3466                 c_options->file_ops.no_trash = FALSE;
3467                 }
3468 }
3469
3470 static void use_no_cache_cb(GtkWidget *widget, gpointer data)
3471 {
3472         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
3473                 {
3474                 c_options->file_ops.no_trash = TRUE;
3475                 }
3476 }
3477
3478 static void config_tab_behavior(GtkWidget *notebook)
3479 {
3480         GtkWidget *hbox;
3481         GtkWidget *vbox;
3482         GtkWidget *group;
3483         GtkWidget *button;
3484         GtkWidget *tabcomp;
3485         GtkWidget *ct_button;
3486         GtkWidget *spin;
3487         GtkWidget *table;
3488         GtkWidget *marks;
3489         GtkWidget *with_rename;
3490         GtkWidget *collections_on_top;
3491         GtkWidget *hide_window_in_fullscreen;
3492         GtkWidget *checkbox;
3493         GtkWidget *tmp;
3494
3495         vbox = scrolled_notebook_page(notebook, _("Behavior"));
3496
3497         group = pref_group_new(vbox, FALSE, _("Delete"), GTK_ORIENTATION_VERTICAL);
3498
3499         pref_checkbox_new_int(group, _("Confirm permanent file delete"),
3500                               options->file_ops.confirm_delete, &c_options->file_ops.confirm_delete);
3501         pref_checkbox_new_int(group, _("Confirm move file to Trash"),
3502                               options->file_ops.confirm_move_to_trash, &c_options->file_ops.confirm_move_to_trash);
3503         pref_checkbox_new_int(group, _("Enable Delete key"),
3504                               options->file_ops.enable_delete_key, &c_options->file_ops.enable_delete_key);
3505
3506         ct_button = pref_radiobutton_new(group, NULL, _("Use Geeqie trash location"),
3507                                         !options->file_ops.use_system_trash && !options->file_ops.no_trash, G_CALLBACK(use_geeqie_trash_cb),NULL);
3508
3509         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
3510         pref_checkbox_link_sensitivity(ct_button, hbox);
3511
3512         pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_SPACE);
3513         pref_label_new(hbox, _("Folder:"));
3514
3515         tabcomp = tab_completion_new(&safe_delete_path_entry, options->file_ops.safe_delete_path, NULL, NULL, NULL, NULL);
3516         tab_completion_add_select_button(safe_delete_path_entry, NULL, TRUE);
3517         gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
3518         gtk_widget_show(tabcomp);
3519
3520         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
3521         pref_checkbox_link_sensitivity(ct_button, hbox);
3522
3523         pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_GAP);
3524         spin = pref_spin_new_int(hbox, _("Maximum size:"), _("MiB"),
3525                                  0, 2048, 1, options->file_ops.safe_delete_folder_maxsize, &c_options->file_ops.safe_delete_folder_maxsize);
3526         gtk_widget_set_tooltip_markup(spin, _("Set to 0 for unlimited size"));
3527         button = pref_button_new(NULL, NULL, _("View"), FALSE,
3528                                  G_CALLBACK(safe_delete_view_cb), NULL);
3529         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
3530         gtk_widget_show(button);
3531
3532         button = pref_button_new(NULL, GTK_STOCK_CLEAR, NULL, FALSE,
3533                                  G_CALLBACK(safe_delete_clear_cb), NULL);
3534         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
3535         pref_radiobutton_new(group, ct_button, _("Use system Trash bin"),
3536                                         options->file_ops.use_system_trash && !options->file_ops.no_trash, G_CALLBACK(use_system_trash_cb), NULL);
3537
3538         pref_radiobutton_new(group, ct_button, _("Use no trash at all"),
3539                         options->file_ops.no_trash, G_CALLBACK(use_no_cache_cb), NULL);
3540
3541         gtk_widget_show(button);
3542
3543         pref_spacer(group, PREF_PAD_GROUP);
3544
3545
3546         group = pref_group_new(vbox, FALSE, _("Behavior"), GTK_ORIENTATION_VERTICAL);
3547
3548         pref_checkbox_new_int(group, _("Descend folders in tree view"),
3549                               options->tree_descend_subdirs, &c_options->tree_descend_subdirs);
3550
3551         pref_checkbox_new_int(group, _("In place renaming"),
3552                               options->file_ops.enable_in_place_rename, &c_options->file_ops.enable_in_place_rename);
3553
3554         pref_checkbox_new_int(group, _("List directory view uses single click to enter"),
3555                               options->view_dir_list_single_click_enter, &c_options->view_dir_list_single_click_enter);
3556
3557         tmp = pref_checkbox_new_int(group, _("Circular selection lists"),
3558                               options->circular_selection_lists, &c_options->circular_selection_lists);
3559         gtk_widget_set_tooltip_text(tmp, _("Traverse selection lists in a circular manner"));
3560
3561         marks = pref_checkbox_new_int(group, _("Save marks on exit"),
3562                                 options->marks_save, &c_options->marks_save);
3563         gtk_widget_set_tooltip_text(marks,"Note that marks linked to a keyword will be saved irrespective of this setting");
3564
3565         with_rename = pref_checkbox_new_int(group, _("Use \"With Rename\" as default for Copy/Move dialogs"),
3566                                 options->with_rename, &c_options->with_rename);
3567         gtk_widget_set_tooltip_text(with_rename,"Change the default button for Copy/Move dialogs");
3568
3569         collections_on_top = pref_checkbox_new_int(group, _("Open collections on top"),
3570                                 options->collections_on_top, &c_options->collections_on_top);
3571         gtk_widget_set_tooltip_text(collections_on_top,"Open collections window on top");
3572
3573         hide_window_in_fullscreen = pref_checkbox_new_int(group, _("Hide window in fullscreen"),
3574                                 options->hide_window_in_fullscreen, &c_options->hide_window_in_fullscreen);
3575         gtk_widget_set_tooltip_text(hide_window_in_fullscreen,"When alt-tabbing, prevent Geeqie window showing twice");
3576
3577         pref_spin_new_int(group, _("Recent folder list maximum size"), NULL,
3578                           1, 50, 1, options->open_recent_list_maxsize, &c_options->open_recent_list_maxsize);
3579
3580         pref_spin_new_int(group, _("Drag'n drop icon size"), NULL,
3581                           16, 256, 16, options->dnd_icon_size, &c_options->dnd_icon_size);
3582
3583         table = pref_table_new(group, 2, 1, FALSE, FALSE);
3584         add_dnd_default_action_selection_menu(table, 0, 0, _("Drag`n drop default action:"), options->dnd_default_action, &c_options->dnd_default_action);
3585
3586         table = pref_table_new(group, 2, 1, FALSE, FALSE);
3587         add_clipboard_selection_menu(table, 0, 0, _("Copy path clipboard selection:"), options->clipboard_selection, &c_options->clipboard_selection);
3588
3589         pref_spacer(group, PREF_PAD_GROUP);
3590
3591         group = pref_group_new(vbox, FALSE, _("Navigation"), GTK_ORIENTATION_VERTICAL);
3592
3593         pref_checkbox_new_int(group, _("Progressive keyboard scrolling"),
3594                               options->progressive_key_scrolling, &c_options->progressive_key_scrolling);
3595         pref_spin_new_int(group, _("Keyboard scrolling step multiplier:"), NULL,
3596                           1, 32, 1, options->keyboard_scroll_step, (int *)&c_options->keyboard_scroll_step);
3597         pref_checkbox_new_int(group, _("Mouse wheel scrolls image"),
3598                               options->mousewheel_scrolls, &c_options->mousewheel_scrolls);
3599         pref_checkbox_new_int(group, _("Navigation by left or middle click on image"),
3600                               options->image_lm_click_nav, &c_options->image_lm_click_nav);
3601         pref_checkbox_new_int(group, _("Open archive by left click on image"),
3602                               options->image_l_click_archive, &c_options->image_l_click_archive);
3603         pref_checkbox_new_int(group, _("Play video by left click on image"),
3604                               options->image_l_click_video, &c_options->image_l_click_video);
3605         table = pref_table_new(group, 2, 1, FALSE, FALSE);
3606         add_video_menu(table, 0, 0, _("Play with:"), options->image_l_click_video_editor, &c_options->image_l_click_video_editor);
3607
3608         table = pref_table_new(group, 2, 1, FALSE, FALSE);
3609         table = pref_table_new(group, 2, 1, FALSE, FALSE);
3610         add_mouse_selection_menu(table, 0, 0, _("Mouse button Back:"), options->mouse_button_8, &c_options->mouse_button_8);
3611         table = pref_table_new(group, 2, 1, FALSE, FALSE);
3612         add_mouse_selection_menu(table, 0, 0, _("Mouse button Forward:"), options->mouse_button_9, &c_options->mouse_button_9);
3613
3614         pref_spacer(group, PREF_PAD_GROUP);
3615
3616         group = pref_group_new(vbox, FALSE, _("GPU"), GTK_ORIENTATION_VERTICAL);
3617
3618         checkbox = pref_checkbox_new_int(group, _("Override disable GPU"),
3619                                 options->override_disable_gpu, &c_options->override_disable_gpu);
3620         gtk_widget_set_tooltip_text(checkbox, "Contact the developers for usage");
3621
3622 #ifdef DEBUG
3623         pref_spacer(group, PREF_PAD_GROUP);
3624
3625         group = pref_group_new(vbox, FALSE, _("Debugging"), GTK_ORIENTATION_VERTICAL);
3626
3627         pref_spin_new_int(group, _("Debug level:"), NULL,
3628                           DEBUG_LEVEL_MIN, DEBUG_LEVEL_MAX, 1, get_debug_level(), &debug_c);
3629
3630         pref_checkbox_new_int(group, _("Timer data"),
3631                         options->log_window.timer_data, &c_options->log_window.timer_data);
3632
3633         pref_spin_new_int(group, _("Log Window max. lines:"), NULL,
3634                           1, 99999, 1, options->log_window_lines, &options->log_window_lines);
3635 #endif
3636 }
3637
3638 /* accelerators tab */
3639 static void config_tab_accelerators(GtkWidget *notebook)
3640 {
3641         GtkWidget *hbox;
3642         GtkWidget *vbox;
3643         GtkWidget *group;
3644         GtkWidget *button;
3645         GtkWidget *scrolled;
3646         GtkWidget *accel_view;
3647         GtkCellRenderer *renderer;
3648         GtkTreeSelection *selection;
3649         GtkTreeViewColumn *column;
3650
3651         vbox = scrolled_notebook_page(notebook, _("Keyboard"));
3652
3653         group = pref_group_new(vbox, TRUE, _("Accelerators"), GTK_ORIENTATION_VERTICAL);
3654
3655         scrolled = gtk_scrolled_window_new(NULL, NULL);
3656         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
3657         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3658         gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
3659         gtk_widget_show(scrolled);
3660
3661         accel_store = gtk_tree_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
3662
3663         accel_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(accel_store));
3664         g_object_unref(accel_store);
3665         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(accel_view));
3666         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
3667
3668         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(accel_view), FALSE);
3669
3670         renderer = gtk_cell_renderer_text_new();
3671
3672         column = gtk_tree_view_column_new_with_attributes(_("Action"),
3673                                                           renderer,
3674                                                           "text", AE_ACTION,
3675                                                           NULL);
3676
3677         gtk_tree_view_column_set_sort_column_id(column, AE_ACTION);
3678         gtk_tree_view_column_set_resizable(column, TRUE);
3679         gtk_tree_view_append_column(GTK_TREE_VIEW(accel_view), column);
3680
3681
3682         renderer = gtk_cell_renderer_accel_new();
3683         g_signal_connect(G_OBJECT(renderer), "accel-cleared",
3684                          G_CALLBACK(accel_store_cleared_cb), accel_store);
3685         g_signal_connect(G_OBJECT(renderer), "accel-edited",
3686                          G_CALLBACK(accel_store_edited_cb), accel_store);
3687
3688
3689         g_object_set (renderer,
3690                       "editable", TRUE,
3691                       "accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
3692                       NULL);
3693
3694         column = gtk_tree_view_column_new_with_attributes(_("KEY"),
3695                                                           renderer,
3696                                                           "text", AE_KEY,
3697                                                           NULL);
3698
3699         gtk_tree_view_column_set_sort_column_id(column, AE_KEY);
3700         gtk_tree_view_column_set_resizable(column, TRUE);
3701         gtk_tree_view_append_column(GTK_TREE_VIEW(accel_view), column);
3702
3703         renderer = gtk_cell_renderer_text_new();
3704
3705         column = gtk_tree_view_column_new_with_attributes(_("Tooltip"),
3706                                                           renderer,
3707                                                           "text", AE_TOOLTIP,
3708                                                           NULL);
3709
3710         gtk_tree_view_column_set_sort_column_id(column, AE_TOOLTIP);
3711         gtk_tree_view_column_set_resizable(column, TRUE);
3712         gtk_tree_view_append_column(GTK_TREE_VIEW(accel_view), column);
3713
3714         renderer = gtk_cell_renderer_text_new();
3715
3716         column = gtk_tree_view_column_new_with_attributes("Accel",
3717                                                           renderer,
3718                                                           "text", AE_ACCEL,
3719                                                           NULL);
3720
3721         gtk_tree_view_column_set_sort_column_id(column, AE_ACCEL);
3722         gtk_tree_view_column_set_resizable(column, TRUE);
3723         gtk_tree_view_append_column(GTK_TREE_VIEW(accel_view), column);
3724
3725         accel_store_populate();
3726         gtk_container_add(GTK_CONTAINER(scrolled), accel_view);
3727         gtk_widget_show(accel_view);
3728
3729         hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
3730
3731         button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
3732                                  G_CALLBACK(accel_default_cb), accel_view);
3733         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
3734         gtk_widget_show(button);
3735
3736         button = pref_button_new(NULL, NULL, _("Reset selected"), FALSE,
3737                                  G_CALLBACK(accel_reset_cb), accel_view);
3738         gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
3739         gtk_widget_show(button);
3740 }
3741
3742 /* toolbar main tab */
3743 static void config_tab_toolbar_main(GtkWidget *notebook)
3744 {
3745         GtkWidget *vbox;
3746         GtkWidget *toolbardata;
3747         LayoutWindow *lw;
3748
3749         lw = layout_window_list->data;
3750
3751         vbox = scrolled_notebook_page(notebook, _("Toolbar Main"));
3752
3753         toolbardata = toolbar_select_new(lw, TOOLBAR_MAIN);
3754         gtk_box_pack_start(GTK_BOX(vbox), toolbardata, TRUE, TRUE, 0);
3755         gtk_widget_show(vbox);
3756 }
3757
3758 /* toolbar status tab */
3759 static void config_tab_toolbar_status(GtkWidget *notebook)
3760 {
3761         GtkWidget *vbox;
3762         GtkWidget *toolbardata;
3763         LayoutWindow *lw;
3764
3765         lw = layout_window_list->data;
3766
3767         vbox = scrolled_notebook_page(notebook, _("Toolbar Status"));
3768
3769         toolbardata = toolbar_select_new(lw, TOOLBAR_STATUS);
3770         gtk_box_pack_start(GTK_BOX(vbox), toolbardata, TRUE, TRUE, 0);
3771         gtk_widget_show(vbox);
3772 }
3773
3774 /* advanced tab */
3775 static gint extension_sort_cb(gconstpointer a, gconstpointer b)
3776 {
3777         return g_strcmp0((gchar *)a, (gchar *)b);
3778 }
3779
3780 static void config_tab_advanced(GtkWidget *notebook)
3781 {
3782         GtkWidget *vbox;
3783         GtkWidget *group;
3784         GSList *formats_list;
3785         GList *extensions_list = NULL;
3786         gchar **extensions;
3787         GtkWidget *tabcomp;
3788         GdkPixbufFormat *fm;
3789         gint i;
3790         GString *types_string = g_string_new(NULL);
3791         GtkWidget *types_string_label;
3792         GtkWidget *threads_string_label;
3793         GtkWidget *dupes_threads_spin;
3794
3795         vbox = scrolled_notebook_page(notebook, _("Advanced"));
3796         group = pref_group_new(vbox, FALSE, _("External preview extraction"), GTK_ORIENTATION_VERTICAL);
3797
3798         pref_checkbox_new_int(group, _("Use external preview extraction -  Requires restart"), options->external_preview.enable, &c_options->external_preview.enable);
3799
3800         pref_spacer(group, PREF_PAD_GROUP);
3801
3802         formats_list = gdk_pixbuf_get_formats();
3803
3804         while (formats_list)
3805                 {
3806                 fm = formats_list->data;
3807                 extensions = gdk_pixbuf_format_get_extensions(fm);
3808
3809                 i = 0;
3810                 while (extensions[i])
3811                         {
3812                         extensions_list = g_list_insert_sorted(extensions_list, g_strdup(extensions[i]), extension_sort_cb);
3813                         i++;
3814                         }
3815
3816                 g_strfreev(extensions);
3817                 formats_list = formats_list->next;
3818                 }
3819
3820         while (extensions_list)
3821                 {
3822                 if (types_string->len == 0)
3823                         {
3824                         types_string = g_string_append(types_string, extensions_list->data);
3825                         }
3826                 else
3827                         {
3828                         types_string = g_string_append(types_string, ", ");
3829                         types_string = g_string_append(types_string, extensions_list->data);
3830                         }
3831
3832                 extensions_list = extensions_list->next;
3833                 }
3834
3835         types_string = g_string_prepend(types_string, _("Usable file types:\n"));
3836         types_string_label = pref_label_new(group, types_string->str);
3837         gtk_label_set_line_wrap(GTK_LABEL(types_string_label), TRUE);
3838
3839         pref_spacer(group, PREF_PAD_GROUP);
3840
3841         group = pref_group_new(vbox, FALSE, _("File identification tool"), GTK_ORIENTATION_VERTICAL);
3842         external_preview_select_entry = gtk_entry_new();
3843         tabcomp = tab_completion_new(&external_preview_select_entry, options->external_preview.select, NULL, NULL, NULL, NULL);
3844         tab_completion_add_select_button(external_preview_select_entry, _("Select file identification tool"), FALSE);
3845         gtk_box_pack_start(GTK_BOX(group), tabcomp, TRUE, TRUE, 0);
3846         gtk_widget_show(tabcomp);
3847
3848         group = pref_group_new(vbox, FALSE, _("Preview extraction tool"), GTK_ORIENTATION_VERTICAL);
3849         external_preview_extract_entry = gtk_entry_new();
3850         tabcomp = tab_completion_new(&external_preview_extract_entry, options->external_preview.extract, NULL, NULL, NULL, NULL);
3851         tab_completion_add_select_button(external_preview_extract_entry, _("Select preview extraction tool"), FALSE);
3852         gtk_box_pack_start(GTK_BOX(group), tabcomp, TRUE, TRUE, 0);
3853         gtk_widget_show(tabcomp);
3854
3855         gtk_widget_show(vbox);
3856
3857         g_slist_free(formats_list);
3858         string_list_free(extensions_list);
3859         g_string_free(types_string, TRUE);
3860
3861         pref_spacer(group, PREF_PAD_GROUP);
3862
3863         pref_line(vbox, PREF_PAD_SPACE);
3864         group = pref_group_new(vbox, FALSE, _("Thread pool limits"), GTK_ORIENTATION_VERTICAL);
3865
3866         threads_string_label = pref_label_new(group, "This option limits the number of threads (or cpu cores)\nthat Geeqie will use when running duplicate checks. The default value is 0, which means all available cores will be used.");
3867         gtk_label_set_line_wrap(GTK_LABEL(threads_string_label), TRUE);
3868
3869         pref_spacer(vbox, PREF_PAD_GROUP);
3870
3871         dupes_threads_spin = pref_spin_new_int(vbox, _("Duplicate check:"), _("max. threads"), 0, get_cpu_cores(), 1, options->threads.duplicates, &c_options->threads.duplicates);
3872         gtk_widget_set_tooltip_markup(dupes_threads_spin, _("Set to 0 for unlimited"));
3873 }
3874
3875 /* stereo tab */
3876 static void config_tab_stereo(GtkWidget *notebook)
3877 {
3878         GtkWidget *vbox;
3879         GtkWidget *group;
3880         GtkWidget *group2;
3881         GtkWidget *table;
3882         GtkWidget *box;
3883         GtkWidget *box2;
3884         GtkWidget *fs_button;
3885         vbox = scrolled_notebook_page(notebook, _("Stereo"));
3886
3887         group = pref_group_new(vbox, FALSE, _("Windowed stereo mode"), GTK_ORIENTATION_VERTICAL);
3888
3889         table = pref_table_new(group, 2, 1, FALSE, FALSE);
3890         add_stereo_mode_menu(table, 0, 0, _("Windowed stereo mode"), options->stereo.mode, &c_options->stereo.mode, FALSE);
3891
3892         table = pref_table_new(group, 2, 2, TRUE, FALSE);
3893         box = pref_table_box(table, 0, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
3894         pref_checkbox_new_int(box, _("Mirror left image"),
3895                               options->stereo.mode & PR_STEREO_MIRROR_LEFT, &c_options->stereo.tmp.mirror_left);
3896         box = pref_table_box(table, 1, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
3897         pref_checkbox_new_int(box, _("Flip left image"),
3898                               options->stereo.mode & PR_STEREO_FLIP_LEFT, &c_options->stereo.tmp.flip_left);
3899         box = pref_table_box(table, 0, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
3900         pref_checkbox_new_int(box, _("Mirror right image"),
3901                               options->stereo.mode & PR_STEREO_MIRROR_RIGHT, &c_options->stereo.tmp.mirror_right);
3902         box = pref_table_box(table, 1, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
3903         pref_checkbox_new_int(box, _("Flip right image"),
3904                               options->stereo.mode & PR_STEREO_FLIP_RIGHT, &c_options->stereo.tmp.flip_right);
3905         pref_checkbox_new_int(group, _("Swap left and right images"),
3906                               options->stereo.mode & PR_STEREO_SWAP, &c_options->stereo.tmp.swap);
3907         pref_checkbox_new_int(group, _("Disable stereo mode on single image source"),
3908                               options->stereo.mode & PR_STEREO_TEMP_DISABLE, &c_options->stereo.tmp.temp_disable);
3909
3910         group = pref_group_new(vbox, FALSE, _("Fullscreen stereo mode"), GTK_ORIENTATION_VERTICAL);
3911         fs_button = pref_checkbox_new_int(group, _("Use different settings for fullscreen"),
3912                               options->stereo.enable_fsmode, &c_options->stereo.enable_fsmode);
3913         box2 = pref_box_new(group, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_SPACE);
3914         pref_checkbox_link_sensitivity(fs_button, box2);
3915         table = pref_table_new(box2, 2, 1, FALSE, FALSE);
3916         add_stereo_mode_menu(table, 0, 0, _("Fullscreen stereo mode"), options->stereo.fsmode, &c_options->stereo.fsmode, TRUE);
3917         table = pref_table_new(box2, 2, 2, TRUE, FALSE);
3918         box = pref_table_box(table, 0, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
3919         pref_checkbox_new_int(box, _("Mirror left image"),
3920                               options->stereo.fsmode & PR_STEREO_MIRROR_LEFT, &c_options->stereo.tmp.fs_mirror_left);
3921         box = pref_table_box(table, 1, 0, GTK_ORIENTATION_HORIZONTAL, NULL);
3922         pref_checkbox_new_int(box, _("Flip left image"),
3923                               options->stereo.fsmode & PR_STEREO_FLIP_LEFT, &c_options->stereo.tmp.fs_flip_left);
3924         box = pref_table_box(table, 0, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
3925         pref_checkbox_new_int(box, _("Mirror right image"),
3926                               options->stereo.fsmode & PR_STEREO_MIRROR_RIGHT, &c_options->stereo.tmp.fs_mirror_right);
3927         box = pref_table_box(table, 1, 1, GTK_ORIENTATION_HORIZONTAL, NULL);
3928         pref_checkbox_new_int(box, _("Flip right image"),
3929                               options->stereo.fsmode & PR_STEREO_FLIP_RIGHT, &c_options->stereo.tmp.fs_flip_right);
3930         pref_checkbox_new_int(box2, _("Swap left and right images"),
3931                               options->stereo.fsmode & PR_STEREO_SWAP, &c_options->stereo.tmp.fs_swap);
3932         pref_checkbox_new_int(box2, _("Disable stereo mode on single image source"),
3933                               options->stereo.fsmode & PR_STEREO_TEMP_DISABLE, &c_options->stereo.tmp.fs_temp_disable);
3934
3935         group2 = pref_group_new(box2, FALSE, _("Fixed position"), GTK_ORIENTATION_VERTICAL);
3936         table = pref_table_new(group2, 5, 3, FALSE, FALSE);
3937         pref_table_spin_new_int(table, 0, 0, _("Width"), NULL,
3938                           1, 5000, 1, options->stereo.fixed_w, &c_options->stereo.fixed_w);
3939         pref_table_spin_new_int(table, 3, 0,  _("Height"), NULL,
3940                           1, 5000, 1, options->stereo.fixed_h, &c_options->stereo.fixed_h);
3941         pref_table_spin_new_int(table, 0, 1,  _("Left X"), NULL,
3942                           0, 5000, 1, options->stereo.fixed_x1, &c_options->stereo.fixed_x1);
3943         pref_table_spin_new_int(table, 3, 1,  _("Left Y"), NULL,
3944                           0, 5000, 1, options->stereo.fixed_y1, &c_options->stereo.fixed_y1);
3945         pref_table_spin_new_int(table, 0, 2,  _("Right X"), NULL,
3946                           0, 5000, 1, options->stereo.fixed_x2, &c_options->stereo.fixed_x2);
3947         pref_table_spin_new_int(table, 3, 2,  _("Right Y"), NULL,
3948                           0, 5000, 1, options->stereo.fixed_y2, &c_options->stereo.fixed_y2);
3949
3950 }
3951
3952 /* Main preferences window */
3953 static void config_window_create(LayoutWindow *lw)
3954 {
3955         GtkWidget *win_vbox;
3956         GtkWidget *hbox;
3957         GtkWidget *notebook;
3958         GtkWidget *button;
3959         GtkWidget *ct_button;
3960
3961         if (!c_options) c_options = init_options(NULL);
3962
3963         configwindow = window_new(GTK_WINDOW_TOPLEVEL, "preferences", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Preferences"));
3964         DEBUG_NAME(configwindow);
3965         gtk_window_set_type_hint(GTK_WINDOW(configwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
3966         g_signal_connect(G_OBJECT(configwindow), "delete_event",
3967                          G_CALLBACK(config_window_delete), NULL);
3968         if (options->save_dialog_window_positions)
3969                 {
3970                 gtk_window_resize(GTK_WINDOW(configwindow), lw->options.preferences_window.w, lw->options.preferences_window.h);
3971                 gtk_window_move(GTK_WINDOW(configwindow), lw->options.preferences_window.x, lw->options.preferences_window.y);
3972                 }
3973         else
3974                 {
3975                 gtk_window_set_default_size(GTK_WINDOW(configwindow), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
3976                 }
3977         gtk_window_set_resizable(GTK_WINDOW(configwindow), TRUE);
3978         gtk_container_set_border_width(GTK_CONTAINER(configwindow), PREF_PAD_BORDER);
3979
3980         win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
3981         gtk_container_add(GTK_CONTAINER(configwindow), win_vbox);
3982         gtk_widget_show(win_vbox);
3983
3984         notebook = gtk_notebook_new();
3985         gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT);
3986         gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
3987         gtk_box_pack_start(GTK_BOX(win_vbox), notebook, TRUE, TRUE, 0);
3988
3989         config_tab_general(notebook);
3990         config_tab_image(notebook);
3991         config_tab_osd(notebook);
3992         config_tab_windows(notebook);
3993         config_tab_accelerators(notebook);
3994         config_tab_files(notebook);
3995         config_tab_metadata(notebook);
3996         config_tab_keywords(notebook);
3997         config_tab_color(notebook);
3998         config_tab_stereo(notebook);
3999         config_tab_behavior(notebook);
4000         config_tab_toolbar_main(notebook);
4001         config_tab_toolbar_status(notebook);
4002         config_tab_advanced(notebook);
4003
4004         gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), lw->options.preferences_window.page_number);
4005
4006         hbox = gtk_hbutton_box_new();
4007         gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
4008         gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
4009         gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
4010         gtk_widget_show(hbox);
4011
4012         button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
4013                                  G_CALLBACK(config_window_help_cb), notebook);
4014         gtk_container_add(GTK_CONTAINER(hbox), button);
4015         gtk_widget_set_can_default(button, TRUE);
4016         gtk_widget_show(button);
4017
4018         button = pref_button_new(NULL, GTK_STOCK_OK, NULL, FALSE,
4019                                  G_CALLBACK(config_window_ok_cb), notebook);
4020         gtk_container_add(GTK_CONTAINER(hbox), button);
4021         gtk_widget_set_can_default(button, TRUE);
4022         gtk_widget_grab_default(button);
4023         gtk_widget_show(button);
4024
4025         ct_button = button;
4026
4027         button = pref_button_new(NULL, GTK_STOCK_CANCEL, NULL, FALSE,
4028                                  G_CALLBACK(config_window_close_cb), NULL);
4029         gtk_container_add(GTK_CONTAINER(hbox), button);
4030         gtk_widget_set_can_default(button, TRUE);
4031         gtk_widget_show(button);
4032
4033         if (!generic_dialog_get_alternative_button_order(configwindow))
4034                 {
4035                 gtk_box_reorder_child(GTK_BOX(hbox), ct_button, -1);
4036                 }
4037
4038         gtk_widget_show(notebook);
4039
4040         gtk_widget_show(configwindow);
4041 }
4042
4043 /*
4044  *-----------------------------------------------------------------------------
4045  * config window show (public)
4046  *-----------------------------------------------------------------------------
4047  */
4048
4049 void show_config_window(LayoutWindow *lw)
4050 {
4051         if (configwindow)
4052                 {
4053                 gtk_window_present(GTK_WINDOW(configwindow));
4054                 return;
4055                 }
4056
4057         config_window_create(lw);
4058 }
4059
4060 /*
4061  *-----------------
4062  * about window
4063  *-----------------
4064  */
4065
4066 void show_about_window(LayoutWindow *lw)
4067 {
4068         GdkPixbuf *pixbuf_logo;
4069         GdkPixbuf *pixbuf_icon;
4070         gchar *authors[1000];
4071         gchar *comment;
4072         gint i_authors = 0;
4073         gchar *path;
4074         GString *copyright;
4075         gchar *timezone_path;
4076         ZoneDetect *cd;
4077         FILE *fp = NULL;
4078 #define LINE_LENGTH 1000
4079         gchar line[LINE_LENGTH];
4080
4081         copyright = g_string_new(NULL);
4082         copyright = g_string_append(copyright, "This program comes with absolutely no warranty.\nGNU General Public License, version 2 or later.\nSee https://www.gnu.org/licenses/old-licenses/gpl-2.0.html\n\n");
4083
4084         timezone_path = g_build_filename(get_rc_dir(), TIMEZONE_DATABASE_FILE, NULL);
4085         if (g_file_test(timezone_path, G_FILE_TEST_EXISTS))
4086                 {
4087                 cd = ZDOpenDatabase(timezone_path);
4088                 if (cd)
4089                         {
4090                         copyright = g_string_append(copyright, ZDGetNotice(cd));
4091                         }
4092                 else
4093                         {
4094                         log_printf("Error: Init of timezone database %s failed\n", timezone_path);
4095                         }
4096                 ZDCloseDatabase(cd);
4097                 }
4098         g_free(timezone_path);
4099
4100         authors[0] = NULL;
4101         path = g_build_filename(gq_helpdir, "AUTHORS", NULL);
4102         fp = fopen(path, "r");
4103         if (fp)
4104                 {
4105                 while(fgets(line, LINE_LENGTH, fp))
4106                         {
4107                         /* get rid of ending \n from fgets */
4108                         line[strlen(line) - 1] = '\0';
4109                         authors[i_authors] = g_strdup(line);
4110                         i_authors++;
4111                         }
4112                 authors[i_authors] = NULL;
4113                 fclose(fp);
4114                 }
4115         g_free(path);
4116
4117         comment = g_strconcat("Development and bug reports:\n", GQ_EMAIL_ADDRESS,
4118                                                 "\nhttps://github.com/BestImageViewer/geeqie/issues",NULL);
4119
4120         pixbuf_logo = pixbuf_inline(PIXBUF_INLINE_LOGO);
4121         pixbuf_icon = pixbuf_inline(PIXBUF_INLINE_ICON);
4122         gtk_show_about_dialog(GTK_WINDOW(lw->window),
4123                 "title", _("About Geeqie"),
4124                 "resizable", TRUE,
4125                 "program-name", GQ_APPNAME,
4126                 "version", VERSION,
4127                 "logo", pixbuf_logo,
4128                 "icon", pixbuf_icon,
4129                 "website", GQ_WEBSITE,
4130                 "website-label", "Website",
4131                 "comments", comment,
4132                 "authors", authors,
4133                 "translator-credits", _("translator-credits"),
4134                 "wrap-license", TRUE,
4135                 "license", copyright->str,
4136                 NULL);
4137
4138         g_string_free(copyright, TRUE);
4139
4140         gint n = 0;
4141         while(n < i_authors)
4142                 {
4143                 g_free(authors[n]);
4144                 n++;
4145                 }
4146         g_free(comment);
4147
4148         return;
4149 }
4150
4151 static void image_overlay_set_text_colours()
4152 {
4153         c_options->image_overlay.text_red = options->image_overlay.text_red;
4154         c_options->image_overlay.text_green = options->image_overlay.text_green;
4155         c_options->image_overlay.text_blue = options->image_overlay.text_blue;
4156         c_options->image_overlay.text_alpha = options->image_overlay.text_alpha;
4157         c_options->image_overlay.background_red = options->image_overlay.background_red;
4158         c_options->image_overlay.background_green = options->image_overlay.background_green;
4159         c_options->image_overlay.background_blue = options->image_overlay.background_blue;
4160         c_options->image_overlay.background_alpha = options->image_overlay.background_alpha;
4161 }
4162
4163 /*
4164  *-----------------------------------------------------------------------------
4165  * timezone database routines
4166  *-----------------------------------------------------------------------------
4167  */
4168
4169 static void timezone_async_ready_cb(GObject *source_object, GAsyncResult *res, gpointer data)
4170 {
4171         GError *error = NULL;
4172         TZData *tz = data;
4173         gchar *tmp_filename;
4174         gchar *timezone_bin;
4175         gchar *tmp_dir = NULL;
4176         FileData *fd;
4177
4178         if (!g_cancellable_is_cancelled(tz->cancellable))
4179                 {
4180                 generic_dialog_close(tz->gd);
4181                 }
4182
4183
4184         if (g_file_copy_finish(G_FILE(source_object), res, &error))
4185                 {
4186                 tmp_filename = g_file_get_path(tz->tmp_g_file);
4187                 fd = file_data_new_simple(tmp_filename);
4188                 tmp_dir = open_archive(fd);
4189
4190                 if (tmp_dir)
4191                         {
4192                         timezone_bin = g_build_filename(tmp_dir, TIMEZONE_DATABASE_VERSION, TIMEZONE_DATABASE_FILE, NULL);
4193                         if (isfile(timezone_bin))
4194                                 {
4195                                 move_file(timezone_bin, tz->timezone_database_user);
4196                                 }
4197                         else
4198                                 {
4199                                 warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
4200                                 }
4201
4202                         g_free(timezone_bin);
4203                         g_free(tmp_dir); // The folder in /tmp is deleted in exit_program_final()
4204                         }
4205                 else
4206                         {
4207                         warning_dialog(_("Warning: Cannot open timezone database file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
4208                         }
4209                 g_free(tmp_filename);
4210                 file_data_unref(fd);
4211                 }
4212         else
4213                 {
4214                 file_util_warning_dialog(_("Error: Timezone database download failed"), error->message, GTK_STOCK_DIALOG_ERROR, NULL);
4215                 }
4216
4217         g_file_delete(tz->tmp_g_file, NULL, &error);
4218         g_object_unref(tz->tmp_g_file);
4219         tz->tmp_g_file = NULL;
4220         g_object_unref(tz->cancellable);
4221         g_object_unref(tz->timezone_database_gq);
4222 }
4223
4224 static void timezone_progress_cb(goffset current_num_bytes, goffset total_num_bytes, gpointer data)
4225 {
4226         TZData *tz = data;
4227
4228         if (!g_cancellable_is_cancelled(tz->cancellable))
4229                 {
4230                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(tz->progress), (gdouble)current_num_bytes / total_num_bytes);
4231                 }
4232 }
4233
4234 static void timezone_cancel_button_cb(GenericDialog *gd, gpointer data)
4235 {
4236         TZData *tz = data;
4237
4238         g_cancellable_cancel(tz->cancellable);
4239 }
4240
4241 static void timezone_database_install_cb(GtkWidget *widget, gpointer data)
4242 {
4243         TZData *tz = data;
4244         GError *error = NULL;
4245         GFileIOStream *io_stream;
4246
4247         if (tz->tmp_g_file)
4248                 {
4249                 return;
4250                 }
4251
4252         tz->tmp_g_file = g_file_new_tmp("geeqie_timezone_XXXXXX", &io_stream, &error);
4253
4254         if (error)
4255                 {
4256                 file_util_warning_dialog(_("Timezone database download failed"), error->message, GTK_STOCK_DIALOG_ERROR, NULL);
4257                 log_printf("Error: Download timezone database failed:\n%s", error->message);
4258                 g_error_free(error);
4259                 g_object_unref(tz->tmp_g_file);
4260                 }
4261         else
4262                 {
4263                 tz->timezone_database_gq = g_file_new_for_uri(TIMEZONE_DATABASE_WEB);
4264
4265                 tz->gd = generic_dialog_new(_("Timezone database"), "download_timezone_database", NULL, TRUE, timezone_cancel_button_cb, tz);
4266
4267                 generic_dialog_add_message(tz->gd, GTK_STOCK_DIALOG_INFO, _("Downloading timezone database"), NULL, FALSE);
4268
4269                 tz->progress = gtk_progress_bar_new();
4270                 gtk_box_pack_start(GTK_BOX(tz->gd->vbox), tz->progress, FALSE, FALSE, 0);
4271                 gtk_widget_show(tz->progress);
4272
4273                 gtk_widget_show(tz->gd->dialog);
4274                 tz->cancellable = g_cancellable_new();
4275                 g_file_copy_async(tz->timezone_database_gq, tz->tmp_g_file, G_FILE_COPY_OVERWRITE, G_PRIORITY_LOW, tz->cancellable, timezone_progress_cb, tz, timezone_async_ready_cb, tz);
4276
4277                 gtk_button_set_label(GTK_BUTTON(widget), _("Update"));
4278                 }
4279 }
4280 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */