src/layout-util.cc

   1 /*
   2  * Copyright (C) 2004 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 "layout-util.h"
  24
  25 #include "advanced-exif.h"
  26 #include "bar-sort.h"
  27 #include "bar.h"
  28 #include "bar-keywords.h"
  29 #include "cache-maint.h"
  30 #include "collect.h"
  31 #include "collect-dlg.h"
  32 #include "color-man.h"
  33 #include "dupe.h"
  34 #include "editors.h"
  35 #include "history-list.h"
  36 #include "image.h"
  37 #include "image-overlay.h"
  38 #include "histogram.h"
  39 #include "img-view.h"
  40 #include "layout-image.h"
  41 #include "logwindow.h"
  42 #include "misc.h"
  43 #include "pan-view.h"
  44 #include "pixbuf-util.h"
  45 #include "preferences.h"
  46 #include "print.h"
  47 #include "rcfile.h"
  48 #include "search.h"
  49 #include "search-and-run.h"
  50 #include "slideshow.h"
  51 #include "ui-fileops.h"
  52 #include "ui-menu.h"
  53 #include "ui-misc.h"
  54 #include "utilops.h"
  55 #include "view-dir.h"
  56 #include "view-file.h"
  57 #include "window.h"
  58 #include "metadata.h"
  59 #include "desktop-file.h"
  60
  61 #include <sys/wait.h>
  62 #include "keymap-template.h"
  63
  64 #define MENU_EDIT_ACTION_OFFSET 16
  65 #define FILE_COLUMN_POINTER 0
  66
  67 static gboolean layout_bar_enabled(LayoutWindow *lw);
  68 static gboolean layout_bar_sort_enabled(LayoutWindow *lw);
  69 static void layout_bars_hide_toggle(LayoutWindow *lw);
  70 static void layout_util_sync_views(LayoutWindow *lw);
  71 static void layout_search_and_run_window_new(LayoutWindow *lw);
  72
  73 /*
  74  *-----------------------------------------------------------------------------
  75  * keyboard handler
  76  *-----------------------------------------------------------------------------
  77  */
  78
  79 static guint tree_key_overrides[] = {
  80         GDK_KEY_Page_Up,        GDK_KEY_KP_Page_Up,
  81         GDK_KEY_Page_Down,      GDK_KEY_KP_Page_Down,
  82         GDK_KEY_Home,   GDK_KEY_KP_Home,
  83         GDK_KEY_End,    GDK_KEY_KP_End
  84 };
  85
  86 static gboolean layout_key_match(guint keyval)
  87 {
  88         guint i;
  89
  90         for (i = 0; i < sizeof(tree_key_overrides) / sizeof(guint); i++)
  91                 {
  92                 if (keyval == tree_key_overrides[i]) return TRUE;
  93                 }
  94
  95         return FALSE;
  96 }
  97
  98 gboolean layout_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
  99 {
 100         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 101         GtkWidget *focused;
 102         gboolean stop_signal = FALSE;
 103         gint x = 0;
 104         gint y = 0;
 105
 106         if (lw->path_entry && gtk_widget_has_focus(lw->path_entry))
 107                 {
 108                 if (event->keyval == GDK_KEY_Escape && lw->dir_fd)
 109                         {
 110                         gtk_entry_set_text(GTK_ENTRY(lw->path_entry), lw->dir_fd->path);
 111                         }
 112
 113                 /* the gtkaccelgroup of the window is stealing presses before they get to the entry (and more),
 114                  * so when the some widgets have focus, give them priority (HACK)
 115                  */
 116                 if (gtk_widget_event(lw->path_entry, (GdkEvent *)event))
 117                         {
 118                         return TRUE;
 119                         }
 120                 }
 121
 122         if (lw->vf->file_filter.combo && gtk_widget_has_focus(gtk_bin_get_child(GTK_BIN(lw->vf->file_filter.combo))))
 123                 {
 124                 if (gtk_widget_event(gtk_bin_get_child(GTK_BIN(lw->vf->file_filter.combo)), (GdkEvent *)event))
 125                         {
 126                         return TRUE;
 127                         }
 128                 }
 129
 130         if (lw->vd && lw->options.dir_view_type == DIRVIEW_TREE && gtk_widget_has_focus(lw->vd->view) &&
 131             !layout_key_match(event->keyval) &&
 132             gtk_widget_event(lw->vd->view, (GdkEvent *)event))
 133                 {
 134                 return TRUE;
 135                 }
 136         if (lw->bar &&
 137             bar_event(lw->bar, (GdkEvent *)event))
 138                 {
 139                 return TRUE;
 140                 }
 141
 142         focused = gtk_container_get_focus_child(GTK_CONTAINER(lw->image->widget));
 143         if (lw->image &&
 144             ((focused && gtk_widget_has_focus(focused)) || (lw->tools && widget == lw->window) || lw->full_screen) )
 145                 {
 146                 stop_signal = TRUE;
 147                 switch (event->keyval)
 148                         {
 149                         case GDK_KEY_Left: case GDK_KEY_KP_Left:
 150                                 x -= 1;
 151                                 break;
 152                         case GDK_KEY_Right: case GDK_KEY_KP_Right:
 153                                 x += 1;
 154                                 break;
 155                         case GDK_KEY_Up: case GDK_KEY_KP_Up:
 156                                 y -= 1;
 157                                 break;
 158                         case GDK_KEY_Down: case GDK_KEY_KP_Down:
 159                                 y += 1;
 160                                 break;
 161                         default:
 162                                 stop_signal = FALSE;
 163                                 break;
 164                         }
 165
 166                 if (!stop_signal &&
 167                     !(event->state & GDK_CONTROL_MASK))
 168                         {
 169                         stop_signal = TRUE;
 170                         switch (event->keyval)
 171                                 {
 172                                 case GDK_KEY_Menu:
 173                                         layout_image_menu_popup(lw);
 174                                         break;
 175                                 default:
 176                                         stop_signal = FALSE;
 177                                         break;
 178                                 }
 179                         }
 180                 }
 181
 182         if (x != 0 || y!= 0)
 183                 {
 184                 if (event->state & GDK_SHIFT_MASK)
 185                         {
 186                         x *= 3;
 187                         y *= 3;
 188                         }
 189                 keyboard_scroll_calc(&x, &y, event);
 190                 layout_image_scroll(lw, x, y, (event->state & GDK_SHIFT_MASK));
 191                 }
 192
 193         return stop_signal;
 194 }
 195
 196 void layout_keyboard_init(LayoutWindow *lw, GtkWidget *window)
 197 {
 198         g_signal_connect(G_OBJECT(window), "key_press_event",
 199                          G_CALLBACK(layout_key_press_cb), lw);
 200 }
 201
 202 /*
 203  *-----------------------------------------------------------------------------
 204  * menu callbacks
 205  *-----------------------------------------------------------------------------
 206  */
 207
 208
 209 static GtkWidget *layout_window(LayoutWindow *lw)
 210 {
 211         return lw->full_screen ? lw->full_screen->window : lw->window;
 212 }
 213
 214 static void layout_exit_fullscreen(LayoutWindow *lw)
 215 {
 216         if (!lw->full_screen) return;
 217         layout_image_full_screen_stop(lw);
 218 }
 219
 220 static void clear_marks_cancel_cb(GenericDialog *gd, gpointer UNUSED(data))
 221 {
 222         generic_dialog_close(gd);
 223 }
 224
 225 static void clear_marks_help_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
 226 {
 227         help_window_show("GuideMainWindowMenus.html");
 228 }
 229
 230 void layout_menu_clear_marks_ok_cb(GenericDialog *gd, gpointer UNUSED(data))
 231 {
 232         marks_clear_all();
 233         generic_dialog_close(gd);
 234 }
 235
 236 static void layout_menu_clear_marks_cb(GtkAction *UNUSED(action), gpointer UNUSED(data))
 237 {
 238         GenericDialog *gd;
 239
 240         gd = generic_dialog_new(_("Clear Marks"),
 241                                 "marks_clear", NULL, FALSE, clear_marks_cancel_cb, NULL);
 242         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION, "Clear all marks?",
 243                                 "This will clear all marks for all images,\nincluding those linked to keywords",
 244                                 TRUE);
 245         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, layout_menu_clear_marks_ok_cb, TRUE);
 246         generic_dialog_add_button(gd, GTK_STOCK_HELP, NULL,
 247                                 clear_marks_help_cb, FALSE);
 248
 249         gtk_widget_show(gd->dialog);
 250 }
 251
 252 static void layout_menu_new_cb(GtkAction *UNUSED(action), gpointer data)
 253 {
 254         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 255
 256         layout_exit_fullscreen(lw);
 257         collection_window_new(NULL);
 258 }
 259
 260 static void layout_menu_open_cb(GtkAction *UNUSED(action), gpointer data)
 261 {
 262         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 263
 264         layout_exit_fullscreen(lw);
 265         collection_dialog_load(NULL);
 266 }
 267
 268 static void layout_menu_search_cb(GtkAction *UNUSED(action), gpointer data)
 269 {
 270         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 271
 272         layout_exit_fullscreen(lw);
 273         search_new(lw->dir_fd, layout_image_get_fd(lw));
 274 }
 275
 276 static void layout_menu_dupes_cb(GtkAction *UNUSED(action), gpointer data)
 277 {
 278         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 279
 280         layout_exit_fullscreen(lw);
 281         dupe_window_new();
 282 }
 283
 284 static void layout_menu_pan_cb(GtkAction *UNUSED(action), gpointer data)
 285 {
 286         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 287
 288         layout_exit_fullscreen(lw);
 289         pan_window_new(lw->dir_fd);
 290 }
 291
 292 static void layout_menu_print_cb(GtkAction *UNUSED(action), gpointer data)
 293 {
 294         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 295
 296         print_window_new(layout_image_get_fd(lw), layout_selection_list(lw), layout_list(lw), layout_window(lw));
 297 }
 298
 299 static void layout_menu_dir_cb(GtkAction *UNUSED(action), gpointer data)
 300 {
 301         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 302
 303         if (lw->vd) vd_new_folder(lw->vd, lw->dir_fd);
 304 }
 305
 306 static void layout_menu_copy_cb(GtkAction *UNUSED(action), gpointer data)
 307 {
 308         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 309
 310         file_util_copy(NULL, layout_selection_list(lw), NULL, layout_window(lw));
 311 }
 312
 313 static void layout_menu_copy_path_cb(GtkAction *UNUSED(action), gpointer data)
 314 {
 315         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 316
 317         file_util_copy_path_list_to_clipboard(layout_selection_list(lw), TRUE);
 318 }
 319
 320 static void layout_menu_copy_path_unquoted_cb(GtkAction *UNUSED(action), gpointer data)
 321 {
 322         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 323
 324         file_util_copy_path_list_to_clipboard(layout_selection_list(lw), FALSE);
 325 }
 326
 327 static void layout_menu_move_cb(GtkAction *UNUSED(action), gpointer data)
 328 {
 329         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 330
 331         file_util_move(NULL, layout_selection_list(lw), NULL, layout_window(lw));
 332 }
 333
 334 static void layout_menu_rename_cb(GtkAction *UNUSED(action), gpointer data)
 335 {
 336         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 337
 338         file_util_rename(NULL, layout_selection_list(lw), layout_window(lw));
 339 }
 340
 341 static void layout_menu_delete_cb(GtkAction *UNUSED(action), gpointer data)
 342 {
 343         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 344
 345         options->file_ops.safe_delete_enable = FALSE;
 346         file_util_delete(NULL, layout_selection_list(lw), layout_window(lw));
 347 }
 348
 349 static void layout_menu_move_to_trash_cb(GtkAction *UNUSED(action), gpointer data)
 350 {
 351         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 352
 353         options->file_ops.safe_delete_enable = TRUE;
 354         file_util_delete(NULL, layout_selection_list(lw), layout_window(lw));
 355 }
 356
 357 static void layout_menu_move_to_trash_key_cb(GtkAction *UNUSED(action), gpointer data)
 358 {
 359         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 360
 361         if (options->file_ops.enable_delete_key)
 362                 {
 363                 options->file_ops.safe_delete_enable = TRUE;
 364                 file_util_delete(NULL, layout_selection_list(lw), layout_window(lw));
 365                 }
 366 }
 367
 368 static void layout_menu_disable_grouping_cb(GtkAction *UNUSED(action), gpointer data)
 369 {
 370         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 371
 372         file_data_disable_grouping_list(layout_selection_list(lw), TRUE);
 373 }
 374
 375 static void layout_menu_enable_grouping_cb(GtkAction *UNUSED(action), gpointer data)
 376 {
 377         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 378
 379         file_data_disable_grouping_list(layout_selection_list(lw), FALSE);
 380 }
 381
 382 void layout_menu_close_cb(GtkAction *UNUSED(action), gpointer data)
 383 {
 384         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 385
 386         layout_exit_fullscreen(lw);
 387         layout_close(lw);
 388 }
 389
 390 static void layout_menu_exit_cb(GtkAction *UNUSED(action), gpointer UNUSED(data))
 391 {
 392         exit_program();
 393 }
 394
 395 static void layout_menu_alter_90_cb(GtkAction *UNUSED(action), gpointer data)
 396 {
 397         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 398
 399         layout_image_alter_orientation(lw, ALTER_ROTATE_90);
 400 }
 401
 402 static void layout_menu_rating_0_cb(GtkAction *UNUSED(action), gpointer data)
 403 {
 404         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 405
 406         layout_image_rating(lw, "0");
 407 }
 408
 409 static void layout_menu_rating_1_cb(GtkAction *UNUSED(action), gpointer data)
 410 {
 411         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 412
 413         layout_image_rating(lw, "1");
 414 }
 415
 416 static void layout_menu_rating_2_cb(GtkAction *UNUSED(action), gpointer data)
 417 {
 418         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 419
 420         layout_image_rating(lw, "2");
 421 }
 422
 423 static void layout_menu_rating_3_cb(GtkAction *UNUSED(action), gpointer data)
 424 {
 425         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 426
 427         layout_image_rating(lw, "3");
 428 }
 429
 430 static void layout_menu_rating_4_cb(GtkAction *UNUSED(action), gpointer data)
 431 {
 432         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 433
 434         layout_image_rating(lw, "4");
 435 }
 436
 437 static void layout_menu_rating_5_cb(GtkAction *UNUSED(action), gpointer data)
 438 {
 439         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 440
 441         layout_image_rating(lw, "5");
 442 }
 443
 444 static void layout_menu_rating_m1_cb(GtkAction *UNUSED(action), gpointer data)
 445 {
 446         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 447
 448         layout_image_rating(lw, "-1");
 449 }
 450
 451 static void layout_menu_alter_90cc_cb(GtkAction *UNUSED(action), gpointer data)
 452 {
 453         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 454
 455         layout_image_alter_orientation(lw, ALTER_ROTATE_90_CC);
 456 }
 457
 458 static void layout_menu_alter_180_cb(GtkAction *UNUSED(action), gpointer data)
 459 {
 460         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 461
 462         layout_image_alter_orientation(lw, ALTER_ROTATE_180);
 463 }
 464
 465 static void layout_menu_alter_mirror_cb(GtkAction *UNUSED(action), gpointer data)
 466 {
 467         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 468
 469         layout_image_alter_orientation(lw, ALTER_MIRROR);
 470 }
 471
 472 static void layout_menu_alter_flip_cb(GtkAction *UNUSED(action), gpointer data)
 473 {
 474         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 475
 476         layout_image_alter_orientation(lw, ALTER_FLIP);
 477 }
 478
 479 static void layout_menu_alter_desaturate_cb(GtkToggleAction *action, gpointer data)
 480 {
 481         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 482
 483         layout_image_set_desaturate(lw, gtk_toggle_action_get_active(action));
 484 }
 485
 486 static void layout_menu_alter_ignore_alpha_cb(GtkToggleAction *action, gpointer data)
 487 {
 488    LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 489
 490         if (lw->options.ignore_alpha == gtk_toggle_action_get_active(action)) return;
 491
 492    layout_image_set_ignore_alpha(lw, gtk_toggle_action_get_active(action));
 493 }
 494
 495 static void layout_menu_alter_none_cb(GtkAction *UNUSED(action), gpointer data)
 496 {
 497         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 498
 499         layout_image_alter_orientation(lw, ALTER_NONE);
 500 }
 501
 502 static void layout_menu_exif_rotate_cb(GtkToggleAction *action, gpointer data)
 503 {
 504         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 505
 506         options->image.exif_rotate_enable = gtk_toggle_action_get_active(action);
 507         layout_image_reset_orientation(lw);
 508 }
 509
 510 static void layout_menu_select_rectangle_cb(GtkToggleAction *action, gpointer UNUSED(data))
 511 {
 512         options->draw_rectangle = gtk_toggle_action_get_active(action);
 513 }
 514
 515 static void layout_menu_split_pane_sync_cb(GtkToggleAction *action, gpointer data)
 516 {
 517         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 518
 519         lw->options.split_pane_sync = gtk_toggle_action_get_active(action);
 520 }
 521
 522 static void layout_menu_select_overunderexposed_cb(GtkToggleAction *action, gpointer data)
 523 {
 524         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 525
 526         layout_image_set_overunderexposed(lw, gtk_toggle_action_get_active(action));
 527 }
 528
 529 static void layout_menu_write_rotate(GtkToggleAction *UNUSED(action), gpointer data, gboolean keep_date)
 530 {
 531         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 532         GtkTreeModel *store;
 533         GList *work;
 534         GtkTreeSelection *selection;
 535         GtkTreePath *tpath;
 536         FileData *fd_n;
 537         GtkTreeIter iter;
 538         gchar *rotation;
 539         gchar *command;
 540         gint run_result;
 541         GenericDialog *gd;
 542         GString *message;
 543         int cmdstatus;
 544
 545         if (!layout_valid(&lw)) return;
 546
 547         if (!lw || !lw->vf) return;
 548
 549         if (lw->vf->type == FILEVIEW_ICON)
 550                 {
 551                 if (!VFICON(lw->vf)->selection) return;
 552                 work = VFICON(lw->vf)->selection;
 553                 }
 554         else
 555                 {
 556                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(lw->vf->listview));
 557                 work = gtk_tree_selection_get_selected_rows(selection, &store);
 558                 }
 559
 560         while (work)
 561                 {
 562                 if (lw->vf->type == FILEVIEW_ICON)
 563                         {
 564                         fd_n = static_cast<FileData *>(work->data);
 565                         work = work->next;
 566                         }
 567                 else
 568                         {
 569                         tpath = static_cast<GtkTreePath *>(work->data);
 570                         gtk_tree_model_get_iter(store, &iter, tpath);
 571                         gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &fd_n, -1);
 572                         work = work->next;
 573                         }
 574
 575                 rotation = g_strdup_printf("%d", fd_n->user_orientation);
 576                 command = g_strconcat(gq_bindir, "/geeqie-rotate -r ", rotation,
 577                                                                 keep_date ? " -t \"" : " \"", fd_n->path, "\"", NULL);
 578                 cmdstatus = runcmd(command);
 579                 run_result = WEXITSTATUS(cmdstatus);
 580                 if (!run_result)
 581                         {
 582                         fd_n->user_orientation = 0;
 583                         }
 584                 else
 585                         {
 586                         message = g_string_new("");
 587                         message = g_string_append(message, _("Operation failed:\n"));
 588
 589                         if (run_result == 1)
 590                                 message = g_string_append(message, _("No file extension\n"));
 591                         else if (run_result == 3)
 592                                 message = g_string_append(message, _("Cannot create tmp file\n"));
 593                         else if (run_result == 4)
 594                                 message = g_string_append(message, _("Operation not supported for filetype\n"));
 595                         else if (run_result == 5)
 596                                 message = g_string_append(message, _("File is not writable\n"));
 597                         else if (run_result == 6)
 598                                 message = g_string_append(message, _("Exiftran error\n"));
 599                         else if (run_result == 7)
 600                                 message = g_string_append(message, _("Mogrify error\n"));
 601
 602                         message = g_string_append(message, fd_n->name);
 603
 604                         gd = generic_dialog_new(_("Image orientation"),
 605                         "Image orientation", NULL, TRUE, NULL, NULL);
 606                         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_ERROR,
 607                         "Image orientation", message->str, TRUE);
 608                         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, NULL, TRUE);
 609
 610                         gtk_widget_show(gd->dialog);
 611
 612                         g_string_free(message, TRUE);
 613                         }
 614
 615                 g_free(rotation);
 616                 g_free(command);
 617                 }
 618 }
 619
 620 static void layout_menu_write_rotate_keep_date_cb(GtkToggleAction *action, gpointer data)
 621 {
 622         layout_menu_write_rotate(action, data, TRUE);
 623 }
 624
 625 static void layout_menu_write_rotate_cb(GtkToggleAction *action, gpointer data)
 626 {
 627         layout_menu_write_rotate(action, data, FALSE);
 628 }
 629
 630 static void layout_menu_config_cb(GtkAction *UNUSED(action), gpointer data)
 631 {
 632         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 633
 634         layout_exit_fullscreen(lw);
 635         show_config_window(lw);
 636 }
 637
 638 static void layout_menu_editors_cb(GtkAction *UNUSED(action), gpointer data)
 639 {
 640         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 641
 642         layout_exit_fullscreen(lw);
 643         show_editor_list_window();
 644 }
 645
 646 static void layout_menu_layout_config_cb(GtkAction *UNUSED(action), gpointer data)
 647 {
 648         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 649
 650         layout_exit_fullscreen(lw);
 651         layout_show_config_window(lw);
 652 }
 653
 654 static void layout_menu_remove_thumb_cb(GtkAction *UNUSED(action), gpointer data)
 655 {
 656         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 657
 658         layout_exit_fullscreen(lw);
 659         cache_manager_show();
 660 }
 661
 662 static void layout_menu_wallpaper_cb(GtkAction *UNUSED(action), gpointer data)
 663 {
 664         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 665
 666         layout_image_to_root(lw);
 667 }
 668
 669 /* single window zoom */
 670 static void layout_menu_zoom_in_cb(GtkAction *UNUSED(action), gpointer data)
 671 {
 672         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 673
 674         layout_image_zoom_adjust(lw, get_zoom_increment(), FALSE);
 675 }
 676
 677 static void layout_menu_zoom_out_cb(GtkAction *UNUSED(action), gpointer data)
 678 {
 679         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 680
 681         layout_image_zoom_adjust(lw, -get_zoom_increment(), FALSE);
 682 }
 683
 684 static void layout_menu_zoom_1_1_cb(GtkAction *UNUSED(action), gpointer data)
 685 {
 686         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 687
 688         layout_image_zoom_set(lw, 1.0, FALSE);
 689 }
 690
 691 static void layout_menu_zoom_fit_cb(GtkAction *UNUSED(action), gpointer data)
 692 {
 693         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 694
 695         layout_image_zoom_set(lw, 0.0, FALSE);
 696 }
 697
 698 static void layout_menu_zoom_fit_hor_cb(GtkAction *UNUSED(action), gpointer data)
 699 {
 700         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 701
 702         layout_image_zoom_set_fill_geometry(lw, FALSE, FALSE);
 703 }
 704
 705 static void layout_menu_zoom_fit_vert_cb(GtkAction *UNUSED(action), gpointer data)
 706 {
 707         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 708
 709         layout_image_zoom_set_fill_geometry(lw, TRUE, FALSE);
 710 }
 711
 712 static void layout_menu_zoom_2_1_cb(GtkAction *UNUSED(action), gpointer data)
 713 {
 714         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 715
 716         layout_image_zoom_set(lw, 2.0, FALSE);
 717 }
 718
 719 static void layout_menu_zoom_3_1_cb(GtkAction *UNUSED(action), gpointer data)
 720 {
 721         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 722
 723         layout_image_zoom_set(lw, 3.0, FALSE);
 724 }
 725 static void layout_menu_zoom_4_1_cb(GtkAction *UNUSED(action), gpointer data)
 726 {
 727         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 728
 729         layout_image_zoom_set(lw, 4.0, FALSE);
 730 }
 731
 732 static void layout_menu_zoom_1_2_cb(GtkAction *UNUSED(action), gpointer data)
 733 {
 734         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 735
 736         layout_image_zoom_set(lw, -2.0, FALSE);
 737 }
 738
 739 static void layout_menu_zoom_1_3_cb(GtkAction *UNUSED(action), gpointer data)
 740 {
 741         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 742
 743         layout_image_zoom_set(lw, -3.0, FALSE);
 744 }
 745
 746 static void layout_menu_zoom_1_4_cb(GtkAction *UNUSED(action), gpointer data)
 747 {
 748         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 749
 750         layout_image_zoom_set(lw, -4.0, FALSE);
 751 }
 752
 753 /* connected zoom */
 754 static void layout_menu_connect_zoom_in_cb(GtkAction *UNUSED(action), gpointer data)
 755 {
 756         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 757
 758         layout_image_zoom_adjust(lw, get_zoom_increment(), TRUE);
 759 }
 760
 761 static void layout_menu_connect_zoom_out_cb(GtkAction *UNUSED(action), gpointer data)
 762 {
 763         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 764
 765         layout_image_zoom_adjust(lw, -get_zoom_increment(), TRUE);
 766 }
 767
 768 static void layout_menu_connect_zoom_1_1_cb(GtkAction *UNUSED(action), gpointer data)
 769 {
 770         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 771
 772         layout_image_zoom_set(lw, 1.0, TRUE);
 773 }
 774
 775 static void layout_menu_connect_zoom_fit_cb(GtkAction *UNUSED(action), gpointer data)
 776 {
 777         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 778
 779         layout_image_zoom_set(lw, 0.0, TRUE);
 780 }
 781
 782 static void layout_menu_connect_zoom_fit_hor_cb(GtkAction *UNUSED(action), gpointer data)
 783 {
 784         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 785
 786         layout_image_zoom_set_fill_geometry(lw, FALSE, TRUE);
 787 }
 788
 789 static void layout_menu_connect_zoom_fit_vert_cb(GtkAction *UNUSED(action), gpointer data)
 790 {
 791         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 792
 793         layout_image_zoom_set_fill_geometry(lw, TRUE, TRUE);
 794 }
 795
 796 static void layout_menu_connect_zoom_2_1_cb(GtkAction *UNUSED(action), gpointer data)
 797 {
 798         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 799
 800         layout_image_zoom_set(lw, 2.0, TRUE);
 801 }
 802
 803 static void layout_menu_connect_zoom_3_1_cb(GtkAction *UNUSED(action), gpointer data)
 804 {
 805         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 806
 807         layout_image_zoom_set(lw, 3.0, TRUE);
 808 }
 809 static void layout_menu_connect_zoom_4_1_cb(GtkAction *UNUSED(action), gpointer data)
 810 {
 811         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 812
 813         layout_image_zoom_set(lw, 4.0, TRUE);
 814 }
 815
 816 static void layout_menu_connect_zoom_1_2_cb(GtkAction *UNUSED(action), gpointer data)
 817 {
 818         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 819
 820         layout_image_zoom_set(lw, -2.0, TRUE);
 821 }
 822
 823 static void layout_menu_connect_zoom_1_3_cb(GtkAction *UNUSED(action), gpointer data)
 824 {
 825         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 826
 827         layout_image_zoom_set(lw, -3.0, TRUE);
 828 }
 829
 830 static void layout_menu_connect_zoom_1_4_cb(GtkAction *UNUSED(action), gpointer data)
 831 {
 832         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 833
 834         layout_image_zoom_set(lw, -4.0, TRUE);
 835 }
 836
 837
 838 static void layout_menu_split_cb(GtkRadioAction *action, GtkRadioAction *UNUSED(current), gpointer data)
 839 {
 840         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 841         ImageSplitMode mode;
 842
 843         layout_exit_fullscreen(lw);
 844         mode = static_cast<ImageSplitMode>(gtk_radio_action_get_current_value(action));
 845         layout_split_change(lw, mode);
 846 }
 847
 848
 849 static void layout_menu_thumb_cb(GtkToggleAction *action, gpointer data)
 850 {
 851         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 852
 853         layout_thumb_set(lw, gtk_toggle_action_get_active(action));
 854 }
 855
 856
 857 static void layout_menu_list_cb(GtkRadioAction *action, GtkRadioAction *UNUSED(current), gpointer data)
 858 {
 859         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 860
 861         layout_exit_fullscreen(lw);
 862         layout_views_set(lw, lw->options.dir_view_type, (FileViewType) gtk_radio_action_get_current_value(action));
 863 }
 864
 865 static void layout_menu_view_dir_as_cb(GtkToggleAction *action,  gpointer data)
 866 {
 867         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 868
 869         layout_exit_fullscreen(lw);
 870
 871         if (gtk_toggle_action_get_active(action))
 872                 {
 873                 layout_views_set(lw, DIRVIEW_TREE, lw->options.file_view_type);
 874                 }
 875         else
 876                 {
 877                 layout_views_set(lw, DIRVIEW_LIST, lw->options.file_view_type);
 878                 }
 879 }
 880
 881 static void layout_menu_view_in_new_window_cb(GtkAction *UNUSED(action), gpointer data)
 882 {
 883         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 884
 885         layout_exit_fullscreen(lw);
 886         view_window_new(layout_image_get_fd(lw));
 887 }
 888
 889 static void layout_menu_open_archive_cb(GtkAction *UNUSED(action), gpointer data)
 890 {
 891         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 892         LayoutWindow *lw_new;
 893         gchar *dest_dir;
 894         FileData *fd;
 895
 896         layout_exit_fullscreen(lw);
 897         fd = layout_image_get_fd(lw);
 898
 899         if (fd->format_class == FORMAT_CLASS_ARCHIVE)
 900                 {
 901                 dest_dir = open_archive(layout_image_get_fd(lw));
 902                 if (dest_dir)
 903                         {
 904                         lw_new = layout_new_from_default();
 905                         layout_set_path(lw_new, dest_dir);
 906                         g_free(dest_dir);
 907                         }
 908                 else
 909                         {
 910                         warning_dialog(_("Cannot open archive file"), _("See the Log Window"), GTK_STOCK_DIALOG_WARNING, NULL);
 911                         }
 912                 }
 913 }
 914
 915 static void layout_menu_fullscreen_cb(GtkAction *UNUSED(action), gpointer data)
 916 {
 917         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 918
 919         layout_image_full_screen_toggle(lw);
 920 }
 921
 922 static void layout_menu_escape_cb(GtkAction *UNUSED(action), gpointer data)
 923 {
 924         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 925
 926         layout_exit_fullscreen(lw);
 927 }
 928
 929 static void layout_menu_overlay_toggle_cb(GtkAction *UNUSED(action), gpointer data)
 930 {
 931         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 932
 933         image_osd_toggle(lw->image);
 934         layout_util_sync_views(lw);
 935 }
 936
 937
 938 static void layout_menu_overlay_cb(GtkToggleAction *action, gpointer data)
 939 {
 940         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 941
 942         if (gtk_toggle_action_get_active(action))
 943                 {
 944                 OsdShowFlags flags = image_osd_get(lw->image);
 945
 946                 if ((flags | OSD_SHOW_INFO | OSD_SHOW_STATUS) != flags)
 947                         image_osd_set(lw->image, static_cast<OsdShowFlags>(flags | OSD_SHOW_INFO | OSD_SHOW_STATUS));
 948                 }
 949         else
 950                 {
 951                 GtkToggleAction *histogram_action = GTK_TOGGLE_ACTION(gtk_action_group_get_action(lw->action_group, "ImageHistogram"));
 952
 953                 image_osd_set(lw->image, OSD_SHOW_NOTHING);
 954                 gtk_toggle_action_set_active(histogram_action, FALSE); /* this calls layout_menu_histogram_cb */
 955                 }
 956 }
 957
 958 static void layout_menu_histogram_cb(GtkToggleAction *action, gpointer data)
 959 {
 960         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 961
 962         if (gtk_toggle_action_get_active(action))
 963                 {
 964                 image_osd_set(lw->image, static_cast<OsdShowFlags>(OSD_SHOW_INFO | OSD_SHOW_STATUS | OSD_SHOW_HISTOGRAM));
 965                 layout_util_sync_views(lw); /* show the overlay state, default channel and mode in the menu */
 966                 }
 967         else
 968                 {
 969                 OsdShowFlags flags = image_osd_get(lw->image);
 970                 if (flags & OSD_SHOW_HISTOGRAM)
 971                         image_osd_set(lw->image, static_cast<OsdShowFlags>(flags & ~OSD_SHOW_HISTOGRAM));
 972                 }
 973 }
 974
 975 static void layout_menu_animate_cb(GtkToggleAction *action, gpointer data)
 976 {
 977         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 978
 979         if (lw->options.animate == gtk_toggle_action_get_active(action)) return;
 980         layout_image_animate_toggle(lw);
 981 }
 982
 983 static void layout_menu_rectangular_selection_cb(GtkToggleAction *action, gpointer UNUSED(data))
 984 {
 985         options->collections.rectangular_selection = gtk_toggle_action_get_active(action);
 986 }
 987
 988 static void layout_menu_histogram_toggle_channel_cb(GtkAction *UNUSED(action), gpointer data)
 989 {
 990         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 991
 992         image_osd_histogram_toggle_channel(lw->image);
 993         layout_util_sync_views(lw);
 994 }
 995
 996 static void layout_menu_histogram_toggle_mode_cb(GtkAction *UNUSED(action), gpointer data)
 997 {
 998         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
 999
1000         image_osd_histogram_toggle_mode(lw->image);
1001         layout_util_sync_views(lw);
1002 }
1003
1004 static void layout_menu_histogram_channel_cb(GtkRadioAction *action, GtkRadioAction *UNUSED(current), gpointer data)
1005 {
1006         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1007         gint channel = gtk_radio_action_get_current_value(action);
1008         GtkToggleAction *histogram_action = GTK_TOGGLE_ACTION(gtk_action_group_get_action(lw->action_group, "ImageHistogram"));
1009
1010         if (channel < 0 || channel >= HCHAN_COUNT) return;
1011
1012         gtk_toggle_action_set_active(histogram_action, TRUE); /* this calls layout_menu_histogram_cb */
1013         image_osd_histogram_set_channel(lw->image, channel);
1014 }
1015
1016 static void layout_menu_histogram_mode_cb(GtkRadioAction *action, GtkRadioAction *UNUSED(current), gpointer data)
1017 {
1018         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1019         gint mode = gtk_radio_action_get_current_value(action);
1020         GtkToggleAction *histogram_action = GTK_TOGGLE_ACTION(gtk_action_group_get_action(lw->action_group, "ImageHistogram"));
1021
1022         if (mode < 0 || mode > 1) return;
1023
1024         gtk_toggle_action_set_active(histogram_action, TRUE); /* this calls layout_menu_histogram_cb */
1025         image_osd_histogram_set_mode(lw->image, mode);
1026 }
1027
1028 static void layout_menu_refresh_cb(GtkAction *UNUSED(action), gpointer data)
1029 {
1030         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1031
1032         layout_refresh(lw);
1033 }
1034
1035 static void layout_menu_bar_exif_cb(GtkAction *UNUSED(action), gpointer data)
1036 {
1037         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1038
1039         layout_exit_fullscreen(lw);
1040         layout_exif_window_new(lw);
1041 }
1042
1043 static void layout_menu_search_and_run_cb(GtkAction *UNUSED(action), gpointer data)
1044 {
1045         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1046
1047         layout_exit_fullscreen(lw);
1048         layout_search_and_run_window_new(lw);
1049 }
1050
1051
1052 static void layout_menu_float_cb(GtkToggleAction *action, gpointer data)
1053 {
1054         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1055
1056         if (lw->options.tools_float == gtk_toggle_action_get_active(action)) return;
1057
1058         layout_exit_fullscreen(lw);
1059         layout_tools_float_toggle(lw);
1060 }
1061
1062 static void layout_menu_hide_cb(GtkAction *UNUSED(action), gpointer data)
1063 {
1064         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1065
1066         layout_exit_fullscreen(lw);
1067         layout_tools_hide_toggle(lw);
1068 }
1069
1070 static void layout_menu_toolbar_cb(GtkToggleAction *action, gpointer data)
1071 {
1072         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1073
1074         if (lw->options.toolbar_hidden == gtk_toggle_action_get_active(action)) return;
1075
1076         layout_exit_fullscreen(lw);
1077         layout_toolbar_toggle(lw);
1078 }
1079
1080 static void layout_menu_info_pixel_cb(GtkToggleAction *action, gpointer data)
1081 {
1082         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1083
1084         if (lw->options.show_info_pixel == gtk_toggle_action_get_active(action)) return;
1085
1086         layout_exit_fullscreen(lw);
1087         layout_info_pixel_set(lw, !lw->options.show_info_pixel);
1088 }
1089
1090 /* NOTE: these callbacks are called also from layout_util_sync_views */
1091 static void layout_menu_bar_cb(GtkToggleAction *action, gpointer data)
1092 {
1093         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1094
1095         if (layout_bar_enabled(lw) == gtk_toggle_action_get_active(action)) return;
1096
1097         layout_exit_fullscreen(lw);
1098         layout_bar_toggle(lw);
1099 }
1100
1101 static void layout_menu_bar_sort_cb(GtkToggleAction *action, gpointer data)
1102 {
1103         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1104
1105         if (layout_bar_sort_enabled(lw) == gtk_toggle_action_get_active(action)) return;
1106
1107         layout_exit_fullscreen(lw);
1108         layout_bar_sort_toggle(lw);
1109 }
1110
1111 static void layout_menu_hide_bars_cb(GtkToggleAction *action, gpointer data)
1112 {
1113         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1114
1115         if (lw->options.bars_state.hidden == gtk_toggle_action_get_active(action))
1116                 {
1117                 return;
1118                 }
1119         layout_bars_hide_toggle(lw);
1120 }
1121
1122 static void layout_menu_slideshow_cb(GtkToggleAction *action, gpointer data)
1123 {
1124         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1125
1126         if (layout_image_slideshow_active(lw) == gtk_toggle_action_get_active(action)) return;
1127         layout_image_slideshow_toggle(lw);
1128 }
1129
1130 static void layout_menu_slideshow_pause_cb(GtkAction *UNUSED(action), gpointer data)
1131 {
1132         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1133
1134         layout_image_slideshow_pause_toggle(lw);
1135 }
1136
1137 static void layout_menu_slideshow_slower_cb(GtkAction *UNUSED(action), gpointer UNUSED(data))
1138 {
1139         options->slideshow.delay = options->slideshow.delay + 5;
1140         if (options->slideshow.delay > SLIDESHOW_MAX_SECONDS)
1141                 options->slideshow.delay = SLIDESHOW_MAX_SECONDS;
1142 }
1143
1144 static void layout_menu_slideshow_faster_cb(GtkAction *UNUSED(action), gpointer UNUSED(data))
1145 {
1146         options->slideshow.delay = options->slideshow.delay - 5;
1147         if (options->slideshow.delay < SLIDESHOW_MIN_SECONDS * 10)
1148                 options->slideshow.delay = SLIDESHOW_MIN_SECONDS * 10;
1149 }
1150
1151
1152 static void layout_menu_stereo_mode_next_cb(GtkAction *UNUSED(action), gpointer data)
1153 {
1154         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1155         gint mode = layout_image_stereo_pixbuf_get(lw);
1156
1157         /* 0->1, 1->2, 2->3, 3->1 - disable auto, then cycle */
1158         mode = mode % 3 + 1;
1159
1160         GtkAction *radio = gtk_action_group_get_action(lw->action_group, "StereoAuto");
1161         gtk_radio_action_set_current_value(GTK_RADIO_ACTION(radio), mode);
1162
1163         /*
1164         this is called via fallback in layout_menu_stereo_mode_cb
1165         layout_image_stereo_pixbuf_set(lw, mode);
1166         */
1167
1168 }
1169
1170 static void layout_menu_stereo_mode_cb(GtkRadioAction *action, GtkRadioAction *UNUSED(current), gpointer data)
1171 {
1172         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1173         gint mode = gtk_radio_action_get_current_value(action);
1174         layout_image_stereo_pixbuf_set(lw, mode);
1175 }
1176
1177 static void layout_menu_help_cb(GtkAction *UNUSED(action), gpointer data)
1178 {
1179         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1180
1181         layout_exit_fullscreen(lw);
1182         help_window_show("index.html");
1183 }
1184
1185 static void layout_menu_help_search_cb(GtkAction *UNUSED(action), gpointer data)
1186 {
1187         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1188
1189         layout_exit_fullscreen(lw);
1190         help_search_window_show();
1191 }
1192
1193 static void layout_menu_help_keys_cb(GtkAction *UNUSED(action), gpointer data)
1194 {
1195         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1196
1197         layout_exit_fullscreen(lw);
1198         help_window_show("GuideReferenceKeyboardShortcuts.html");
1199 }
1200
1201 static void layout_menu_notes_cb(GtkAction *UNUSED(action), gpointer data)
1202 {
1203         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1204
1205         layout_exit_fullscreen(lw);
1206         help_window_show("release_notes");
1207 }
1208
1209 static void layout_menu_changelog_cb(GtkAction *UNUSED(action), gpointer data)
1210 {
1211         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1212
1213         layout_exit_fullscreen(lw);
1214         help_window_show("changelog");
1215 }
1216
1217 static const char *keyboard_map_hardcoded[][2] = {
1218         {"Scroll","Left"},
1219         {"FastScroll", "&lt;Shift&gt;Left"},
1220         {"Left Border", "&lt;Primary&gt;Left"},
1221         {"Left Border", "&lt;Primary&gt;&lt;Shift&gt;Left"},
1222         {"Scroll", "Right"},
1223         {"FastScroll", "&lt;Shift&gt;Right"},
1224         {"Right Border", "&lt;Primary&gt;Right"},
1225         {"Right Border", "&lt;Primary&gt;&lt;Shift&gt;Right"},
1226         {"Scroll", "Up"},
1227         {"FastScroll", "&lt;Shift&gt;Up"},
1228         {"Upper Border", "&lt;Primary&gt;Up"},
1229         {"Upper Border", "&lt;Primary&gt;&lt;Shift&gt;Up"},
1230         {"Scroll", "Down"},
1231         {"FastScroll", "&lt;Shift&gt;Down"},
1232         {"Lower Border", "&lt;Primary&gt;Down"},
1233         {"Lower Border", "&lt;Primary&gt;&lt;Shift&gt;Down"},
1234         {"Next/Drag", "M1"},
1235         {"FastDrag", "&lt;Shift&gt;M1"},
1236         {"DnD Start", "M2"},
1237         {"Menu", "M3"},
1238         {"PrevImage", "MW4"},
1239         {"NextImage", "MW5"},
1240         {"ScrollUp", "&lt;Shift&gt;MW4"},
1241         {"ScrollDown", "&lt;Shift&gt;MW5"},
1242         {"ZoomIn", "&lt;Primary&gt;MW4"},
1243         {"ZoomOut", "&lt;Primary&gt;MW5"},
1244         {NULL, NULL}
1245 };
1246
1247 static void layout_menu_foreach_func(
1248                                         gpointer data,
1249                                         const gchar *accel_path,
1250                                         guint accel_key,
1251                                         GdkModifierType accel_mods,
1252                                         gboolean UNUSED(changed))
1253 {
1254         gchar *path, *name;
1255         gchar *key_name, *menu_name;
1256         gchar **subset_lt_arr, **subset_gt_arr;
1257         gchar *subset_lt, *converted_name;
1258         GPtrArray *array = static_cast<GPtrArray *>(data);
1259
1260         path = g_strescape(accel_path, NULL);
1261         name = gtk_accelerator_name(accel_key, accel_mods);
1262
1263         menu_name = g_strdup(g_strrstr(path, "/")+1);
1264
1265         if (g_strrstr(name, ">"))
1266                 {
1267                 subset_lt_arr = g_strsplit_set(name,"<", 4);
1268                 subset_lt = g_strjoinv("&lt;", subset_lt_arr);
1269                 subset_gt_arr = g_strsplit_set(subset_lt,">", 4);
1270                 converted_name = g_strjoinv("&gt;", subset_gt_arr);
1271                 key_name = g_strdup(converted_name);
1272
1273                 g_free(converted_name);
1274                 g_free(subset_lt);
1275                 g_strfreev(subset_lt_arr);
1276                 g_strfreev(subset_gt_arr);
1277                 }
1278         else
1279                 key_name = g_strdup(name);
1280
1281         g_ptr_array_add(array, (gpointer)menu_name);
1282         g_ptr_array_add(array, (gpointer)key_name);
1283
1284         g_free(name);
1285         g_free(path);
1286 }
1287
1288 static void layout_menu_kbd_map_cb(GtkAction *UNUSED(action), gpointer UNUSED(data))
1289 {
1290         gint fd = -1;
1291         GPtrArray *array;
1292         char * tmp_file;
1293         GError *error = NULL;
1294         GIOChannel *channel;
1295         char **pre_key, **post_key;
1296         const char *key_name;
1297         char *converted_line;
1298         int keymap_index;
1299         guint index;
1300
1301         fd = g_file_open_tmp("geeqie_keymap_XXXXXX.svg", &tmp_file, &error);
1302         if (error)
1303                 {
1304                 log_printf("Error: Keyboard Map - cannot create file:%s\n",error->message);
1305                 g_error_free(error);
1306                 }
1307         else
1308                 {
1309                 array = g_ptr_array_new();
1310
1311                 gtk_accel_map_foreach(array, layout_menu_foreach_func);
1312
1313                 channel = g_io_channel_unix_new(fd);
1314
1315                 keymap_index = 0;
1316                 while (keymap_template[keymap_index])
1317                         {
1318                         if (g_strrstr(keymap_template[keymap_index], ">key:"))
1319                                 {
1320                                 pre_key = g_strsplit(keymap_template[keymap_index],">key:",2);
1321                                 post_key = g_strsplit(pre_key[1],"<",2);
1322
1323                                 index=0;
1324                                 key_name = " ";
1325                                 for (index=0; index < array->len-2; index=index+2)
1326                                         {
1327                                         if (!(g_ascii_strcasecmp(static_cast<const gchar *>(g_ptr_array_index(array,index+1)), post_key[0])))
1328                                                 {
1329                                                 key_name = static_cast<const gchar *>(g_ptr_array_index(array,index+0));
1330                                                 break;
1331                                                 }
1332                                         }
1333
1334                                 index=0;
1335                                 while (keyboard_map_hardcoded[index][0])
1336                                         {
1337                                         if (!(g_strcmp0(keyboard_map_hardcoded[index][1], post_key[0])))
1338                                                 {
1339                                                 key_name = keyboard_map_hardcoded[index][0];
1340                                                 break;
1341                                                 }
1342                                         index++;
1343                                         }
1344
1345                                 converted_line = g_strconcat(pre_key[0], ">", key_name, "<", post_key[1], "\n", NULL);
1346                                 g_io_channel_write_chars(channel, converted_line, -1, NULL, &error);
1347                                 if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
1348
1349                                 g_free(converted_line);
1350                                 g_strfreev(pre_key);
1351                                 g_strfreev(post_key);
1352                                 }
1353                         else
1354                                 {
1355                                 g_io_channel_write_chars(channel, keymap_template[keymap_index], -1, NULL, &error);
1356                                 if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
1357                                 g_io_channel_write_chars(channel, "\n", -1, NULL, &error);
1358                                 if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
1359                                 }
1360                         keymap_index++;
1361                         }
1362
1363                 g_io_channel_flush(channel, &error);
1364                 if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
1365                 g_io_channel_unref(channel);
1366
1367                 index=0;
1368                 for (index=0; index < array->len-2; index=index+2)
1369                         {
1370                         g_free(g_ptr_array_index(array,index));
1371                         g_free(g_ptr_array_index(array,index+1));
1372                         }
1373                 g_ptr_array_unref(array);
1374
1375                 view_window_new(file_data_new_simple(tmp_file));
1376                 g_free(tmp_file);
1377                 }
1378 }
1379
1380 static void layout_menu_about_cb(GtkAction *UNUSED(action), gpointer data)
1381 {
1382         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1383
1384         layout_exit_fullscreen(lw);
1385         show_about_window(lw);
1386 }
1387
1388 static void layout_menu_log_window_cb(GtkAction *UNUSED(action), gpointer data)
1389 {
1390         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1391
1392         layout_exit_fullscreen(lw);
1393         log_window_new(lw);
1394 }
1395
1396
1397 /*
1398  *-----------------------------------------------------------------------------
1399  * select menu
1400  *-----------------------------------------------------------------------------
1401  */
1402
1403 static void layout_menu_select_all_cb(GtkAction *UNUSED(action), gpointer data)
1404 {
1405         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1406
1407         layout_select_all(lw);
1408 }
1409
1410 static void layout_menu_unselect_all_cb(GtkAction *UNUSED(action), gpointer data)
1411 {
1412         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1413
1414         layout_select_none(lw);
1415 }
1416
1417 static void layout_menu_invert_selection_cb(GtkAction *UNUSED(action), gpointer data)
1418 {
1419         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1420
1421         layout_select_invert(lw);
1422 }
1423
1424 static void layout_menu_file_filter_cb(GtkToggleAction *action, gpointer data)
1425 {
1426         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1427
1428         layout_file_filter_set(lw, gtk_toggle_action_get_active(action));
1429 }
1430
1431 static void layout_menu_marks_cb(GtkToggleAction *action, gpointer data)
1432 {
1433         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1434
1435         layout_marks_set(lw, gtk_toggle_action_get_active(action));
1436 }
1437
1438
1439 static void layout_menu_set_mark_sel_cb(GtkAction *action, gpointer data)
1440 {
1441         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1442         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1443         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1444
1445         layout_selection_to_mark(lw, mark, STM_MODE_SET);
1446 }
1447
1448 static void layout_menu_res_mark_sel_cb(GtkAction *action, gpointer data)
1449 {
1450         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1451         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1452         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1453
1454         layout_selection_to_mark(lw, mark, STM_MODE_RESET);
1455 }
1456
1457 static void layout_menu_toggle_mark_sel_cb(GtkAction *action, gpointer data)
1458 {
1459         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1460         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1461         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1462
1463         layout_selection_to_mark(lw, mark, STM_MODE_TOGGLE);
1464 }
1465
1466 static void layout_menu_sel_mark_cb(GtkAction *action, gpointer data)
1467 {
1468         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1469         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1470         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1471
1472         layout_mark_to_selection(lw, mark, MTS_MODE_SET);
1473 }
1474
1475 static void layout_menu_sel_mark_or_cb(GtkAction *action, gpointer data)
1476 {
1477         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1478         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1479         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1480
1481         layout_mark_to_selection(lw, mark, MTS_MODE_OR);
1482 }
1483
1484 static void layout_menu_sel_mark_and_cb(GtkAction *action, gpointer data)
1485 {
1486         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1487         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1488         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1489
1490         layout_mark_to_selection(lw, mark, MTS_MODE_AND);
1491 }
1492
1493 static void layout_menu_sel_mark_minus_cb(GtkAction *action, gpointer data)
1494 {
1495         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1496         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1497         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1498
1499         layout_mark_to_selection(lw, mark, MTS_MODE_MINUS);
1500 }
1501
1502 static void layout_menu_mark_filter_toggle_cb(GtkAction *action, gpointer data)
1503 {
1504         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1505         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1506         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1507
1508         layout_marks_set(lw, TRUE);
1509         layout_mark_filter_toggle(lw, mark);
1510 }
1511
1512
1513 /*
1514  *-----------------------------------------------------------------------------
1515  * go menu
1516  *-----------------------------------------------------------------------------
1517  */
1518
1519 static void layout_menu_image_first_cb(GtkAction *UNUSED(action), gpointer data)
1520 {
1521         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1522         layout_image_first(lw);
1523 }
1524
1525 static void layout_menu_image_prev_cb(GtkAction *UNUSED(action), gpointer data)
1526 {
1527         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1528         gint i;
1529
1530         if (lw->options.split_pane_sync)
1531                 {
1532                 for (i = 0; i < MAX_SPLIT_IMAGES; i++)
1533                         {
1534                         if (lw->split_images[i])
1535                                 {
1536                                 if (i != -1)
1537                                         {
1538                                         DEBUG_1("image activate scroll %d", i);
1539                                         layout_image_activate(lw, i, FALSE);
1540                                         layout_image_prev(lw);
1541                                         }
1542                                 }
1543                         }
1544                 }
1545         else
1546                 {
1547                 layout_image_prev(lw);
1548                 }
1549 }
1550
1551 static void layout_menu_image_next_cb(GtkAction *UNUSED(action), gpointer data)
1552 {
1553         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1554         gint i;
1555
1556         if (lw->options.split_pane_sync)
1557                 {
1558                 for (i = 0; i < MAX_SPLIT_IMAGES; i++)
1559                         {
1560                         if (lw->split_images[i])
1561                                 {
1562                                 if (i != -1)
1563                                         {
1564                                         DEBUG_1("image activate scroll %d", i);
1565                                         layout_image_activate(lw, i, FALSE);
1566                                         layout_image_next(lw);
1567                                         }
1568                                 }
1569                         }
1570                 }
1571         else
1572                 {
1573                 layout_image_next(lw);
1574                 }
1575 }
1576
1577 static void layout_menu_page_first_cb(GtkAction *UNUSED(action), gpointer data)
1578 {
1579         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1580         FileData *fd = layout_image_get_fd(lw);
1581
1582         if (fd->page_total > 0)
1583                 {
1584                 file_data_set_page_num(fd, 1);
1585                 }
1586 }
1587
1588 static void layout_menu_page_last_cb(GtkAction *UNUSED(action), gpointer data)
1589 {
1590         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1591         FileData *fd = layout_image_get_fd(lw);
1592
1593         if (fd->page_total > 0)
1594                 {
1595                 file_data_set_page_num(fd, -1);
1596                 }
1597 }
1598
1599 static void layout_menu_page_next_cb(GtkAction *UNUSED(action), gpointer data)
1600 {
1601         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1602         FileData *fd = layout_image_get_fd(lw);
1603
1604         if (fd->page_total > 0)
1605                 {
1606                 file_data_inc_page_num(fd);
1607                 }
1608 }
1609
1610 static void layout_menu_page_previous_cb(GtkAction *UNUSED(action), gpointer data)
1611 {
1612         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1613         FileData *fd = layout_image_get_fd(lw);
1614
1615         if (fd->page_total > 0)
1616                 {
1617                 file_data_dec_page_num(fd);
1618                 }
1619 }
1620
1621 static void layout_menu_image_forward_cb(GtkAction *UNUSED(action), gpointer data)
1622 {
1623         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1624
1625         /* Obtain next image */
1626         layout_set_path(lw, image_chain_forward());
1627 }
1628
1629 static void layout_menu_image_back_cb(GtkAction *UNUSED(action), gpointer data)
1630 {
1631         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1632
1633         /* Obtain previous image */
1634         layout_set_path(lw, image_chain_back());
1635 }
1636
1637 static void layout_menu_split_pane_next_cb(GtkAction *UNUSED(action), gpointer data)
1638 {
1639         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1640         gint active_frame;
1641
1642         active_frame = lw->active_split_image;
1643
1644         if (active_frame < MAX_SPLIT_IMAGES-1 && lw->split_images[active_frame+1] )
1645                 {
1646                 active_frame++;
1647                 }
1648         else
1649                 {
1650                 active_frame = 0;
1651                 }
1652         layout_image_activate(lw, active_frame, FALSE);
1653 }
1654
1655 static void layout_menu_split_pane_prev_cb(GtkAction *UNUSED(action), gpointer data)
1656 {
1657         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1658         gint active_frame;
1659
1660         active_frame = lw->active_split_image;
1661
1662         if (active_frame >=1 && lw->split_images[active_frame-1] )
1663                 {
1664                 active_frame--;
1665                 }
1666         else
1667                 {
1668                 active_frame = MAX_SPLIT_IMAGES-1;
1669                 while (!lw->split_images[active_frame])
1670                         {
1671                         active_frame--;
1672                         }
1673                 }
1674         layout_image_activate(lw, active_frame, FALSE);
1675 }
1676
1677 static void layout_menu_split_pane_updown_cb(GtkAction *UNUSED(action), gpointer data)
1678 {
1679         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1680         gint active_frame;
1681
1682         active_frame = lw->active_split_image;
1683
1684         if (lw->split_images[MAX_SPLIT_IMAGES-1] )
1685                 {
1686                 active_frame = active_frame ^ 2;
1687                 }
1688         else
1689                 {
1690                 active_frame = active_frame ^ 1;
1691                 }
1692         layout_image_activate(lw, active_frame, FALSE);
1693 }
1694
1695 static void layout_menu_image_last_cb(GtkAction *UNUSED(action), gpointer data)
1696 {
1697         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1698         layout_image_last(lw);
1699 }
1700
1701 static void layout_menu_back_cb(GtkAction *UNUSED(action), gpointer data)
1702 {
1703         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1704         FileData *dir_fd;
1705
1706         /* Obtain previous path */
1707         dir_fd = file_data_new_dir(history_chain_back());
1708         layout_set_fd(lw, dir_fd);
1709         file_data_unref(dir_fd);
1710 }
1711
1712 static void layout_menu_forward_cb(GtkAction *UNUSED(action), gpointer data)
1713 {
1714         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1715         FileData *dir_fd;
1716
1717         /* Obtain next path */
1718         dir_fd = file_data_new_dir(history_chain_forward());
1719         layout_set_fd(lw, dir_fd);
1720         file_data_unref(dir_fd);
1721 }
1722
1723 static void layout_menu_home_cb(GtkAction *UNUSED(action), gpointer data)
1724 {
1725         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1726         const gchar *path;
1727
1728         if (lw->options.home_path && *lw->options.home_path)
1729                 path = lw->options.home_path;
1730         else
1731                 path = homedir();
1732
1733         if (path)
1734                 {
1735                 FileData *dir_fd = file_data_new_dir(path);
1736                 layout_set_fd(lw, dir_fd);
1737                 file_data_unref(dir_fd);
1738                 }
1739 }
1740
1741 static void layout_menu_up_cb(GtkAction *UNUSED(action), gpointer data)
1742 {
1743         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1744         ViewDir *vd = lw->vd;
1745         gchar *path;
1746
1747         if (!vd->dir_fd || strcmp(vd->dir_fd->path, G_DIR_SEPARATOR_S) == 0) return;
1748         path = remove_level_from_path(vd->dir_fd->path);
1749
1750         if (vd->select_func)
1751                 {
1752                 FileData *fd = file_data_new_dir(path);
1753                 vd->select_func(vd, fd, vd->select_data);
1754                 file_data_unref(fd);
1755                 }
1756
1757         g_free(path);
1758 }
1759
1760
1761 /*
1762  *-----------------------------------------------------------------------------
1763  * edit menu
1764  *-----------------------------------------------------------------------------
1765  */
1766
1767 static void layout_menu_edit_cb(GtkAction *action, gpointer data)
1768 {
1769         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1770         const gchar *key = gtk_action_get_name(action);
1771
1772         if (!editor_window_flag_set(key))
1773                 layout_exit_fullscreen(lw);
1774
1775         file_util_start_editor_from_filelist(key, layout_selection_list(lw), layout_get_path(lw), lw->window);
1776 }
1777
1778
1779 static void layout_menu_metadata_write_cb(GtkAction *UNUSED(action), gpointer UNUSED(data))
1780 {
1781         metadata_write_queue_confirm(TRUE, NULL, NULL);
1782 }
1783
1784 static GtkWidget *last_focussed = NULL;
1785 static void layout_menu_keyword_autocomplete_cb(GtkAction *UNUSED(action), gpointer data)
1786 {
1787         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1788         GtkWidget *tmp;
1789         gboolean auto_has_focus;
1790
1791         tmp = gtk_window_get_focus(GTK_WINDOW(lw->window));
1792         auto_has_focus = bar_keywords_autocomplete_focus(lw);
1793
1794         if (auto_has_focus)
1795                 {
1796                 gtk_widget_grab_focus(last_focussed);
1797                 }
1798         else
1799                 {
1800                 last_focussed = tmp;
1801                 }
1802 }
1803
1804 /*
1805  *-----------------------------------------------------------------------------
1806  * color profile button (and menu)
1807  *-----------------------------------------------------------------------------
1808  */
1809 #ifdef HAVE_LCMS
1810 static void layout_color_menu_enable_cb(GtkToggleAction *action, gpointer data)
1811 {
1812         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1813
1814         if (layout_image_color_profile_get_use(lw) == gtk_toggle_action_get_active(action)) return;
1815
1816         layout_image_color_profile_set_use(lw, gtk_toggle_action_get_active(action));
1817         layout_util_sync_color(lw);
1818         layout_image_refresh(lw);
1819 }
1820 #else
1821 static void layout_color_menu_enable_cb()
1822 {
1823 }
1824 #endif
1825
1826 #ifdef HAVE_LCMS
1827 static void layout_color_menu_use_image_cb(GtkToggleAction *action, gpointer data)
1828 {
1829         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1830         gint input;
1831         gboolean use_image;
1832
1833         if (!layout_image_color_profile_get(lw, &input, &use_image)) return;
1834         if (use_image == gtk_toggle_action_get_active(action)) return;
1835         layout_image_color_profile_set(lw, input, gtk_toggle_action_get_active(action));
1836         layout_util_sync_color(lw);
1837         layout_image_refresh(lw);
1838 }
1839 #else
1840 static void layout_color_menu_use_image_cb()
1841 {
1842 }
1843 #endif
1844
1845 #ifdef HAVE_LCMS
1846 static void layout_color_menu_input_cb(GtkRadioAction *action, GtkRadioAction *UNUSED(current), gpointer data)
1847 {
1848         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1849         gint type;
1850         gint input;
1851         gboolean use_image;
1852
1853         type = gtk_radio_action_get_current_value(action);
1854         if (type < 0 || type >= COLOR_PROFILE_FILE + COLOR_PROFILE_INPUTS) return;
1855
1856         if (!layout_image_color_profile_get(lw, &input, &use_image)) return;
1857         if (type == input) return;
1858
1859         layout_image_color_profile_set(lw, type, use_image);
1860         layout_image_refresh(lw);
1861 }
1862 #else
1863 static void layout_color_menu_input_cb()
1864 {
1865 }
1866 #endif
1867
1868
1869 /*
1870  *-----------------------------------------------------------------------------
1871  * recent menu
1872  *-----------------------------------------------------------------------------
1873  */
1874
1875 static void layout_menu_recent_cb(GtkWidget *widget, gpointer UNUSED(data))
1876 {
1877         gint n;
1878         gchar *path;
1879
1880         n = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "recent_index"));
1881
1882         path = static_cast<gchar *>(g_list_nth_data(history_list_get_by_key("recent"), n));
1883
1884         if (!path) return;
1885
1886         /* make a copy of it */
1887         path = g_strdup(path);
1888         collection_window_new(path);
1889         g_free(path);
1890 }
1891
1892 static void layout_menu_recent_update(LayoutWindow *lw)
1893 {
1894         GtkWidget *menu;
1895         GtkWidget *recent;
1896         GtkWidget *item;
1897         GList *list;
1898         gint n;
1899
1900         if (!lw->ui_manager) return;
1901
1902         list = history_list_get_by_key("recent");
1903         n = 0;
1904
1905         menu = gtk_menu_new();
1906
1907         while (list)
1908                 {
1909                 const gchar *filename = filename_from_path((gchar *)list->data);
1910                 gchar *name;
1911                 gboolean free_name = FALSE;
1912
1913                 if (file_extension_match(filename, GQ_COLLECTION_EXT))
1914                         {
1915                         name = remove_extension_from_path(filename);
1916                         free_name = TRUE;
1917                         }
1918                 else
1919                         {
1920                         name = (gchar *) filename;
1921                         }
1922
1923                 item = menu_item_add_simple(menu, name, G_CALLBACK(layout_menu_recent_cb), lw);
1924                 if (free_name) g_free(name);
1925                 g_object_set_data(G_OBJECT(item), "recent_index", GINT_TO_POINTER(n));
1926                 list = list->next;
1927                 n++;
1928                 }
1929
1930         if (n == 0)
1931                 {
1932                 menu_item_add(menu, _("Empty"), NULL, NULL);
1933                 }
1934
1935         recent = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/FileMenu/OpenRecent");
1936         gtk_menu_item_set_submenu(GTK_MENU_ITEM(recent), menu);
1937         gtk_widget_set_sensitive(recent, (n != 0));
1938 }
1939
1940 void layout_recent_update_all(void)
1941 {
1942         GList *work;
1943
1944         work = layout_window_list;
1945         while (work)
1946                 {
1947                 LayoutWindow *lw = static_cast<LayoutWindow *>(work->data);
1948                 work = work->next;
1949
1950                 layout_menu_recent_update(lw);
1951                 }
1952 }
1953
1954 void layout_recent_add_path(const gchar *path)
1955 {
1956         if (!path) return;
1957
1958         history_list_add_to_key("recent", path, options->open_recent_list_maxsize);
1959
1960         layout_recent_update_all();
1961 }
1962
1963 /*
1964  *-----------------------------------------------------------------------------
1965  * window layout menu
1966  *-----------------------------------------------------------------------------
1967  */
1968 typedef struct _WindowNames WindowNames;
1969 struct _WindowNames
1970 {
1971         gboolean displayed;
1972         gchar *name;
1973         gchar *path;
1974 };
1975
1976 typedef struct _RenameWindow RenameWindow;
1977 struct _RenameWindow
1978 {
1979         GenericDialog *gd;
1980         LayoutWindow *lw;
1981
1982         GtkWidget *button_ok;
1983         GtkWidget *window_name_entry;
1984 };
1985
1986 typedef struct _DeleteWindow DeleteWindow;
1987 struct _DeleteWindow
1988 {
1989         GenericDialog *gd;
1990         LayoutWindow *lw;
1991
1992         GtkWidget *button_ok;
1993         GtkWidget *group;
1994 };
1995
1996 static gint layout_window_menu_list_sort_cb(gconstpointer a, gconstpointer b)
1997 {
1998         const WindowNames *wna = static_cast<const WindowNames *>(a);
1999         const WindowNames *wnb = static_cast<const WindowNames *>(b);
2000
2001         return g_strcmp0((gchar *)wna->name, (gchar *)wnb->name);
2002 }
2003
2004 static GList *layout_window_menu_list(GList *listin)
2005 {
2006         GList *list;
2007         WindowNames *wn;
2008         gboolean dupe;
2009         DIR *dp;
2010         struct dirent *dir;
2011         gchar *pathl;
2012
2013         pathl = path_from_utf8(get_window_layouts_dir());
2014         dp = opendir(pathl);
2015         if (!dp)
2016                 {
2017                 /* dir not found */
2018                 g_free(pathl);
2019                 return listin;
2020                 }
2021
2022         while ((dir = readdir(dp)) != NULL)
2023                 {
2024                 gchar *name_file = dir->d_name;
2025
2026                 if (g_str_has_suffix(name_file, ".xml"))
2027                         {
2028                         LayoutWindow *lw_tmp ;
2029                         gchar *name_utf8 = path_to_utf8(name_file);
2030                         gchar *name_base = g_strndup(name_utf8, strlen(name_utf8) - 4);
2031                         list = layout_window_list;
2032                         dupe = FALSE;
2033                         while (list)
2034                                 {
2035                                 lw_tmp = static_cast<LayoutWindow *>(list->data);
2036                                 if (g_strcmp0(lw_tmp->options.id, name_base) == 0)
2037                                         {
2038                                         dupe = TRUE;
2039                                         }
2040                                 list = list->next;
2041                                 }
2042                         gchar *dpath = g_build_filename(pathl, name_utf8, NULL);
2043                         wn  = g_new0(WindowNames, 1);
2044                         wn->displayed = dupe;
2045                         wn->name = g_strdup(name_base);
2046                         wn->path = g_strdup(dpath);
2047                         listin = g_list_append(listin, wn);
2048
2049                         g_free(dpath);
2050                         g_free(name_utf8);
2051                         g_free(name_base);
2052                         }
2053                 }
2054         closedir(dp);
2055
2056         g_free(pathl);
2057
2058         return g_list_sort(listin, layout_window_menu_list_sort_cb);
2059 }
2060
2061 static void layout_menu_new_window_cb(GtkWidget *UNUSED(widget), gpointer data)
2062 {
2063         gint n;
2064
2065         n = GPOINTER_TO_INT(data);
2066         GList *menulist = NULL;
2067
2068         menulist = layout_window_menu_list(menulist);
2069         WindowNames *wn = static_cast<WindowNames *>(g_list_nth(menulist, n )->data);
2070
2071         if (wn->path)
2072                 {
2073                 load_config_from_file(wn->path, FALSE);
2074                 }
2075         else
2076                 {
2077                 log_printf(_("Error: window layout name: %s does not exist\n"), wn->path);
2078                 }
2079 }
2080
2081 static void layout_menu_new_window_update(LayoutWindow *lw)
2082 {
2083         GtkWidget *menu;
2084         GtkWidget *sub_menu;
2085         GtkWidget *item;
2086         GList *children, *iter;
2087         gint n;
2088         GList *list = NULL;
2089         gint i = 0;
2090         WindowNames *wn;
2091
2092         if (!lw->ui_manager) return;
2093
2094         list = layout_window_menu_list(list);
2095
2096         menu = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/WindowsMenu/NewWindow");
2097         sub_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu));
2098
2099         children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
2100         for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
2101                 {
2102                 if (i >= 4) // separator, default, from current, separator
2103                         {
2104                         gtk_widget_destroy(GTK_WIDGET(iter->data));
2105                         }
2106                 }
2107         g_list_free(children);
2108
2109         menu_item_add_divider(sub_menu);
2110
2111         n = 0;
2112         while (list)
2113                 {
2114                 wn = static_cast<WindowNames *>(list->data);
2115                 item = menu_item_add_simple(sub_menu, wn->name, G_CALLBACK(layout_menu_new_window_cb), GINT_TO_POINTER(n));
2116                 if (wn->displayed)
2117                         {
2118                         gtk_widget_set_sensitive(item, FALSE);
2119                         }
2120                 list = list->next;
2121                 n++;
2122                 }
2123 }
2124
2125 static void window_rename_cancel_cb(GenericDialog *UNUSED(gd), gpointer data)
2126 {
2127         RenameWindow *rw = static_cast<RenameWindow *>(data);
2128
2129         generic_dialog_close(rw->gd);
2130         g_free(rw);
2131 }
2132
2133 static void window_rename_ok(GenericDialog *UNUSED(gd), gpointer data)
2134 {
2135         RenameWindow *rw = static_cast<RenameWindow *>(data);
2136         gchar *path;
2137         gboolean window_layout_name_exists = FALSE;
2138         GList *list = NULL;
2139         gchar *xml_name;
2140         gchar *new_id;
2141
2142         new_id = g_strdup(gtk_entry_get_text(GTK_ENTRY(rw->window_name_entry)));
2143
2144         list = layout_window_menu_list(list);
2145         while (list)
2146                 {
2147                 WindowNames *ln = static_cast<WindowNames *>(list->data);
2148                 if (g_strcmp0(ln->name, new_id) == 0)
2149                         {
2150                         gchar *buf;
2151                         buf = g_strdup_printf(_("Window layout name \"%s\" already exists."), new_id);
2152                         warning_dialog(_("Rename window"), buf, GTK_STOCK_DIALOG_WARNING, rw->gd->dialog);
2153                         g_free(buf);
2154                         window_layout_name_exists = TRUE;
2155                         break;
2156                         }
2157                 list = list->next;
2158                 }
2159
2160         if (!window_layout_name_exists)
2161                 {
2162                 xml_name = g_strdup_printf("%s.xml", rw->lw->options.id);
2163                 path = g_build_filename(get_window_layouts_dir(), xml_name, NULL);
2164
2165                 if (isfile(path))
2166                         {
2167                         unlink_file(path);
2168                         }
2169                 g_free(xml_name);
2170                 g_free(path);
2171
2172                 g_free(rw->lw->options.id);
2173                 rw->lw->options.id = g_strdup(new_id);
2174                 layout_menu_new_window_update(rw->lw);
2175                 layout_refresh(rw->lw);
2176                 image_update_title(rw->lw->image);
2177                 }
2178
2179         save_layout(rw->lw);
2180
2181         g_free(new_id);
2182         generic_dialog_close(rw->gd);
2183         g_free(rw);
2184 }
2185
2186 static void window_rename_ok_cb(GenericDialog *gd, gpointer data)
2187 {
2188         RenameWindow *rw = static_cast<RenameWindow *>(data);
2189
2190         window_rename_ok(gd, rw);
2191 }
2192
2193 static void window_rename_entry_activate_cb(GenericDialog *gd, gpointer data)
2194 {
2195         RenameWindow *rw = static_cast<RenameWindow *>(data);
2196
2197         window_rename_ok(gd, rw);
2198 }
2199
2200 static void window_delete_cancel_cb(GenericDialog *UNUSED(gd), gpointer data)
2201 {
2202         DeleteWindow *dw = static_cast<DeleteWindow *>(data);
2203
2204         g_free(dw);
2205 }
2206
2207 static void window_delete_ok_cb(GenericDialog *UNUSED(gd), gpointer data)
2208 {
2209         DeleteWindow *dw = static_cast<DeleteWindow *>(data);
2210         gchar *path;
2211         gchar *xml_name;
2212
2213         xml_name = g_strdup_printf("%s.xml", dw->lw->options.id);
2214         path = g_build_filename(get_window_layouts_dir(), xml_name, NULL);
2215
2216         layout_close(dw->lw);
2217         g_free(dw);
2218
2219         if (isfile(path))
2220                 {
2221                 unlink_file(path);
2222                 }
2223         g_free(xml_name);
2224         g_free(path);
2225 }
2226
2227 static void layout_menu_window_default_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
2228 {
2229         layout_new_from_default();
2230 }
2231
2232 static void layout_menu_windows_menu_cb(GtkWidget *UNUSED(widget), gpointer data)
2233 {
2234         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2235         GtkWidget *menu;
2236         GtkWidget *sub_menu;
2237         gchar *menu_label;
2238         GList *children, *iter;
2239         gint i;
2240
2241         menu = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/WindowsMenu/");
2242         sub_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu));
2243
2244         /* disable Delete for temporary windows */
2245         if (g_str_has_prefix(lw->options.id, "lw"))
2246                 {
2247                 i = 0;
2248                 children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
2249                 for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
2250                         {
2251                         menu_label = g_strdup(gtk_menu_item_get_label(GTK_MENU_ITEM(iter->data)));
2252                         if (g_strcmp0(menu_label, _("Delete window")) == 0)
2253                                 {
2254                                 gtk_widget_set_sensitive(GTK_WIDGET(iter->data), FALSE);
2255                                 }
2256                         g_free(menu_label);
2257                         }
2258                 g_list_free(children);
2259                 }
2260 }
2261
2262 static void layout_menu_view_menu_cb(GtkWidget *UNUSED(widget), gpointer data)
2263 {
2264         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2265         GtkWidget *menu;
2266         GtkWidget *sub_menu;
2267         gchar *menu_label;
2268         GList *children, *iter;
2269         gint i;
2270         FileData *fd;
2271
2272         menu = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/ViewMenu/");
2273         sub_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu));
2274
2275         fd = layout_image_get_fd(lw);
2276
2277         i = 0;
2278         children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
2279         for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
2280                 {
2281                 menu_label = g_strdup(gtk_menu_item_get_label(GTK_MENU_ITEM(iter->data)));
2282                 if (g_strcmp0(menu_label, _("Open archive")) == 0)
2283                         {
2284                         if (fd && fd->format_class == FORMAT_CLASS_ARCHIVE)
2285                                 {
2286                                 gtk_widget_set_sensitive(GTK_WIDGET(iter->data), TRUE);
2287                                 }
2288                         else
2289                                 {
2290                                 gtk_widget_set_sensitive(GTK_WIDGET(iter->data), FALSE);
2291                                 }
2292                         }
2293                 g_free(menu_label);
2294                 }
2295         g_list_free(children);
2296 }
2297
2298 static void change_window_id(const gchar *infile, const gchar *outfile)
2299 {
2300         GFile *in_file;
2301         GFile *out_file;
2302         GFileInputStream *in_file_stream;
2303         GFileOutputStream *out_file_stream;
2304         GDataInputStream *in_data_stream;
2305         GDataOutputStream *out_data_stream;
2306         gchar *line;
2307         gchar *id_name;
2308
2309         id_name = layout_get_unique_id();
2310
2311         in_file = g_file_new_for_path(infile);
2312         in_file_stream = g_file_read(in_file, NULL, NULL);
2313         in_data_stream = g_data_input_stream_new(G_INPUT_STREAM(in_file_stream));
2314
2315         out_file = g_file_new_for_path(outfile);
2316         out_file_stream = g_file_append_to(out_file, G_FILE_CREATE_PRIVATE, NULL, NULL);
2317         out_data_stream = g_data_output_stream_new(G_OUTPUT_STREAM(out_file_stream));
2318
2319         while ((line = g_data_input_stream_read_line(in_data_stream, NULL, NULL, NULL)))
2320                 {
2321                 if (g_str_has_suffix(line, "<layout"))
2322                         {
2323                         g_data_output_stream_put_string(out_data_stream, line, NULL, NULL);
2324                         g_data_output_stream_put_string(out_data_stream, "\n", NULL, NULL);
2325                         g_free(line);
2326
2327                         line = g_data_input_stream_read_line(in_data_stream, NULL, NULL, NULL);
2328                         g_data_output_stream_put_string(out_data_stream, "id = \"", NULL, NULL);
2329                         g_data_output_stream_put_string(out_data_stream, id_name, NULL, NULL);
2330                         g_data_output_stream_put_string(out_data_stream, "\"\n", NULL, NULL);
2331                         }
2332                 else
2333                         {
2334                         g_data_output_stream_put_string(out_data_stream, line, NULL, NULL);
2335                         g_data_output_stream_put_string(out_data_stream, "\n", NULL, NULL);
2336                         }
2337                 g_free(line);
2338                 }
2339
2340         g_free(id_name);
2341         g_object_unref(out_data_stream);
2342         g_object_unref(in_data_stream);
2343         g_object_unref(out_file_stream);
2344         g_object_unref(in_file_stream);
2345         g_object_unref(out_file);
2346         g_object_unref(in_file);
2347 }
2348
2349 static void layout_menu_window_from_current_cb(GtkWidget *UNUSED(widget), gpointer data)
2350 {
2351         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2352         gint fd_in = -1;
2353         gint fd_out = -1;
2354         char * tmp_file_in;
2355         char * tmp_file_out;
2356         GError *error = NULL;
2357
2358         fd_in = g_file_open_tmp("geeqie_layout_name_XXXXXX.xml", &tmp_file_in, &error);
2359         if (error)
2360                 {
2361                 log_printf("Error: Window layout - cannot create file:%s\n",error->message);
2362                 g_error_free(error);
2363                 return;
2364                 }
2365         close(fd_in);
2366         fd_out = g_file_open_tmp("geeqie_layout_name_XXXXXX.xml", &tmp_file_out, &error);
2367         if (error)
2368                 {
2369                 log_printf("Error: Window layout - cannot create file:%s\n",error->message);
2370                 g_error_free(error);
2371                 return;
2372                 }
2373         close(fd_out);
2374
2375         save_config_to_file(tmp_file_in, options, lw);
2376         change_window_id(tmp_file_in, tmp_file_out);
2377         load_config_from_file(tmp_file_out, FALSE);
2378
2379         unlink_file(tmp_file_in);
2380         unlink_file(tmp_file_out);
2381         g_free(tmp_file_in);
2382         g_free(tmp_file_out);
2383 }
2384
2385 static void layout_menu_window_cb(GtkWidget *UNUSED(widget), gpointer data)
2386 {
2387         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2388
2389         layout_menu_new_window_update(lw);
2390 }
2391
2392 static void layout_menu_window_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
2393 {
2394         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2395         RenameWindow *rw;
2396         GtkWidget *hbox;
2397
2398         rw = g_new0(RenameWindow, 1);
2399         rw->lw = lw;
2400
2401         rw->gd = generic_dialog_new(_("Rename window"), "rename_window", NULL, FALSE, window_rename_cancel_cb, rw);
2402         rw->button_ok = generic_dialog_add_button(rw->gd, GTK_STOCK_OK, _("OK"), window_rename_ok_cb, TRUE);
2403
2404         generic_dialog_add_message(rw->gd, NULL, _("rename window"), NULL, FALSE);
2405
2406         hbox = pref_box_new(rw->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
2407         pref_spacer(hbox, PREF_PAD_INDENT);
2408
2409         hbox = pref_box_new(rw->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2410
2411         rw->window_name_entry = gtk_entry_new();
2412         gtk_widget_set_can_focus(rw->window_name_entry, TRUE);
2413         gtk_editable_set_editable(GTK_EDITABLE(rw->window_name_entry), TRUE);
2414         gtk_entry_set_text(GTK_ENTRY(rw->window_name_entry), lw->options.id);
2415         gtk_box_pack_start(GTK_BOX(hbox), rw->window_name_entry, TRUE, TRUE, 0);
2416         gtk_widget_grab_focus(GTK_WIDGET(rw->window_name_entry));
2417         gtk_widget_show(rw->window_name_entry);
2418         g_signal_connect(rw->window_name_entry, "activate", G_CALLBACK(window_rename_entry_activate_cb), rw);
2419
2420         gtk_widget_show(rw->gd->dialog);
2421 }
2422
2423 static void layout_menu_window_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
2424 {
2425         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2426         DeleteWindow *dw;
2427         GtkWidget *hbox;
2428
2429         dw = g_new0(DeleteWindow, 1);
2430         dw->lw = lw;
2431
2432         dw->gd = generic_dialog_new(_("Delete window"), "delete_window", NULL, TRUE, window_delete_cancel_cb, dw);
2433         dw->button_ok = generic_dialog_add_button(dw->gd, GTK_STOCK_OK, _("OK"), window_delete_ok_cb, TRUE);
2434
2435         generic_dialog_add_message(dw->gd, NULL, _("Delete window layout"), NULL, FALSE);
2436
2437         hbox = pref_box_new(dw->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
2438         pref_spacer(hbox, PREF_PAD_INDENT);
2439         dw->group = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2440
2441         hbox = pref_box_new(dw->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2442         pref_label_new(hbox, (lw->options.id));
2443
2444         gtk_widget_show(dw->gd->dialog);
2445 }
2446
2447 /*
2448  *-----------------------------------------------------------------------------
2449  * menu
2450  *-----------------------------------------------------------------------------
2451  */
2452
2453 #define CB G_CALLBACK
2454 /**
2455  * tooltip is used as the description field in the Help manual shortcuts documentation
2456  *
2457  * struct GtkActionEntry:
2458  *  name, stock_id, label, accelerator, tooltip, callback
2459  */
2460 static GtkActionEntry menu_entries[] = {
2461   { "FileMenu",         NULL,                   N_("_File"),                            NULL,                   NULL,                                   NULL },
2462   { "GoMenu",           NULL,                   N_("_Go"),                              NULL,                   NULL,                                   NULL },
2463   { "EditMenu",         NULL,                   N_("_Edit"),                            NULL,                   NULL,                                   NULL },
2464   { "SelectMenu",       NULL,                   N_("_Select"),                          NULL,                   NULL,                                   NULL },
2465   { "OrientationMenu",  NULL,                   N_("_Orientation"),                     NULL,                   NULL,                                   NULL },
2466   { "RatingMenu",       NULL,                   N_("_Rating"),                                  NULL,                   NULL,                                   NULL },
2467   { "PreferencesMenu",  NULL,                   N_("P_references"),                     NULL,                   NULL,                                   NULL },
2468   { "ViewMenu",         NULL,                   N_("_View"),                            NULL,                   NULL,                                   CB(layout_menu_view_menu_cb)  },
2469   { "FileDirMenu",      NULL,                   N_("_Files and Folders"),               NULL,                   NULL,                                   NULL },
2470   { "ZoomMenu",         NULL,                   N_("_Zoom"),                            NULL,                   NULL,                                   NULL },
2471   { "ColorMenu",        NULL,                   N_("_Color Management"),                NULL,                   NULL,                                   NULL },
2472   { "ConnectZoomMenu",  NULL,                   N_("_Connected Zoom"),                  NULL,                   NULL,                                   NULL },
2473   { "SplitMenu",        NULL,                   N_("Spli_t"),                           NULL,                   NULL,                                   NULL },
2474   { "StereoMenu",       NULL,                   N_("Stere_o"),                          NULL,                   NULL,                                   NULL },
2475   { "OverlayMenu",      NULL,                   N_("Image _Overlay"),                   NULL,                   NULL,                                   NULL },
2476   { "PluginsMenu",      NULL,                   N_("_Plugins"),                         NULL,                   NULL,                                   NULL },
2477   { "WindowsMenu",              NULL,           N_("_Windows"),                         NULL,                   NULL,                                   CB(layout_menu_windows_menu_cb)  },
2478   { "HelpMenu",         NULL,                   N_("_Help"),                            NULL,                   NULL,                                   NULL },
2479
2480   { "Copy",             GTK_STOCK_COPY,         N_("_Copy..."),                         "<control>C",           N_("Copy..."),                          CB(layout_menu_copy_cb) },
2481   { "Move",     PIXBUF_INLINE_ICON_MOVE,                        N_("_Move..."),                         "<control>M",           N_("Move..."),                          CB(layout_menu_move_cb) },
2482   { "Rename",   PIXBUF_INLINE_ICON_RENAME,      N_("_Rename..."),                       "<control>R",           N_("Rename..."),                        CB(layout_menu_rename_cb) },
2483   { "Delete",   PIXBUF_INLINE_ICON_TRASH,       N_("Move to Trash..."),         "<control>D",   N_("Move to Trash..."),         CB(layout_menu_move_to_trash_cb) },
2484   { "DeleteAlt1",       PIXBUF_INLINE_ICON_TRASH,N_("Move to Trash..."),        "Delete",               N_("Move to Trash..."),         CB(layout_menu_move_to_trash_key_cb) },
2485   { "DeleteAlt2",       PIXBUF_INLINE_ICON_TRASH,N_("Move to Trash..."),        "KP_Delete",    N_("Move to Trash..."),         CB(layout_menu_move_to_trash_key_cb) },
2486   { "PermanentDelete",  GTK_STOCK_DELETE,       N_("Delete..."),                        "<shift>Delete",N_("Delete..."),                        CB(layout_menu_delete_cb) },
2487   { "SelectAll",        PIXBUF_INLINE_ICON_SELECT_ALL,                  N_("Select _all"),                      "<control>A",           N_("Select all"),                       CB(layout_menu_select_all_cb) },
2488   { "SelectNone",       PIXBUF_INLINE_ICON_SELECT_NONE,                 N_("Select _none"),                     "<control><shift>A",    N_("Select none"),                      CB(layout_menu_unselect_all_cb) },
2489   { "SelectInvert",     PIXBUF_INLINE_ICON_SELECT_INVERT,                       N_("_Invert Selection"),                "<control><shift>I",    N_("Invert Selection"),                 CB(layout_menu_invert_selection_cb) },
2490   { "CloseWindow",      GTK_STOCK_CLOSE,        N_("C_lose window"),                    "<control>W",           N_("Close window"),                     CB(layout_menu_close_cb) },
2491   { "Quit",             GTK_STOCK_QUIT,         N_("_Quit"),                            "<control>Q",           N_("Quit"),                             CB(layout_menu_exit_cb) },
2492   { "FirstImage",       GTK_STOCK_GOTO_TOP,     N_("_First Image"),                     "Home",                 N_("First Image"),                      CB(layout_menu_image_first_cb) },
2493   { "PrevImage",        GTK_STOCK_GO_UP,        N_("_Previous Image"),                  "BackSpace",            N_("Previous Image"),                   CB(layout_menu_image_prev_cb) },
2494   { "PrevImageAlt1",    GTK_STOCK_GO_UP,        N_("_Previous Image"),                  "Page_Up",              N_("Previous Image"),                   CB(layout_menu_image_prev_cb) },
2495   { "PrevImageAlt2",    GTK_STOCK_GO_UP,        N_("_Previous Image"),                  "KP_Page_Up",           N_("Previous Image"),                   CB(layout_menu_image_prev_cb) },
2496   { "NextImage",        GTK_STOCK_GO_DOWN,      N_("_Next Image"),                      "space",                N_("Next Image"),                       CB(layout_menu_image_next_cb) },
2497   { "NextImageAlt1",    GTK_STOCK_GO_DOWN,      N_("_Next Image"),                      "Page_Down",            N_("Next Image"),                       CB(layout_menu_image_next_cb) },
2498
2499   { "ImageForward",     GTK_STOCK_GOTO_LAST,    N_("Image Forward"),    NULL,   N_("Forward in image history"), CB(layout_menu_image_forward_cb) },
2500   { "ImageBack",        GTK_STOCK_GOTO_FIRST,   N_("Image Back"),               NULL,   N_("Back in image history"),            CB(layout_menu_image_back_cb) },
2501
2502   { "FirstPage",GTK_STOCK_MEDIA_PREVIOUS,       N_("_First Page"),              NULL,   N_( "First Page of multi-page image"),  CB(layout_menu_page_first_cb) },
2503   { "LastPage", GTK_STOCK_MEDIA_NEXT,           N_("_Last Page"),               NULL,   N_("Last Page of multi-page image"),    CB(layout_menu_page_last_cb) },
2504   { "NextPage", GTK_STOCK_MEDIA_FORWARD,        N_("_Next Page"),               NULL,   N_("Next Page of multi-page image"),    CB(layout_menu_page_next_cb) },
2505   { "PrevPage", GTK_STOCK_MEDIA_REWIND,         N_("_Previous Page"),   NULL,   N_("Previous Page of multi-page image"),        CB(layout_menu_page_previous_cb) },
2506
2507
2508   { "NextImageAlt2",    GTK_STOCK_GO_DOWN,      N_("_Next Image"),                      "KP_Page_Down",         N_("Next Image"),               CB(layout_menu_image_next_cb) },
2509   { "LastImage",        GTK_STOCK_GOTO_BOTTOM,  N_("_Last Image"),                      "End",                  N_("Last Image"),                       CB(layout_menu_image_last_cb) },
2510   { "Back",             GTK_STOCK_GO_BACK,      N_("_Back"),                    NULL,   N_("Back in folder history"),           CB(layout_menu_back_cb) },
2511   { "Forward",  GTK_STOCK_GO_FORWARD,   N_("_Forward"),         NULL,   N_("Forward in folder history"),        CB(layout_menu_forward_cb) },
2512   { "Home",             GTK_STOCK_HOME,         N_("_Home"),                    NULL,   N_("Home"),                             CB(layout_menu_home_cb) },
2513   { "Up",               GTK_STOCK_GO_UP,        N_("_Up"),                              NULL,   N_("Up one folder"),                            CB(layout_menu_up_cb) },
2514   { "NewWindow",        NULL,           N_("New window"),                       NULL,           N_("New window"),       CB(layout_menu_window_cb) },
2515   { "NewWindowDefault", NULL,   N_("default"),                  "<control>N",           N_("New window (default)"),     CB(layout_menu_window_default_cb)  },
2516   { "NewWindowFromCurrent",     NULL,   N_("from current"),                     NULL,           N_("from current"),     CB(layout_menu_window_from_current_cb)  },
2517   { "RenameWindow",     GTK_STOCK_EDIT,         N_("Rename window"),    NULL,   N_("Rename window"),    CB(layout_menu_window_rename_cb) },
2518   { "DeleteWindow",     GTK_STOCK_DELETE,               N_("Delete window"),    NULL,   N_("Delete window"),    CB(layout_menu_window_delete_cb) },
2519   { "NewCollection",    GTK_STOCK_INDEX,        N_("_New collection"),                  "C",                    N_("New collection"),                   CB(layout_menu_new_cb) },
2520   { "OpenCollection",   GTK_STOCK_OPEN,         N_("_Open collection..."),              "O",                    N_("Open collection..."),               CB(layout_menu_open_cb) },
2521   { "OpenRecent",       NULL,                   N_("Open recen_t"),                     NULL,                   N_("Open recent collection"),                   NULL },
2522   { "Search",           GTK_STOCK_FIND,         N_("_Search..."),                       "F3",                   N_("Search..."),                        CB(layout_menu_search_cb) },
2523   { "FindDupes",        GTK_STOCK_FIND,         N_("_Find duplicates..."),              "D",                    N_("Find duplicates..."),               CB(layout_menu_dupes_cb) },
2524   { "PanView",  PIXBUF_INLINE_ICON_PANORAMA,    N_("Pa_n view"),                        "<control>J",           N_("Pan view"),                         CB(layout_menu_pan_cb) },
2525   { "Print",            GTK_STOCK_PRINT,        N_("_Print..."),                        "<shift>P",             N_("Print..."),                         CB(layout_menu_print_cb) },
2526   { "NewFolder",        GTK_STOCK_DIRECTORY,    N_("N_ew folder..."),                   "<control>F",           N_("New folder..."),                    CB(layout_menu_dir_cb) },
2527   { "EnableGrouping",   NULL,                   N_("Enable file _grouping"),            NULL,                   N_("Enable file grouping"),             CB(layout_menu_enable_grouping_cb) },
2528   { "DisableGrouping",  NULL,                   N_("Disable file groupi_ng"),           NULL,                   N_("Disable file grouping"),            CB(layout_menu_disable_grouping_cb) },
2529   { "CopyPath",         NULL,                   N_("_Copy path to clipboard"),          NULL,                   N_("Copy path to clipboard"),           CB(layout_menu_copy_path_cb) },
2530   { "CopyPathUnquoted",         NULL,                   N_("_Copy path unquoted to clipboard"),         NULL,                   N_("Copy path unquoted to clipboard"),          CB(layout_menu_copy_path_unquoted_cb) },
2531   { "Rating0",          NULL,                   N_("_Rating 0"),        "<alt>KP_0",    N_("Rating 0"),                 CB(layout_menu_rating_0_cb) },
2532   { "Rating1",          NULL,                   N_("_Rating 1"),        "<alt>KP_1",    N_("Rating 1"),                 CB(layout_menu_rating_1_cb) },
2533   { "Rating2",          NULL,                   N_("_Rating 2"),        "<alt>KP_2",    N_("Rating 2"),                 CB(layout_menu_rating_2_cb) },
2534   { "Rating3",          NULL,                   N_("_Rating 3"),        "<alt>KP_3",    N_("Rating 3"),                 CB(layout_menu_rating_3_cb) },
2535   { "Rating4",          NULL,                   N_("_Rating 4"),        "<alt>KP_4",    N_("Rating 4"),                 CB(layout_menu_rating_4_cb) },
2536   { "Rating5",          NULL,                   N_("_Rating 5"),        "<alt>KP_5",    N_("Rating 5"),                 CB(layout_menu_rating_5_cb) },
2537   { "RatingM1",         NULL,                   N_("_Rating -1"),       "<alt>KP_Subtract",     N_("Rating -1"),        CB(layout_menu_rating_m1_cb) },
2538   { "RotateCW",         PIXBUF_INLINE_ICON_CW,                  N_("_Rotate clockwise 90°"),           "bracketright",         N_("Image Rotate clockwise 90°"),                      CB(layout_menu_alter_90_cb) },
2539   { "RotateCCW",        PIXBUF_INLINE_ICON_CCW, N_("Rotate _counterclockwise 90°"),            "bracketleft",          N_("Rotate counterclockwise 90°"),             CB(layout_menu_alter_90cc_cb) },
2540   { "Rotate180",        PIXBUF_INLINE_ICON_180, N_("Rotate 1_80°"),    "<shift>R",             N_("Image Rotate 180°"),                       CB(layout_menu_alter_180_cb) },
2541   { "Mirror",           PIXBUF_INLINE_ICON_MIRROR,      N_("_Mirror"),  "<shift>M",             N_("Image Mirror"),                             CB(layout_menu_alter_mirror_cb) },
2542   { "Flip",             PIXBUF_INLINE_ICON_FLIP,        N_("_Flip"),    "<shift>F",             N_("Image Flip"),                               CB(layout_menu_alter_flip_cb) },
2543   { "AlterNone",        PIXBUF_INLINE_ICON_ORIGINAL,    N_("_Original state"),  "<shift>O",             N_("Image rotate Original state"),                      CB(layout_menu_alter_none_cb) },
2544   { "Preferences",      GTK_STOCK_PREFERENCES,  N_("P_references..."),                  "<control>O",           N_("Preferences..."),                   CB(layout_menu_config_cb) },
2545   { "Plugins",          GTK_STOCK_PREFERENCES,  N_("Configure _Plugins..."),            NULL,                   N_("Configure Plugins..."),             CB(layout_menu_editors_cb) },
2546   { "LayoutConfig",     GTK_STOCK_PREFERENCES,  N_("_Configure this window..."),        NULL,                   N_("Configure this window..."),         CB(layout_menu_layout_config_cb) },
2547   { "Maintenance",      PIXBUF_INLINE_ICON_MAINTENANCE, N_("_Cache maintenance..."),    NULL,                   N_("Cache maintenance..."),             CB(layout_menu_remove_thumb_cb) },
2548   { "Wallpaper",        NULL,                   N_("Set as _wallpaper"),                NULL,                   N_("Set as wallpaper"),                 CB(layout_menu_wallpaper_cb) },
2549   { "SaveMetadata",     GTK_STOCK_SAVE,         N_("_Save metadata"),                   "<control>S",           N_("Save metadata"),                    CB(layout_menu_metadata_write_cb) },
2550   { "KeywordAutocomplete",      NULL,   N_("Keyword autocomplete"),             "<alt>K",               N_("Keyword Autocomplete"),                     CB(layout_menu_keyword_autocomplete_cb) },
2551   { "ZoomInAlt1",       GTK_STOCK_ZOOM_IN,      N_("Zoom _in"),                         "KP_Add",               N_("Zoom in"),                          CB(layout_menu_zoom_in_cb) },
2552   { "ZoomIn",           GTK_STOCK_ZOOM_IN,      N_("Zoom _in"),                         "equal",                N_("Zoom in"),                          CB(layout_menu_zoom_in_cb) },
2553   { "ZoomOut",          GTK_STOCK_ZOOM_OUT,     N_("Zoom _out"),                        "minus",                N_("Zoom out"),                         CB(layout_menu_zoom_out_cb) },
2554   { "ZoomOutAlt1",      GTK_STOCK_ZOOM_OUT,     N_("Zoom _out"),                        "KP_Subtract",          N_("Zoom out"),                         CB(layout_menu_zoom_out_cb) },
2555   { "Zoom100",          GTK_STOCK_ZOOM_100,     N_("Zoom _1:1"),                        "Z",                    N_("Zoom 1:1"),                         CB(layout_menu_zoom_1_1_cb) },
2556   { "Zoom100Alt1",      GTK_STOCK_ZOOM_100,     N_("Zoom _1:1"),                        "KP_Divide",            N_("Zoom 1:1"),                         CB(layout_menu_zoom_1_1_cb) },
2557   { "ZoomFitAlt1",      GTK_STOCK_ZOOM_FIT,     N_("_Zoom to fit"),                     "KP_Multiply",          N_("Zoom to fit"),                      CB(layout_menu_zoom_fit_cb) },
2558   { "ZoomFit",          GTK_STOCK_ZOOM_FIT,     N_("_Zoom to fit"),                     "X",                    N_("Zoom to fit"),                      CB(layout_menu_zoom_fit_cb) },
2559   { "ZoomFillHor",      PIXBUF_INLINE_ICON_ZOOMFILLHOR, N_("Fit _Horizontally"),                "H",                    N_("Fit Horizontally"),                 CB(layout_menu_zoom_fit_hor_cb) },
2560   { "ZoomFillVert",     PIXBUF_INLINE_ICON_ZOOMFILLVERT,        N_("Fit _Vertically"),                  "W",                    N_("Fit Vertically"),                   CB(layout_menu_zoom_fit_vert_cb) },
2561   { "Zoom200",          GTK_STOCK_FILE,                 N_("Zoom _2:1"),                        NULL,                   N_("Zoom 2:1"),                         CB(layout_menu_zoom_2_1_cb) },
2562   { "Zoom300",          GTK_STOCK_FILE,                 N_("Zoom _3:1"),                        NULL,                   N_("Zoom 3:1"),                         CB(layout_menu_zoom_3_1_cb) },
2563   { "Zoom400",          GTK_STOCK_FILE,                 N_("Zoom _4:1"),                        NULL,                   N_("Zoom 4:1"),                         CB(layout_menu_zoom_4_1_cb) },
2564   { "Zoom50",           GTK_STOCK_FILE,                 N_("Zoom 1:2"),                         NULL,                   N_("Zoom 1:2"),                         CB(layout_menu_zoom_1_2_cb) },
2565   { "Zoom33",           GTK_STOCK_FILE,                 N_("Zoom 1:3"),                         NULL,                   N_("Zoom 1:3"),                         CB(layout_menu_zoom_1_3_cb) },
2566   { "Zoom25",           GTK_STOCK_FILE,                 N_("Zoom 1:4"),                         NULL,                   N_("Zoom 1:4"),                         CB(layout_menu_zoom_1_4_cb) },
2567   { "ConnectZoomIn",    GTK_STOCK_ZOOM_IN,      N_("Zoom _in"),                         "plus",                 N_("Connected Zoom in"),                CB(layout_menu_connect_zoom_in_cb) },
2568   { "ConnectZoomInAlt1",GTK_STOCK_ZOOM_IN,      N_("Zoom _in"),                         "<shift>KP_Add",        N_("Connected Zoom in"),                CB(layout_menu_connect_zoom_in_cb) },
2569   { "ConnectZoomOut",   GTK_STOCK_ZOOM_OUT,     N_("Zoom _out"),                        "underscore",           N_("Connected Zoom out"),               CB(layout_menu_connect_zoom_out_cb) },
2570   { "ConnectZoomOutAlt1",GTK_STOCK_ZOOM_OUT,    N_("Zoom _out"),                        "<shift>KP_Subtract",   N_("Connected Zoom out"),               CB(layout_menu_connect_zoom_out_cb) },
2571   { "ConnectZoom100",   GTK_STOCK_ZOOM_100,     N_("Zoom _1:1"),                        "<shift>Z",             N_("Connected Zoom 1:1"),               CB(layout_menu_connect_zoom_1_1_cb) },
2572   { "ConnectZoom100Alt1",GTK_STOCK_ZOOM_100,    N_("Zoom _1:1"),                        "<shift>KP_Divide",     N_("Connected Zoom 1:1"),               CB(layout_menu_connect_zoom_1_1_cb) },
2573   { "ConnectZoomFit",   GTK_STOCK_ZOOM_FIT,     N_("_Zoom to fit"),                     "<shift>X",             N_("Connected Zoom to fit"),            CB(layout_menu_connect_zoom_fit_cb) },
2574   { "ConnectZoomFitAlt1",GTK_STOCK_ZOOM_FIT,    N_("_Zoom to fit"),                     "<shift>KP_Multiply",   N_("Connected Zoom to fit"),            CB(layout_menu_connect_zoom_fit_cb) },
2575   { "ConnectZoomFillHor",NULL,                  N_("Fit _Horizontally"),                "<shift>H",             N_("Connected Fit Horizontally"),       CB(layout_menu_connect_zoom_fit_hor_cb) },
2576   { "ConnectZoomFillVert",NULL,                 N_("Fit _Vertically"),                  "<shift>W",             N_("Connected Fit Vertically"),         CB(layout_menu_connect_zoom_fit_vert_cb) },
2577   { "ConnectZoom200",   NULL,                   N_("Zoom _2:1"),                        NULL,                   N_("Connected Zoom 2:1"),               CB(layout_menu_connect_zoom_2_1_cb) },
2578   { "ConnectZoom300",   NULL,                   N_("Zoom _3:1"),                        NULL,                   N_("Connected Zoom 3:1"),               CB(layout_menu_connect_zoom_3_1_cb) },
2579   { "ConnectZoom400",   NULL,                   N_("Zoom _4:1"),                        NULL,                   N_("Connected Zoom 4:1"),               CB(layout_menu_connect_zoom_4_1_cb) },
2580   { "ConnectZoom50",    NULL,                   N_("Zoom 1:2"),                         NULL,                   N_("Connected Zoom 1:2"),               CB(layout_menu_connect_zoom_1_2_cb) },
2581   { "ConnectZoom33",    NULL,                   N_("Zoom 1:3"),                         NULL,                   N_("Connected Zoom 1:3"),               CB(layout_menu_connect_zoom_1_3_cb) },
2582   { "ConnectZoom25",    NULL,                   N_("Zoom 1:4"),                         NULL,                   N_("Connected Zoom 1:4"),               CB(layout_menu_connect_zoom_1_4_cb) },
2583   { "ViewInNewWindow",  NULL,                   N_("_View in new window"),              "<control>V",           N_("View in new window"),               CB(layout_menu_view_in_new_window_cb) },
2584   { "OpenArchive",      GTK_STOCK_OPEN,                 N_("Open archive"),             NULL,           N_("Open archive"),             CB(layout_menu_open_archive_cb) },
2585   { "FullScreen",       GTK_STOCK_FULLSCREEN,   N_("F_ull screen"),                     "F",                    N_("Full screen"),                      CB(layout_menu_fullscreen_cb) },
2586   { "FullScreenAlt1",   GTK_STOCK_FULLSCREEN,   N_("F_ull screen"),                     "V",                    N_("Full screen"),                      CB(layout_menu_fullscreen_cb) },
2587   { "FullScreenAlt2",   GTK_STOCK_FULLSCREEN,   N_("F_ull screen"),                     "F11",                  N_("Full screen"),                      CB(layout_menu_fullscreen_cb) },
2588   { "Escape",           GTK_STOCK_LEAVE_FULLSCREEN,N_("_Leave full screen"),            "Escape",               N_("Leave full screen"),                CB(layout_menu_escape_cb) },
2589   { "EscapeAlt1",       GTK_STOCK_LEAVE_FULLSCREEN,N_("_Leave full screen"),            "Q",                    N_("Leave full screen"),                CB(layout_menu_escape_cb) },
2590   { "ImageOverlayCycle",NULL,                   N_("_Cycle through overlay modes"),     "I",                    N_("Cycle through Overlay modes"),      CB(layout_menu_overlay_toggle_cb) },
2591   { "HistogramChanCycle",NULL,                  N_("Cycle through histogram ch_annels"),"K",                    N_("Cycle through histogram channels"), CB(layout_menu_histogram_toggle_channel_cb) },
2592   { "HistogramModeCycle",NULL,                  N_("Cycle through histogram mo_des"),   "J",                    N_("Cycle through histogram modes"),    CB(layout_menu_histogram_toggle_mode_cb) },
2593   { "HideTools",        PIXBUF_INLINE_ICON_HIDETOOLS,   N_("_Hide file list"),                  "<control>H",           N_("Hide file list"),                   CB(layout_menu_hide_cb) },
2594   { "SlideShowPause",   GTK_STOCK_MEDIA_PAUSE,  N_("_Pause slideshow"),                 "P",                    N_("Pause slideshow"),                  CB(layout_menu_slideshow_pause_cb) },
2595   { "SlideShowFaster",  GTK_STOCK_FILE, N_("Faster"),           "<control>equal",                       N_("Slideshow Faster"),                         CB(layout_menu_slideshow_faster_cb) },
2596   { "SlideShowSlower",  GTK_STOCK_FILE, N_("Slower"),           "<control>minus",                       N_("Slideshow Slower"),                         CB(layout_menu_slideshow_slower_cb) },
2597   { "Refresh",          GTK_STOCK_REFRESH,      N_("_Refresh"),                         "R",                    N_("Refresh"),                          CB(layout_menu_refresh_cb) },
2598   { "HelpContents",     GTK_STOCK_HELP,         N_("_Help manual"),                     "F1",                   N_("Help manual"),                              CB(layout_menu_help_cb) },
2599   { "HelpSearch",       NULL,           N_("On-line help search"),                      NULL,                   N_("On-line help search"),                              CB(layout_menu_help_search_cb) },
2600   { "HelpShortcuts",    NULL,                   N_("_Keyboard shortcuts"),              NULL,                   N_("Keyboard shortcuts"),               CB(layout_menu_help_keys_cb) },
2601   { "HelpKbd",          NULL,                   N_("_Keyboard map"),                    NULL,                   N_("Keyboard map"),                     CB(layout_menu_kbd_map_cb) },
2602   { "HelpNotes",        NULL,                   N_("_Readme"),                  NULL,                   N_("Readme"),                   CB(layout_menu_notes_cb) },
2603   { "HelpChangeLog",    NULL,                   N_("_ChangeLog"),                       NULL,                   N_("ChangeLog notes"),                  CB(layout_menu_changelog_cb) },
2604   { "SearchAndRunCommand",      GTK_STOCK_FIND,         N_("Search and Run command"),   "slash",        N_("Search commands by keyword and run them"),  CB(layout_menu_search_and_run_cb) },
2605   { "About",            GTK_STOCK_ABOUT,        N_("_About"),                           NULL,                   N_("About"),                            CB(layout_menu_about_cb) },
2606   { "LogWindow",        NULL,                   N_("_Log Window"),                      NULL,                   N_("Log Window"),                       CB(layout_menu_log_window_cb) },
2607   { "ExifWin",          PIXBUF_INLINE_ICON_EXIF,        N_("_Exif window"),                     "<control>E",           N_("Exif window"),                      CB(layout_menu_bar_exif_cb) },
2608   { "StereoCycle",      NULL,                   N_("_Cycle through stereo modes"),      NULL,                   N_("Cycle through stereo modes"),       CB(layout_menu_stereo_mode_next_cb) },
2609   { "SplitNextPane",    NULL,                   N_("_Next Pane"),       "<alt>Right",                   N_("Next Split Pane"),  CB(layout_menu_split_pane_next_cb) },
2610   { "SplitPreviousPane",        NULL,                   N_("_Previous Pane"),   "<alt>Left",                    N_("Previous Split Pane"),      CB(layout_menu_split_pane_prev_cb) },
2611   { "SplitUpPane",      NULL,                   N_("_Up Pane"), "<alt>Up",                      N_("Up Split Pane"),    CB(layout_menu_split_pane_updown_cb) },
2612   { "SplitDownPane",    NULL,                   N_("_Down Pane"),       "<alt>Down",                    N_("Down Split Pane"),  CB(layout_menu_split_pane_updown_cb) },
2613   { "WriteRotation",    NULL,                   N_("_Write orientation to file"),               NULL,           N_("Write orientation to file"),                        CB(layout_menu_write_rotate_cb) },
2614   { "WriteRotationKeepDate",    NULL,                   N_("_Write orientation to file (preserve timestamp)"),                  NULL,           N_("Write orientation to file (preserve timestamp)"),                   CB(layout_menu_write_rotate_keep_date_cb) },
2615   { "ClearMarks",       NULL,           N_("Clear Marks..."),                   NULL,           N_("Clear Marks"),                      CB(layout_menu_clear_marks_cb) },
2616 };
2617
2618 static GtkToggleActionEntry menu_toggle_entries[] = {
2619   { "Thumbnails",       PIXBUF_INLINE_ICON_THUMB,N_("Show _Thumbnails"),                "T",                    N_("Show Thumbnails"),                  CB(layout_menu_thumb_cb),        FALSE },
2620   { "ShowMarks",        PIXBUF_INLINE_ICON_MARKS,       N_("Show _Marks"),                      "M",                    N_("Show Marks"),                       CB(layout_menu_marks_cb),        FALSE  },
2621   { "ShowFileFilter", PIXBUF_INLINE_ICON_FILE_FILTER,   N_("Show File Filter"), NULL,   N_("Show File Filter"), CB(layout_menu_file_filter_cb),  FALSE  },
2622   { "ShowInfoPixel",    GTK_STOCK_COLOR_PICKER, N_("Pi_xel Info"),                      NULL,                   N_("Show Pixel Info"),                  CB(layout_menu_info_pixel_cb),   FALSE  },
2623   { "IgnoreAlpha", GTK_STOCK_STRIKETHROUGH,           N_("Hide _alpha"),          "<shift>A",     N_("Hide alpha channel"),       CB(layout_menu_alter_ignore_alpha_cb), FALSE},
2624   { "FloatTools",       PIXBUF_INLINE_ICON_FLOAT,N_("_Float file list"),                "L",                    N_("Float file list"),                  CB(layout_menu_float_cb),        FALSE  },
2625   { "HideToolbar",      NULL,                   N_("Hide tool_bar"),                    NULL,                   N_("Hide toolbar"),                     CB(layout_menu_toolbar_cb),      FALSE  },
2626   { "SBar",     PIXBUF_INLINE_ICON_INFO,        N_("_Info sidebar"),                    "<control>K",           N_("Info sidebar"),                     CB(layout_menu_bar_cb),          FALSE  },
2627   { "SBarSort", PIXBUF_INLINE_ICON_SORT,        N_("Sort _manager"),                    "<shift>S",             N_("Sort manager"),                     CB(layout_menu_bar_sort_cb),     FALSE  },
2628   { "HideBars",         NULL,                   N_("Hide Bars"),                        "grave",                N_("Hide Bars"),                        CB(layout_menu_hide_bars_cb),    FALSE  },
2629   { "SlideShow",        GTK_STOCK_MEDIA_PLAY,   N_("Toggle _slideshow"),                "S",                    N_("Toggle slideshow"),                 CB(layout_menu_slideshow_cb),    FALSE  },
2630   { "UseColorProfiles", GTK_STOCK_SELECT_COLOR, N_("Use _color profiles"),              NULL,                   N_("Use color profiles"),               CB(layout_color_menu_enable_cb), FALSE},
2631   { "UseImageProfile",  NULL,                   N_("Use profile from _image"),          NULL,                   N_("Use profile from image"),           CB(layout_color_menu_use_image_cb), FALSE},
2632   { "Grayscale",        PIXBUF_INLINE_ICON_GRAYSCALE,   N_("Toggle _grayscale"),        "<shift>G",             N_("Toggle grayscale"),         CB(layout_menu_alter_desaturate_cb), FALSE},
2633   { "ImageOverlay",     NULL,                   N_("Image _Overlay"),                   NULL,                   N_("Image Overlay"),                    CB(layout_menu_overlay_cb),      FALSE },
2634   { "ImageHistogram",   NULL,                   N_("_Show Histogram"),                  NULL,                   N_("Show Histogram"),                   CB(layout_menu_histogram_cb),    FALSE },
2635   { "RectangularSelection",     PIXBUF_INLINE_ICON_SELECT_RECTANGLE,    N_("Rectangular Selection"),                    "<alt>R",                       N_("Rectangular Selection"),                    CB(layout_menu_rectangular_selection_cb),        FALSE },
2636   { "Animate",  NULL,   N_("_Animation"),               "A",                    N_("Toggle animation"),                 CB(layout_menu_animate_cb),      FALSE  },
2637   { "ExifRotate",       GTK_STOCK_ORIENTATION_PORTRAIT,                 N_("_Exif rotate"),             "<alt>X",               N_("Toggle Exif rotate"),                       CB(layout_menu_exif_rotate_cb), FALSE },
2638   { "DrawRectangle",    PIXBUF_INLINE_ICON_DRAW_RECTANGLE,                      N_("Draw Rectangle"),           NULL,           N_("Draw Rectangle"),                   CB(layout_menu_select_rectangle_cb), FALSE },
2639   { "OverUnderExposed", PIXBUF_INLINE_ICON_EXPOSURE,    N_("Over/Under Exposed"),       "<shift>E",             N_("Highlight over/under exposed"),             CB(layout_menu_select_overunderexposed_cb), FALSE },
2640   { "SplitPaneSync",    PIXBUF_INLINE_SPLIT_PANE_SYNC,                  N_("Split Pane Sync"),  NULL,           N_("Split Pane Sync"),  CB(layout_menu_split_pane_sync_cb), FALSE },
2641 };
2642
2643 static GtkRadioActionEntry menu_radio_entries[] = {
2644   { "ViewList",         NULL,                   N_("Images as _List"),                  "<control>L",           N_("View Images as List"),              FILEVIEW_LIST },
2645   { "ViewIcons",        NULL,                   N_("Images as I_cons"),                 "<control>I",           N_("View Images as Icons"),             FILEVIEW_ICON }
2646 };
2647
2648 static GtkToggleActionEntry menu_view_dir_toggle_entries[] = {
2649   { "FolderTree",       NULL,                   N_("T_oggle Folder View"),                      "<control>T",           N_("Toggle Folders View"),              CB(layout_menu_view_dir_as_cb),FALSE },
2650 };
2651
2652 static GtkRadioActionEntry menu_split_radio_entries[] = {
2653   { "SplitHorizontal",  NULL,                   N_("_Horizontal"),                      "E",                    N_("Split panes horizontal."),                  SPLIT_HOR },
2654   { "SplitVertical",    NULL,                   N_("_Vertical"),                        "U",                    N_("Split panes vertical"),                             SPLIT_VERT },
2655   { "SplitTriple",      NULL,                   N_("_Triple"),                          NULL,                   N_("Split panes triple"),                               SPLIT_TRIPLE },
2656   { "SplitQuad",        NULL,                   N_("_Quad"),                            NULL,                   N_("Split panes quad"),                         SPLIT_QUAD },
2657   { "SplitSingle",      NULL,                   N_("_Single"),                          "Y",                    N_("Single pane"),                              SPLIT_NONE }
2658 };
2659
2660 static GtkRadioActionEntry menu_color_radio_entries[] = {
2661   { "ColorProfile0",    NULL,                   N_("Input _0: sRGB"),                   NULL,                   N_("Input 0: sRGB"),                    COLOR_PROFILE_SRGB },
2662   { "ColorProfile1",    NULL,                   N_("Input _1: AdobeRGB compatible"),    NULL,                   N_("Input 1: AdobeRGB compatible"),     COLOR_PROFILE_ADOBERGB },
2663   { "ColorProfile2",    NULL,                   N_("Input _2"),                         NULL,                   N_("Input 2"),                          COLOR_PROFILE_FILE },
2664   { "ColorProfile3",    NULL,                   N_("Input _3"),                         NULL,                   N_("Input 3"),                          COLOR_PROFILE_FILE + 1 },
2665   { "ColorProfile4",    NULL,                   N_("Input _4"),                         NULL,                   N_("Input 4"),                          COLOR_PROFILE_FILE + 2 },
2666   { "ColorProfile5",    NULL,                   N_("Input _5"),                         NULL,                   N_("Input 5"),                          COLOR_PROFILE_FILE + 3 }
2667 };
2668
2669 static GtkRadioActionEntry menu_histogram_channel[] = {
2670   { "HistogramChanR",   NULL,                   N_("Histogram on _Red"),                NULL,                   N_("Histogram on Red"),         HCHAN_R },
2671   { "HistogramChanG",   NULL,                   N_("Histogram on _Green"),              NULL,                   N_("Histogram on Green"),       HCHAN_G },
2672   { "HistogramChanB",   NULL,                   N_("Histogram on _Blue"),               NULL,                   N_("Histogram on Blue"),        HCHAN_B },
2673   { "HistogramChanRGB", NULL,                   N_("_Histogram on RGB"),                        NULL,                   N_("Histogram on RGB"),         HCHAN_RGB },
2674   { "HistogramChanV",   NULL,                   N_("Histogram on _Value"),              NULL,                   N_("Histogram on Value"),       HCHAN_MAX }
2675 };
2676
2677 static GtkRadioActionEntry menu_histogram_mode[] = {
2678   { "HistogramModeLin", NULL,                   N_("Li_near Histogram"),                NULL,                   N_("Linear Histogram"),         0 },
2679   { "HistogramModeLog", NULL,                   N_("_Log Histogram"),                   NULL,                   N_("Log Histogram"),            1 },
2680 };
2681
2682 static GtkRadioActionEntry menu_stereo_mode_entries[] = {
2683   { "StereoAuto",       NULL,                   N_("_Auto"),                            NULL,                   N_("Stereo Auto"),              STEREO_PIXBUF_DEFAULT },
2684   { "StereoSBS",        NULL,                   N_("_Side by Side"),                    NULL,                   N_("Stereo Side by Side"),      STEREO_PIXBUF_SBS },
2685   { "StereoCross",      NULL,                   N_("_Cross"),                           NULL,                   N_("Stereo Cross"),             STEREO_PIXBUF_CROSS },
2686   { "StereoOff",        NULL,                   N_("_Off"),                             NULL,                   N_("Stereo Off"),               STEREO_PIXBUF_NONE }
2687 };
2688
2689
2690 #undef CB
2691
2692 static const gchar *menu_ui_description =
2693 "<ui>"
2694 "  <menubar name='MainMenu'>"
2695 "    <menu action='FileMenu'>"
2696 "      <menuitem action='NewCollection'/>"
2697 "      <menuitem action='OpenCollection'/>"
2698 "      <menuitem action='OpenRecent'/>"
2699 "      <placeholder name='OpenSection'/>"
2700 "      <separator/>"
2701 "      <menuitem action='Search'/>"
2702 "      <menuitem action='FindDupes'/>"
2703 "      <placeholder name='SearchSection'/>"
2704 "      <separator/>"
2705 "      <menuitem action='Print'/>"
2706 "      <placeholder name='PrintSection'/>"
2707 "      <separator/>"
2708 "      <menuitem action='NewFolder'/>"
2709 "      <menuitem action='Copy'/>"
2710 "      <menuitem action='Move'/>"
2711 "      <menuitem action='Rename'/>"
2712 "      <separator/>"
2713 "      <menuitem action='Delete'/>"
2714 "      <menuitem action='PermanentDelete'/>"
2715 "      <separator/>"
2716 "      <placeholder name='FileOpsSection'/>"
2717 "      <separator/>"
2718 "      <placeholder name='QuitSection'/>"
2719 "      <menuitem action='Quit'/>"
2720 "      <separator/>"
2721 "    </menu>"
2722 "    <menu action='GoMenu'>"
2723 "      <menuitem action='FirstImage'/>"
2724 "      <menuitem action='PrevImage'/>"
2725 "      <menuitem action='NextImage'/>"
2726 "      <menuitem action='LastImage'/>"
2727 "      <menuitem action='ImageBack'/>"
2728 "      <menuitem action='ImageForward'/>"
2729 "      <separator/>"
2730 "      <menuitem action='Back'/>"
2731 "      <menuitem action='Forward'/>"
2732 "      <menuitem action='Up'/>"
2733 "      <menuitem action='Home'/>"
2734 "      <separator/>"
2735 "      <menuitem action='FirstPage'/>"
2736 "      <menuitem action='LastPage'/>"
2737 "      <menuitem action='NextPage'/>"
2738 "      <menuitem action='PrevPage'/>"
2739 "    </menu>"
2740 "    <menu action='SelectMenu'>"
2741 "      <menuitem action='SelectAll'/>"
2742 "      <menuitem action='SelectNone'/>"
2743 "      <menuitem action='SelectInvert'/>"
2744 "      <menuitem action='RectangularSelection'/>"
2745 "      <menuitem action='ShowFileFilter'/>"
2746 "      <placeholder name='SelectSection'/>"
2747 "      <separator/>"
2748 "      <menuitem action='CopyPath'/>"
2749 "      <menuitem action='CopyPathUnquoted'/>"
2750 "      <placeholder name='ClipboardSection'/>"
2751 "      <separator/>"
2752 "      <menuitem action='ShowMarks'/>"
2753 "      <menuitem action='ClearMarks'/>"
2754 "      <placeholder name='MarksSection'/>"
2755 "      <separator/>"
2756 "    </menu>"
2757 "    <menu action='EditMenu'>"
2758 "      <placeholder name='EditSection'/>"
2759 "      <separator/>"
2760 "      <menu action='OrientationMenu'>"
2761 "        <menuitem action='RotateCW'/>"
2762 "        <menuitem action='RotateCCW'/>"
2763 "        <menuitem action='Rotate180'/>"
2764 "        <menuitem action='Mirror'/>"
2765 "        <menuitem action='Flip'/>"
2766 "        <menuitem action='AlterNone'/>"
2767 "        <separator/>"
2768 "        <menuitem action='ExifRotate'/>"
2769 "        <separator/>"
2770 "        <menuitem action='WriteRotation'/>"
2771 "        <menuitem action='WriteRotationKeepDate'/>"
2772 "        <separator/>"
2773 "      </menu>"
2774 "      <menu action='RatingMenu'>"
2775 "        <menuitem action='Rating0'/>"
2776 "        <menuitem action='Rating1'/>"
2777 "        <menuitem action='Rating2'/>"
2778 "        <menuitem action='Rating3'/>"
2779 "        <menuitem action='Rating4'/>"
2780 "        <menuitem action='Rating5'/>"
2781 "        <menuitem action='RatingM1'/>"
2782 "        <separator/>"
2783 "      </menu>"
2784 "      <menuitem action='SaveMetadata'/>"
2785 "      <menuitem action='KeywordAutocomplete'/>"
2786 "      <placeholder name='PropertiesSection'/>"
2787 "      <separator/>"
2788 "      <menuitem action='DrawRectangle'/>"
2789 "      <separator/>"
2790 "      <menuitem action='Preferences'/>"
2791 "      <menuitem action='Plugins'/>"
2792 "      <menuitem action='LayoutConfig'/>"
2793 "      <menuitem action='Maintenance'/>"
2794 "      <placeholder name='PreferencesSection'/>"
2795 "      <separator/>"
2796 "      <separator/>"
2797 "    </menu>"
2798 "    <menu action='PluginsMenu'>"
2799 "    </menu>"
2800 "    <menu action='ViewMenu'>"
2801 "      <menuitem action='ViewInNewWindow'/>"
2802 "      <menuitem action='PanView'/>"
2803 "      <menuitem action='ExifWin'/>"
2804 "      <menuitem action='OpenArchive'/>"
2805 "      <placeholder name='WindowSection'/>"
2806 "      <separator/>"
2807 "      <menu action='FileDirMenu'>"
2808 "        <menuitem action='FolderTree'/>"
2809 "        <placeholder name='FolderSection'/>"
2810 "        <separator/>"
2811 "        <menuitem action='ViewList'/>"
2812 "        <menuitem action='ViewIcons'/>"
2813 "        <menuitem action='Thumbnails'/>"
2814 "        <placeholder name='ListSection'/>"
2815 "        <separator/>"
2816 "        <menuitem action='FloatTools'/>"
2817 "        <menuitem action='HideTools'/>"
2818 "        <menuitem action='HideToolbar'/>"
2819 "      </menu>"
2820 "      <placeholder name='DirSection'/>"
2821 "      <separator/>"
2822 "      <menu action='ZoomMenu'>"
2823 "        <menu action='ConnectZoomMenu'>"
2824 "          <menuitem action='ConnectZoomIn'/>"
2825 "          <menuitem action='ConnectZoomOut'/>"
2826 "          <menuitem action='ConnectZoomFit'/>"
2827 "          <menuitem action='ConnectZoomFillHor'/>"
2828 "          <menuitem action='ConnectZoomFillVert'/>"
2829 "          <menuitem action='ConnectZoom100'/>"
2830 "          <menuitem action='ConnectZoom200'/>"
2831 "          <menuitem action='ConnectZoom300'/>"
2832 "          <menuitem action='ConnectZoom400'/>"
2833 "          <menuitem action='ConnectZoom50'/>"
2834 "          <menuitem action='ConnectZoom33'/>"
2835 "          <menuitem action='ConnectZoom25'/>"
2836 "        </menu>"
2837 "        <menuitem action='ZoomIn'/>"
2838 "        <menuitem action='ZoomOut'/>"
2839 "        <menuitem action='ZoomFit'/>"
2840 "        <menuitem action='ZoomFillHor'/>"
2841 "        <menuitem action='ZoomFillVert'/>"
2842 "        <menuitem action='Zoom100'/>"
2843 "        <menuitem action='Zoom200'/>"
2844 "        <menuitem action='Zoom300'/>"
2845 "        <menuitem action='Zoom400'/>"
2846 "        <menuitem action='Zoom50'/>"
2847 "        <menuitem action='Zoom33'/>"
2848 "        <menuitem action='Zoom25'/>"
2849 "      </menu>"
2850 "      <menu action='SplitMenu'>"
2851 "        <menuitem action='SplitHorizontal'/>"
2852 "        <menuitem action='SplitVertical'/>"
2853 "        <menuitem action='SplitTriple'/>"
2854 "        <menuitem action='SplitQuad'/>"
2855 "        <menuitem action='SplitSingle'/>"
2856 "        <separator/>"
2857 "        <menuitem action='SplitNextPane'/>"
2858 "        <menuitem action='SplitPreviousPane'/>"
2859 "        <menuitem action='SplitUpPane'/>"
2860 "        <menuitem action='SplitDownPane'/>"
2861 "        <separator/>"
2862 "        <menuitem action='SplitPaneSync'/>"
2863 "      </menu>"
2864 "      <menu action='StereoMenu'>"
2865 "        <menuitem action='StereoAuto'/>"
2866 "        <menuitem action='StereoSBS'/>"
2867 "        <menuitem action='StereoCross'/>"
2868 "        <menuitem action='StereoOff'/>"
2869 "        <separator/>"
2870 "        <menuitem action='StereoCycle'/>"
2871 "      </menu>"
2872 "      <menu action='ColorMenu'>"
2873 "        <menuitem action='UseColorProfiles'/>"
2874 "        <menuitem action='UseImageProfile'/>"
2875 "        <menuitem action='ColorProfile0'/>"
2876 "        <menuitem action='ColorProfile1'/>"
2877 "        <menuitem action='ColorProfile2'/>"
2878 "        <menuitem action='ColorProfile3'/>"
2879 "        <menuitem action='ColorProfile4'/>"
2880 "        <menuitem action='ColorProfile5'/>"
2881 "        <separator/>"
2882 "        <menuitem action='Grayscale'/>"
2883 "      </menu>"
2884 "      <menu action='OverlayMenu'>"
2885 "        <menuitem action='ImageOverlay'/>"
2886 "        <menuitem action='ImageHistogram'/>"
2887 "        <menuitem action='ImageOverlayCycle'/>"
2888 "        <separator/>"
2889 "        <menuitem action='HistogramChanR'/>"
2890 "        <menuitem action='HistogramChanG'/>"
2891 "        <menuitem action='HistogramChanB'/>"
2892 "        <menuitem action='HistogramChanRGB'/>"
2893 "        <menuitem action='HistogramChanV'/>"
2894 "        <menuitem action='HistogramChanCycle'/>"
2895 "        <separator/>"
2896 "        <menuitem action='HistogramModeLin'/>"
2897 "        <menuitem action='HistogramModeLog'/>"
2898 "        <menuitem action='HistogramModeCycle'/>"
2899 "      </menu>"
2900 "      <menuitem action='OverUnderExposed'/>"
2901 "      <menuitem action='FullScreen'/>"
2902 "      <placeholder name='ViewSection'/>"
2903 "      <separator/>"
2904 "      <menuitem action='SBar'/>"
2905 "      <menuitem action='SBarSort'/>"
2906 "      <menuitem action='HideBars'/>"
2907 "      <menuitem action='ShowInfoPixel'/>"
2908 "      <menuitem action='IgnoreAlpha'/>"
2909 "      <placeholder name='ToolsSection'/>"
2910 "      <separator/>"
2911 "      <menuitem action='Animate'/>"
2912 "      <menuitem action='SlideShow'/>"
2913 "      <menuitem action='SlideShowPause'/>"
2914 "      <menuitem action='SlideShowFaster'/>"
2915 "      <menuitem action='SlideShowSlower'/>"
2916 "      <separator/>"
2917 "      <menuitem action='Refresh'/>"
2918 "      <placeholder name='SlideShowSection'/>"
2919 "      <separator/>"
2920 "    </menu>"
2921 "    <menu action='WindowsMenu'>"
2922 "      <menu action='NewWindow'>"
2923 "        <menuitem action='NewWindowDefault'/>"
2924 "        <menuitem action='NewWindowFromCurrent'/>"
2925 "        <separator/>"
2926 "       </menu>"
2927 "      <menuitem action='RenameWindow'/>"
2928 "      <menuitem action='DeleteWindow'/>"
2929 "      <menuitem action='CloseWindow'/>"
2930 "    </menu>"
2931 "    <menu action='HelpMenu'>"
2932 "      <separator/>"
2933 "      <menuitem action='HelpContents'/>"
2934 "      <menuitem action='SearchAndRunCommand'/>"
2935 "      <menuitem action='HelpSearch'/>"
2936 "      <menuitem action='HelpShortcuts'/>"
2937 "      <menuitem action='HelpKbd'/>"
2938 "      <menuitem action='HelpNotes'/>"
2939 "      <menuitem action='HelpChangeLog'/>"
2940 "      <placeholder name='HelpSection'/>"
2941 "      <separator/>"
2942 "      <menuitem action='About'/>"
2943 "      <separator/>"
2944 "      <menuitem action='LogWindow'/>"
2945 "      <separator/>"
2946 "    </menu>"
2947 "  </menubar>"
2948 "  <toolbar name='ToolBar'>"
2949 "  </toolbar>"
2950 "  <toolbar name='StatusBar'>"
2951 "  </toolbar>"
2952 "<accelerator action='PrevImageAlt1'/>"
2953 "<accelerator action='PrevImageAlt2'/>"
2954 "<accelerator action='NextImageAlt1'/>"
2955 "<accelerator action='NextImageAlt2'/>"
2956 "<accelerator action='DeleteAlt1'/>"
2957 "<accelerator action='DeleteAlt2'/>"
2958 "<accelerator action='FullScreenAlt1'/>"
2959 "<accelerator action='FullScreenAlt2'/>"
2960 "<accelerator action='Escape'/>"
2961 "<accelerator action='EscapeAlt1'/>"
2962
2963 "<accelerator action='ZoomInAlt1'/>"
2964 "<accelerator action='ZoomOutAlt1'/>"
2965 "<accelerator action='Zoom100Alt1'/>"
2966 "<accelerator action='ZoomFitAlt1'/>"
2967
2968 "<accelerator action='ConnectZoomInAlt1'/>"
2969 "<accelerator action='ConnectZoomOutAlt1'/>"
2970 "<accelerator action='ConnectZoom100Alt1'/>"
2971 "<accelerator action='ConnectZoomFitAlt1'/>"
2972 "</ui>";
2973
2974 static gchar *menu_translate(const gchar *path, gpointer UNUSED(data))
2975 {
2976         return (gchar *)(_(path));
2977 }
2978
2979 static void layout_actions_setup_mark(LayoutWindow *lw, gint mark, const gchar *name_tmpl,
2980                                       const gchar *label_tmpl, const gchar *accel_tmpl, const gchar *tooltip_tmpl, GCallback cb)
2981 {
2982         gchar name[50];
2983         gchar label[100];
2984         gchar accel[50];
2985         gchar tooltip[100];
2986         GtkActionEntry entry = { name, NULL, label, accel, tooltip, cb };
2987         GtkAction *action;
2988
2989         g_snprintf(name, sizeof(name), name_tmpl, mark);
2990         g_snprintf(label, sizeof(label), label_tmpl, mark);
2991
2992         if (accel_tmpl)
2993                 g_snprintf(accel, sizeof(accel), accel_tmpl, mark % 10);
2994         else
2995                 entry.accelerator = NULL;
2996
2997         if (tooltip_tmpl)
2998                 g_snprintf(tooltip, sizeof(tooltip), tooltip_tmpl, mark);
2999         else
3000                 entry.tooltip = NULL;
3001
3002         gtk_action_group_add_actions(lw->action_group, &entry, 1, lw);
3003         action = gtk_action_group_get_action(lw->action_group, name);
3004         g_object_set_data(G_OBJECT(action), "mark_num", GINT_TO_POINTER(mark > 0 ? mark : 10));
3005 }
3006
3007 static void layout_actions_setup_marks(LayoutWindow *lw)
3008 {
3009         gint mark;
3010         GError *error;
3011         GString *desc = g_string_new(
3012                                 "<ui>"
3013                                 "  <menubar name='MainMenu'>"
3014                                 "    <menu action='SelectMenu'>");
3015
3016         for (mark = 1; mark <= FILEDATA_MARKS_SIZE; mark++)
3017                 {
3018                 gint i = (mark < 10 ? mark : 0);
3019
3020                 layout_actions_setup_mark(lw, i, "Mark%d",              _("Mark _%d"), NULL, NULL, NULL);
3021                 layout_actions_setup_mark(lw, i, "SetMark%d",   _("_Set mark %d"),                      NULL,           _("Set mark %d"), G_CALLBACK(layout_menu_set_mark_sel_cb));
3022                 layout_actions_setup_mark(lw, i, "ResetMark%d", _("_Reset mark %d"),                    NULL,           _("Reset mark %d"), G_CALLBACK(layout_menu_res_mark_sel_cb));
3023                 layout_actions_setup_mark(lw, i, "ToggleMark%d",        _("_Toggle mark %d"),                   "%d",           _("Toggle mark %d"), G_CALLBACK(layout_menu_toggle_mark_sel_cb));
3024                 layout_actions_setup_mark(lw, i, "ToggleMark%dAlt1",    _("_Toggle mark %d"),                   "KP_%d",        _("Toggle mark %d"), G_CALLBACK(layout_menu_toggle_mark_sel_cb));
3025                 layout_actions_setup_mark(lw, i, "SelectMark%d",        _("Se_lect mark %d"),                   "<control>%d",  _("Select mark %d"), G_CALLBACK(layout_menu_sel_mark_cb));
3026                 layout_actions_setup_mark(lw, i, "SelectMark%dAlt1",    _("_Select mark %d"),                   "<control>KP_%d", _("Select mark %d"), G_CALLBACK(layout_menu_sel_mark_cb));
3027                 layout_actions_setup_mark(lw, i, "AddMark%d",   _("_Add mark %d"),                      NULL,           _("Add mark %d"), G_CALLBACK(layout_menu_sel_mark_or_cb));
3028                 layout_actions_setup_mark(lw, i, "IntMark%d",   _("_Intersection with mark %d"),        NULL,           _("Intersection with mark %d"), G_CALLBACK(layout_menu_sel_mark_and_cb));
3029                 layout_actions_setup_mark(lw, i, "UnselMark%d", _("_Unselect mark %d"),                 NULL,           _("Unselect mark %d"), G_CALLBACK(layout_menu_sel_mark_minus_cb));
3030                 layout_actions_setup_mark(lw, i, "FilterMark%d",        _("_Filter mark %d"),                   NULL,           _("Filter mark %d"), G_CALLBACK(layout_menu_mark_filter_toggle_cb));
3031
3032                 g_string_append_printf(desc,
3033                                 "      <menu action='Mark%d'>"
3034                                 "        <menuitem action='ToggleMark%d'/>"
3035                                 "        <menuitem action='SetMark%d'/>"
3036                                 "        <menuitem action='ResetMark%d'/>"
3037                                 "        <separator/>"
3038                                 "        <menuitem action='SelectMark%d'/>"
3039                                 "        <menuitem action='AddMark%d'/>"
3040                                 "        <menuitem action='IntMark%d'/>"
3041                                 "        <menuitem action='UnselMark%d'/>"
3042                                 "        <separator/>"
3043                                 "        <menuitem action='FilterMark%d'/>"
3044                                 "      </menu>",
3045                                 i, i, i, i, i, i, i, i, i);
3046                 }
3047
3048         g_string_append(desc,
3049                                 "    </menu>"
3050                                 "  </menubar>");
3051         for (mark = 1; mark <= FILEDATA_MARKS_SIZE; mark++)
3052                 {
3053                 gint i = (mark < 10 ? mark : 0);
3054
3055                 g_string_append_printf(desc,
3056                                 "<accelerator action='ToggleMark%dAlt1'/>"
3057                                 "<accelerator action='SelectMark%dAlt1'/>",
3058                                 i, i);
3059                 }
3060         g_string_append(desc,   "</ui>" );
3061
3062         error = NULL;
3063         if (!gtk_ui_manager_add_ui_from_string(lw->ui_manager, desc->str, -1, &error))
3064                 {
3065                 g_message("building menus failed: %s", error->message);
3066                 g_error_free(error);
3067                 exit(EXIT_FAILURE);
3068                 }
3069         g_string_free(desc, TRUE);
3070 }
3071
3072 static GList *layout_actions_editor_menu_path(EditorDescription *editor)
3073 {
3074         gchar **split = g_strsplit(editor->menu_path, "/", 0);
3075         gint i = 0;
3076         GList *ret = NULL;
3077
3078         if (split[0] == NULL)
3079                 {
3080                 g_strfreev(split);
3081                 return NULL;
3082                 }
3083
3084         while (split[i])
3085                 {
3086                 ret = g_list_prepend(ret, g_strdup(split[i]));
3087                 i++;
3088                 }
3089
3090         g_strfreev(split);
3091
3092         ret = g_list_prepend(ret, g_strdup(editor->key));
3093
3094         return g_list_reverse(ret);
3095 }
3096
3097 static void layout_actions_editor_add(GString *desc, GList *path, GList *old_path)
3098 {
3099         gint to_open, to_close, i;
3100         while (path && old_path && strcmp((gchar *)path->data, (gchar *)old_path->data) == 0)
3101                 {
3102                 path = path->next;
3103                 old_path = old_path->next;
3104                 }
3105         to_open = g_list_length(path) - 1;
3106         to_close = g_list_length(old_path) - 1;
3107
3108         if (to_close > 0)
3109                 {
3110                 old_path = g_list_last(old_path);
3111                 old_path = old_path->prev;
3112                 }
3113
3114         for (i =  0; i < to_close; i++)
3115                 {
3116                 gchar *name = static_cast<gchar *>(old_path->data);
3117                 if (g_str_has_suffix(name, "Section"))
3118                         {
3119                         g_string_append(desc,   "      </placeholder>");
3120                         }
3121                 else if (g_str_has_suffix(name, "Menu"))
3122                         {
3123                         g_string_append(desc,   "    </menu>");
3124                         }
3125                 else
3126                         {
3127                         g_warning("invalid menu path item %s", name);
3128                         }
3129                 old_path = old_path->prev;
3130                 }
3131
3132         for (i =  0; i < to_open; i++)
3133                 {
3134                 gchar *name = static_cast<gchar *>(path->data);
3135                 if (g_str_has_suffix(name, "Section"))
3136                         {
3137                         g_string_append_printf(desc,    "      <placeholder name='%s'>", name);
3138                         }
3139                 else if (g_str_has_suffix(name, "Menu"))
3140                         {
3141                         g_string_append_printf(desc,    "    <menu action='%s'>", name);
3142                         }
3143                 else
3144                         {
3145                         g_warning("invalid menu path item %s", name);
3146                         }
3147                 path = path->next;
3148                 }
3149
3150         if (path)
3151                 g_string_append_printf(desc, "      <menuitem action='%s'/>", (gchar *)path->data);
3152 }
3153
3154 static void layout_actions_setup_editors(LayoutWindow *lw)
3155 {
3156         GError *error;
3157         GList *editors_list;
3158         GList *work;
3159         GList *old_path;
3160         GString *desc;
3161
3162         if (lw->ui_editors_id)
3163                 {
3164                 gtk_ui_manager_remove_ui(lw->ui_manager, lw->ui_editors_id);
3165                 }
3166
3167         if (lw->action_group_editors)
3168                 {
3169                 gtk_ui_manager_remove_action_group(lw->ui_manager, lw->action_group_editors);
3170                 g_object_unref(lw->action_group_editors);
3171                 }
3172         lw->action_group_editors = gtk_action_group_new("MenuActionsExternal");
3173         gtk_ui_manager_insert_action_group(lw->ui_manager, lw->action_group_editors, 1);
3174
3175         /* lw->action_group_editors contains translated entries, no translate func is required */
3176         desc = g_string_new(
3177                                 "<ui>"
3178                                 "  <menubar name='MainMenu'>");
3179
3180         editors_list = editor_list_get();
3181
3182         old_path = NULL;
3183         work = editors_list;
3184         while (work)
3185                 {
3186                 GList *path;
3187                 EditorDescription *editor = static_cast<EditorDescription *>(work->data);
3188                 GtkActionEntry entry = { editor->key,
3189                                          NULL,
3190                                          editor->name,
3191                                          editor->hotkey,
3192                                          editor->comment ? editor->comment : editor->name,
3193                                          G_CALLBACK(layout_menu_edit_cb) };
3194
3195                 if (editor->icon)
3196                         {
3197                         entry.stock_id = editor->key;
3198                         }
3199                 gtk_action_group_add_actions(lw->action_group_editors, &entry, 1, lw);
3200
3201                 path = layout_actions_editor_menu_path(editor);
3202                 layout_actions_editor_add(desc, path, old_path);
3203
3204                 string_list_free(old_path);
3205                 old_path = path;
3206                 work = work->next;
3207                 }
3208
3209         layout_actions_editor_add(desc, NULL, old_path);
3210         string_list_free(old_path);
3211
3212         g_string_append(desc,   "  </menubar>"
3213                                 "</ui>" );
3214
3215         error = NULL;
3216
3217         lw->ui_editors_id = gtk_ui_manager_add_ui_from_string(lw->ui_manager, desc->str, -1, &error);
3218         if (!lw->ui_editors_id)
3219                 {
3220                 g_message("building menus failed: %s", error->message);
3221                 g_error_free(error);
3222                 exit(EXIT_FAILURE);
3223                 }
3224         g_string_free(desc, TRUE);
3225         g_list_free(editors_list);
3226 }
3227
3228 void layout_actions_setup(LayoutWindow *lw)
3229 {
3230         GError *error;
3231         gint i;
3232
3233         DEBUG_1("%s layout_actions_setup: start", get_exec_time());
3234         if (lw->ui_manager) return;
3235
3236         lw->action_group = gtk_action_group_new("MenuActions");
3237         gtk_action_group_set_translate_func(lw->action_group, menu_translate, NULL, NULL);
3238
3239         gtk_action_group_add_actions(lw->action_group,
3240                                      menu_entries, G_N_ELEMENTS(menu_entries), lw);
3241         gtk_action_group_add_toggle_actions(lw->action_group,
3242                                             menu_toggle_entries, G_N_ELEMENTS(menu_toggle_entries), lw);
3243         gtk_action_group_add_radio_actions(lw->action_group,
3244                                            menu_radio_entries, G_N_ELEMENTS(menu_radio_entries),
3245                                            0, G_CALLBACK(layout_menu_list_cb), lw);
3246         gtk_action_group_add_radio_actions(lw->action_group,
3247                                            menu_split_radio_entries, G_N_ELEMENTS(menu_split_radio_entries),
3248                                            0, G_CALLBACK(layout_menu_split_cb), lw);
3249         gtk_action_group_add_toggle_actions(lw->action_group,
3250                                            menu_view_dir_toggle_entries, G_N_ELEMENTS(menu_view_dir_toggle_entries),
3251                                             lw);
3252         gtk_action_group_add_radio_actions(lw->action_group,
3253                                            menu_color_radio_entries, COLOR_PROFILE_FILE + COLOR_PROFILE_INPUTS,
3254                                            0, G_CALLBACK(layout_color_menu_input_cb), lw);
3255         gtk_action_group_add_radio_actions(lw->action_group,
3256                                            menu_histogram_channel, G_N_ELEMENTS(menu_histogram_channel),
3257                                            0, G_CALLBACK(layout_menu_histogram_channel_cb), lw);
3258         gtk_action_group_add_radio_actions(lw->action_group,
3259                                            menu_histogram_mode, G_N_ELEMENTS(menu_histogram_mode),
3260                                            0, G_CALLBACK(layout_menu_histogram_mode_cb), lw);
3261         gtk_action_group_add_radio_actions(lw->action_group,
3262                                            menu_stereo_mode_entries, G_N_ELEMENTS(menu_stereo_mode_entries),
3263                                            0, G_CALLBACK(layout_menu_stereo_mode_cb), lw);
3264
3265
3266         lw->ui_manager = gtk_ui_manager_new();
3267         gtk_ui_manager_set_add_tearoffs(lw->ui_manager, TRUE);
3268         gtk_ui_manager_insert_action_group(lw->ui_manager, lw->action_group, 0);
3269
3270         DEBUG_1("%s layout_actions_setup: add menu", get_exec_time());
3271         error = NULL;
3272         if (!gtk_ui_manager_add_ui_from_string(lw->ui_manager, menu_ui_description, -1, &error))
3273                 {
3274                 g_message("building menus failed: %s", error->message);
3275                 g_error_free(error);
3276                 exit(EXIT_FAILURE);
3277                 }
3278
3279         DEBUG_1("%s layout_actions_setup: add toolbar", get_exec_time());
3280         for (i = 0; i < TOOLBAR_COUNT; i++)
3281                 {
3282                 layout_toolbar_clear(lw, static_cast<ToolbarType>(i));
3283                 layout_toolbar_add_default(lw, static_cast<ToolbarType>(i));
3284                 }
3285
3286         DEBUG_1("%s layout_actions_setup: marks", get_exec_time());
3287         layout_actions_setup_marks(lw);
3288
3289         DEBUG_1("%s layout_actions_setup: editors", get_exec_time());
3290         layout_actions_setup_editors(lw);
3291
3292         DEBUG_1("%s layout_actions_setup: status_update_write", get_exec_time());
3293         layout_util_status_update_write(lw);
3294
3295         DEBUG_1("%s layout_actions_setup: actions_add_window", get_exec_time());
3296         layout_actions_add_window(lw, lw->window);
3297         DEBUG_1("%s layout_actions_setup: end", get_exec_time());
3298 }
3299
3300 static gint layout_editors_reload_idle_id = -1;
3301 static GList *layout_editors_desktop_files = NULL;
3302
3303 static gboolean layout_editors_reload_idle_cb(gpointer UNUSED(data))
3304 {
3305         if (!layout_editors_desktop_files)
3306                 {
3307                 DEBUG_1("%s layout_editors_reload_idle_cb: get_desktop_files", get_exec_time());
3308                 layout_editors_desktop_files = editor_get_desktop_files();
3309                 return G_SOURCE_CONTINUE;
3310                 }
3311
3312         editor_read_desktop_file(static_cast<const gchar *>(layout_editors_desktop_files->data));
3313         g_free(layout_editors_desktop_files->data);
3314         layout_editors_desktop_files = g_list_delete_link(layout_editors_desktop_files, layout_editors_desktop_files);
3315
3316
3317         if (!layout_editors_desktop_files)
3318                 {
3319                 GList *work;
3320                 DEBUG_1("%s layout_editors_reload_idle_cb: setup_editors", get_exec_time());
3321                 editor_table_finish();
3322
3323                 work = layout_window_list;
3324                 while (work)
3325                         {
3326                         LayoutWindow *lw = static_cast<LayoutWindow *>(work->data);
3327                         work = work->next;
3328                         layout_actions_setup_editors(lw);
3329                         if (lw->bar_sort_enabled)
3330                                 {
3331                                 layout_bar_sort_toggle(lw);
3332                                 }
3333                         }
3334
3335                 DEBUG_1("%s layout_editors_reload_idle_cb: setup_editors done", get_exec_time());
3336
3337                 layout_editors_reload_idle_id = -1;
3338                 return G_SOURCE_REMOVE;
3339                 }
3340         return G_SOURCE_CONTINUE;
3341 }
3342
3343 void layout_editors_reload_start(void)
3344 {
3345         DEBUG_1("%s layout_editors_reload_start", get_exec_time());
3346
3347         if (layout_editors_reload_idle_id != -1)
3348                 {
3349                 g_source_remove(layout_editors_reload_idle_id);
3350                 string_list_free(layout_editors_desktop_files);
3351                 }
3352
3353         editor_table_clear();
3354         layout_editors_reload_idle_id = g_idle_add(layout_editors_reload_idle_cb, NULL);
3355 }
3356
3357 void layout_editors_reload_finish(void)
3358 {
3359         if (layout_editors_reload_idle_id != -1)
3360                 {
3361                 DEBUG_1("%s layout_editors_reload_finish", get_exec_time());
3362                 g_source_remove(layout_editors_reload_idle_id);
3363                 while (layout_editors_reload_idle_id != -1)
3364                         {
3365                         layout_editors_reload_idle_cb(NULL);
3366                         }
3367                 }
3368 }
3369
3370 void layout_actions_add_window(LayoutWindow *lw, GtkWidget *window)
3371 {
3372         GtkAccelGroup *group;
3373
3374         if (!lw->ui_manager) return;
3375
3376         group = gtk_ui_manager_get_accel_group(lw->ui_manager);
3377         gtk_window_add_accel_group(GTK_WINDOW(window), group);
3378 }
3379
3380 GtkWidget *layout_actions_menu_bar(LayoutWindow *lw)
3381 {
3382         if (lw->menu_bar) return lw->menu_bar;
3383         lw->menu_bar = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu");
3384         g_object_ref(lw->menu_bar);
3385         return lw->menu_bar;
3386 }
3387
3388 GtkWidget *layout_actions_toolbar(LayoutWindow *lw, ToolbarType type)
3389 {
3390         if (lw->toolbar[type]) return lw->toolbar[type];
3391         switch (type)
3392                 {
3393                 case TOOLBAR_MAIN:
3394                         lw->toolbar[type] = gtk_ui_manager_get_widget(lw->ui_manager, "/ToolBar");
3395                         gtk_toolbar_set_icon_size(GTK_TOOLBAR(lw->toolbar[type]), GTK_ICON_SIZE_SMALL_TOOLBAR);
3396                         gtk_toolbar_set_style(GTK_TOOLBAR(lw->toolbar[type]), GTK_TOOLBAR_ICONS);
3397                         break;
3398                 case TOOLBAR_STATUS:
3399                         lw->toolbar[type] = gtk_ui_manager_get_widget(lw->ui_manager, "/StatusBar");
3400                         gtk_toolbar_set_icon_size(GTK_TOOLBAR(lw->toolbar[type]), GTK_ICON_SIZE_MENU);
3401                         gtk_toolbar_set_style(GTK_TOOLBAR(lw->toolbar[type]), GTK_TOOLBAR_ICONS);
3402                         gtk_toolbar_set_show_arrow(GTK_TOOLBAR(lw->toolbar[type]), FALSE);
3403                         break;
3404                 default:
3405                         break;
3406                 }
3407         g_object_ref(lw->toolbar[type]);
3408         return lw->toolbar[type];
3409 }
3410
3411 GtkWidget *layout_actions_menu_tool_bar(LayoutWindow *lw)
3412 {
3413         GtkWidget *menu_bar;
3414         GtkWidget *toolbar;
3415
3416         if (lw->menu_tool_bar) return lw->menu_tool_bar;
3417
3418         menu_bar = layout_actions_menu_bar(lw);
3419         DEBUG_NAME(menu_bar);
3420         toolbar = layout_actions_toolbar(lw, TOOLBAR_MAIN);
3421         DEBUG_NAME(toolbar);
3422         lw->menu_tool_bar = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
3423
3424         gtk_box_pack_start(GTK_BOX(lw->menu_tool_bar), menu_bar, FALSE, FALSE, 0);
3425         gtk_box_pack_start(GTK_BOX(lw->menu_tool_bar), toolbar, FALSE, FALSE, 0);
3426
3427         g_object_ref(lw->menu_tool_bar);
3428         return lw->menu_tool_bar;
3429 }
3430
3431 void layout_toolbar_clear(LayoutWindow *lw, ToolbarType type)
3432 {
3433         if (lw->toolbar_merge_id[type])
3434                 {
3435                 gtk_ui_manager_remove_ui(lw->ui_manager, lw->toolbar_merge_id[type]);
3436                 gtk_ui_manager_ensure_update(lw->ui_manager);
3437                 }
3438         string_list_free(lw->toolbar_actions[type]);
3439         lw->toolbar_actions[type] = NULL;
3440
3441         lw->toolbar_merge_id[type] = gtk_ui_manager_new_merge_id(lw->ui_manager);
3442 }
3443
3444 void layout_toolbar_add(LayoutWindow *lw, ToolbarType type, const gchar *action)
3445 {
3446         const gchar *path = NULL;
3447
3448         if (!action || !lw->ui_manager) return;
3449
3450         if (g_list_find_custom(lw->toolbar_actions[type], action, (GCompareFunc)strcmp)) return;
3451
3452         switch (type)
3453                 {
3454                 case TOOLBAR_MAIN:
3455                         path = "/ToolBar";
3456                         break;
3457                 case TOOLBAR_STATUS:
3458                         path = "/StatusBar";
3459                         break;
3460                 default:
3461                         break;
3462                 }
3463
3464
3465         if (g_str_has_suffix(action, ".desktop"))
3466                 {
3467                 /* this may be called before the external editors are read
3468                    create a dummy action for now */
3469                 if (!lw->action_group_editors)
3470                         {
3471                         lw->action_group_editors = gtk_action_group_new("MenuActionsExternal");
3472                         gtk_ui_manager_insert_action_group(lw->ui_manager, lw->action_group_editors, 1);
3473                         }
3474                 if (!gtk_action_group_get_action(lw->action_group_editors, action))
3475                         {
3476                         GtkActionEntry entry = { action,
3477                                                  GTK_STOCK_MISSING_IMAGE,
3478                                                  action,
3479                                                  NULL,
3480                                                  NULL,
3481                                                  NULL };
3482                         DEBUG_1("Creating temporary action %s", action);
3483                         gtk_action_group_add_actions(lw->action_group_editors, &entry, 1, lw);
3484                         }
3485                 }
3486         gtk_ui_manager_add_ui(lw->ui_manager, lw->toolbar_merge_id[type], path, action, action, GTK_UI_MANAGER_TOOLITEM, FALSE);
3487         lw->toolbar_actions[type] = g_list_append(lw->toolbar_actions[type], g_strdup(action));
3488 }
3489
3490
3491 void layout_toolbar_add_default(LayoutWindow *lw, ToolbarType type)
3492 {
3493         LayoutWindow *lw_first;
3494         GList *work_action;
3495
3496         switch (type)
3497                 {
3498                 case TOOLBAR_MAIN:
3499                         if (layout_window_list)
3500                                 {
3501                                 lw_first = static_cast<LayoutWindow *>(layout_window_list->data);
3502                                 if (lw_first->toolbar_actions[TOOLBAR_MAIN])
3503                                         {
3504                                         work_action = lw_first->toolbar_actions[type];
3505                                         while (work_action)
3506                                                 {
3507                                                 gchar *action = static_cast<gchar *>(work_action->data);
3508                                                 work_action = work_action->next;
3509                                                 layout_toolbar_add(lw, type, action);
3510                                                 }
3511                                         }
3512                                 else
3513                                         {
3514                                         layout_toolbar_add(lw, type, "Thumbnails");
3515                                         layout_toolbar_add(lw, type, "Back");
3516                                         layout_toolbar_add(lw, type, "Forward");
3517                                         layout_toolbar_add(lw, type, "Up");
3518                                         layout_toolbar_add(lw, type, "Home");
3519                                         layout_toolbar_add(lw, type, "Refresh");
3520                                         layout_toolbar_add(lw, type, "ZoomIn");
3521                                         layout_toolbar_add(lw, type, "ZoomOut");
3522                                         layout_toolbar_add(lw, type, "ZoomFit");
3523                                         layout_toolbar_add(lw, type, "Zoom100");
3524                                         layout_toolbar_add(lw, type, "Preferences");
3525                                         layout_toolbar_add(lw, type, "FloatTools");
3526                                         }
3527                                 }
3528                         else
3529                                 {
3530                                 layout_toolbar_add(lw, type, "Thumbnails");
3531                                 layout_toolbar_add(lw, type, "Back");
3532                                 layout_toolbar_add(lw, type, "Forward");
3533                                 layout_toolbar_add(lw, type, "Up");
3534                                 layout_toolbar_add(lw, type, "Home");
3535                                 layout_toolbar_add(lw, type, "Refresh");
3536                                 layout_toolbar_add(lw, type, "ZoomIn");
3537                                 layout_toolbar_add(lw, type, "ZoomOut");
3538                                 layout_toolbar_add(lw, type, "ZoomFit");
3539                                 layout_toolbar_add(lw, type, "Zoom100");
3540                                 layout_toolbar_add(lw, type, "Preferences");
3541                                 layout_toolbar_add(lw, type, "FloatTools");
3542                                 }
3543                         break;
3544                 case TOOLBAR_STATUS:
3545                         if (layout_window_list)
3546                                 {
3547                                 lw_first = static_cast<LayoutWindow *>(layout_window_list->data);
3548                                 if (lw_first->toolbar_actions[TOOLBAR_MAIN])
3549                                         {
3550                                         work_action = lw_first->toolbar_actions[type];
3551                                         while (work_action)
3552                                                 {
3553                                                 gchar *action = static_cast<gchar *>(work_action->data);
3554                                                 work_action = work_action->next;
3555                                                 layout_toolbar_add(lw, type, action);
3556                                                 }
3557                                         }
3558                                 else
3559                                         {
3560                                         layout_toolbar_add(lw, type, "ExifRotate");
3561                                         layout_toolbar_add(lw, type, "ShowInfoPixel");
3562                                         layout_toolbar_add(lw, type, "UseColorProfiles");
3563                                         layout_toolbar_add(lw, type, "SaveMetadata");
3564                                         }
3565                                 }
3566                         else
3567                                 {
3568                                 layout_toolbar_add(lw, type, "ExifRotate");
3569                                 layout_toolbar_add(lw, type, "ShowInfoPixel");
3570                                 layout_toolbar_add(lw, type, "UseColorProfiles");
3571                                 layout_toolbar_add(lw, type, "SaveMetadata");
3572                                 }
3573                         break;
3574                 default:
3575                         break;
3576                 }
3577 }
3578
3579
3580
3581 void layout_toolbar_write_config(LayoutWindow *lw, ToolbarType type, GString *outstr, gint indent)
3582 {
3583         const gchar *name = NULL;
3584         GList *work = lw->toolbar_actions[type];
3585
3586         switch (type)
3587                 {
3588                 case TOOLBAR_MAIN:
3589                         name = "toolbar";
3590                         break;
3591                 case TOOLBAR_STATUS:
3592                         name = "statusbar";
3593                         break;
3594                 default:
3595                         break;
3596                 }
3597
3598         WRITE_NL(); WRITE_STRING("<%s>", name);
3599         indent++;
3600         WRITE_NL(); WRITE_STRING("<clear/>");
3601         while (work)
3602                 {
3603                 gchar *action = static_cast<gchar *>(work->data);
3604                 work = work->next;
3605                 WRITE_NL(); WRITE_STRING("<toolitem ");
3606                 write_char_option(outstr, indent + 1, "action", action);
3607                 WRITE_STRING("/>");
3608                 }
3609         indent--;
3610         WRITE_NL(); WRITE_STRING("</%s>", name);
3611 }
3612
3613 void layout_toolbar_add_from_config(LayoutWindow *lw, ToolbarType type, const char **attribute_names, const gchar **attribute_values)
3614 {
3615         gchar *action = NULL;
3616
3617         while (*attribute_names)
3618                 {
3619                 const gchar *option = *attribute_names++;
3620                 const gchar *value = *attribute_values++;
3621
3622                 if (READ_CHAR_FULL("action", action)) continue;
3623
3624                 log_printf("unknown attribute %s = %s\n", option, value);
3625                 }
3626
3627         layout_toolbar_add(lw, type, action);
3628         g_free(action);
3629 }
3630
3631 /*
3632  *-----------------------------------------------------------------------------
3633  * misc
3634  *-----------------------------------------------------------------------------
3635  */
3636
3637 void layout_util_status_update_write(LayoutWindow *lw)
3638 {
3639         GtkAction *action;
3640         gint n = metadata_queue_length();
3641         action = gtk_action_group_get_action(lw->action_group, "SaveMetadata");
3642         gtk_action_set_sensitive(action, n > 0);
3643         if (n > 0)
3644                 {
3645                 gchar *buf = g_strdup_printf(_("Number of files with unsaved metadata: %d"), n);
3646                 g_object_set(G_OBJECT(action), "tooltip", buf, NULL);
3647                 g_free(buf);
3648                 }
3649         else
3650                 {
3651                 g_object_set(G_OBJECT(action), "tooltip", _("No unsaved metadata"), NULL);
3652                 }
3653 }
3654
3655 void layout_util_status_update_write_all(void)
3656 {
3657         GList *work;
3658
3659         work = layout_window_list;
3660         while (work)
3661                 {
3662                 LayoutWindow *lw = static_cast<LayoutWindow *>(work->data);
3663                 work = work->next;
3664
3665                 layout_util_status_update_write(lw);
3666                 }
3667 }
3668
3669 static gchar *layout_color_name_parse(const gchar *name)
3670 {
3671         if (!name || !*name) return g_strdup(_("Empty"));
3672         return g_strdelimit(g_strdup(name), "_", '-');
3673 }
3674
3675 void layout_util_sync_color(LayoutWindow *lw)
3676 {
3677         GtkAction *action;
3678         gint input = 0;
3679         gboolean use_color;
3680         gboolean use_image = FALSE;
3681         gint i;
3682         gchar action_name[15];
3683 #ifdef HAVE_LCMS
3684         gchar *image_profile;
3685         gchar *screen_profile;
3686 #endif
3687
3688         if (!lw->action_group) return;
3689         if (!layout_image_color_profile_get(lw, &input, &use_image)) return;
3690
3691         use_color = layout_image_color_profile_get_use(lw);
3692
3693         action = gtk_action_group_get_action(lw->action_group, "UseColorProfiles");
3694 #ifdef HAVE_LCMS
3695         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), use_color);
3696         if (layout_image_color_profile_get_status(lw, &image_profile, &screen_profile))
3697                 {
3698                 gchar *buf;
3699                 buf = g_strdup_printf(_("Image profile: %s\nScreen profile: %s"), image_profile, screen_profile);
3700                 g_object_set(G_OBJECT(action), "tooltip", buf, NULL);
3701                 g_free(image_profile);
3702                 g_free(screen_profile);
3703                 g_free(buf);
3704                 }
3705         else
3706                 {
3707                 g_object_set(G_OBJECT(action), "tooltip", _("Click to enable color management"), NULL);
3708                 }
3709 #else
3710         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), FALSE);
3711         gtk_action_set_sensitive(action, FALSE);
3712         g_object_set(G_OBJECT(action), "tooltip", _("Color profiles not supported"), NULL);
3713 #endif
3714
3715         action = gtk_action_group_get_action(lw->action_group, "UseImageProfile");
3716         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), use_image);
3717         gtk_action_set_sensitive(action, use_color);
3718
3719         for (i = 0; i < COLOR_PROFILE_FILE + COLOR_PROFILE_INPUTS; i++)
3720                 {
3721                 sprintf(action_name, "ColorProfile%d", i);
3722                 action = gtk_action_group_get_action(lw->action_group, action_name);
3723
3724                 if (i >= COLOR_PROFILE_FILE)
3725                         {
3726                         const gchar *name = options->color_profile.input_name[i - COLOR_PROFILE_FILE];
3727                         const gchar *file = options->color_profile.input_file[i - COLOR_PROFILE_FILE];
3728                         gchar *end;
3729                         gchar *buf;
3730
3731                         if (!name || !name[0]) name = filename_from_path(file);
3732
3733                         end = layout_color_name_parse(name);
3734                         buf = g_strdup_printf(_("Input _%d: %s"), i, end);
3735                         g_free(end);
3736
3737                         g_object_set(G_OBJECT(action), "label", buf, NULL);
3738                         g_free(buf);
3739
3740                         gtk_action_set_visible(action, file && file[0]);
3741                         }
3742
3743                 gtk_action_set_sensitive(action, !use_image);
3744                 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), (i == input));
3745                 }
3746
3747         action = gtk_action_group_get_action(lw->action_group, "Grayscale");
3748         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), layout_image_get_desaturate(lw));
3749 }
3750
3751 void layout_util_sync_file_filter(LayoutWindow *lw)
3752 {
3753         GtkAction *action;
3754
3755         if (!lw->action_group) return;
3756
3757         action = gtk_action_group_get_action(lw->action_group, "ShowFileFilter");
3758         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_file_filter);
3759 }
3760
3761 void layout_util_sync_marks(LayoutWindow *lw)
3762 {
3763         GtkAction *action;
3764
3765         if (!lw->action_group) return;
3766
3767         action = gtk_action_group_get_action(lw->action_group, "ShowMarks");
3768         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_marks);
3769 }
3770
3771 static void layout_util_sync_views(LayoutWindow *lw)
3772 {
3773         GtkAction *action;
3774         OsdShowFlags osd_flags = image_osd_get(lw->image);
3775
3776         if (!lw->action_group) return;
3777
3778         action = gtk_action_group_get_action(lw->action_group, "FolderTree");
3779         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.dir_view_type);
3780
3781         action = gtk_action_group_get_action(lw->action_group, "SplitSingle");
3782         gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), lw->split_mode);
3783
3784         action = gtk_action_group_get_action(lw->action_group, "SplitNextPane");
3785         gtk_action_set_sensitive(action, !(lw->split_mode == SPLIT_NONE));
3786         action = gtk_action_group_get_action(lw->action_group, "SplitPreviousPane");
3787         gtk_action_set_sensitive(action, !(lw->split_mode == SPLIT_NONE));
3788         action = gtk_action_group_get_action(lw->action_group, "SplitUpPane");
3789         gtk_action_set_sensitive(action, !(lw->split_mode == SPLIT_NONE));
3790         action = gtk_action_group_get_action(lw->action_group, "SplitDownPane");
3791         gtk_action_set_sensitive(action, !(lw->split_mode == SPLIT_NONE));
3792
3793         action = gtk_action_group_get_action(lw->action_group, "SplitPaneSync");
3794         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.split_pane_sync);
3795
3796         action = gtk_action_group_get_action(lw->action_group, "ViewIcons");
3797         gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), lw->options.file_view_type);
3798
3799         action = gtk_action_group_get_action(lw->action_group, "FloatTools");
3800         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.tools_float);
3801
3802         action = gtk_action_group_get_action(lw->action_group, "SBar");
3803         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), layout_bar_enabled(lw));
3804
3805         action = gtk_action_group_get_action(lw->action_group, "SBarSort");
3806         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), layout_bar_sort_enabled(lw));
3807
3808         action = gtk_action_group_get_action(lw->action_group, "HideToolbar");
3809         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.toolbar_hidden);
3810
3811         action = gtk_action_group_get_action(lw->action_group, "ShowInfoPixel");
3812         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_info_pixel);
3813
3814         action = gtk_action_group_get_action(lw->action_group, "SlideShow");
3815         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), layout_image_slideshow_active(lw));
3816
3817         action = gtk_action_group_get_action(lw->action_group, "IgnoreAlpha");
3818         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.ignore_alpha);
3819
3820         action = gtk_action_group_get_action(lw->action_group, "Animate");
3821         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.animate);
3822
3823         action = gtk_action_group_get_action(lw->action_group, "ImageOverlay");
3824         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), osd_flags != OSD_SHOW_NOTHING);
3825
3826         action = gtk_action_group_get_action(lw->action_group, "ImageHistogram");
3827         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), osd_flags & OSD_SHOW_HISTOGRAM);
3828
3829         action = gtk_action_group_get_action(lw->action_group, "ExifRotate");
3830         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), options->image.exif_rotate_enable);
3831
3832         action = gtk_action_group_get_action(lw->action_group, "OverUnderExposed");
3833         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), options->overunderexposed);
3834
3835         action = gtk_action_group_get_action(lw->action_group, "DrawRectangle");
3836         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), options->draw_rectangle);
3837
3838         action = gtk_action_group_get_action(lw->action_group, "RectangularSelection");
3839         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), options->collections.rectangular_selection);
3840
3841         action = gtk_action_group_get_action(lw->action_group, "ShowFileFilter");
3842         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_file_filter);
3843
3844         action = gtk_action_group_get_action(lw->action_group, "HideBars");
3845         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), (lw->options.bars_state.hidden));
3846
3847         if (osd_flags & OSD_SHOW_HISTOGRAM)
3848                 {
3849                 action = gtk_action_group_get_action(lw->action_group, "HistogramChanR");
3850                 gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), image_osd_histogram_get_channel(lw->image));
3851
3852                 action = gtk_action_group_get_action(lw->action_group, "HistogramModeLin");
3853                 gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), image_osd_histogram_get_mode(lw->image));
3854                 }
3855
3856         action = gtk_action_group_get_action(lw->action_group, "ConnectZoomMenu");
3857         gtk_action_set_sensitive(action, lw->split_mode != SPLIT_NONE);
3858
3859         action = gtk_action_group_get_action(lw->action_group, "WriteRotation");
3860         gtk_action_set_sensitive(action, !(runcmd("which exiftran >/dev/null 2>&1") ||
3861                                                         runcmd("which mogrify >/dev/null 2>&1") || options->metadata.write_orientation));
3862         action = gtk_action_group_get_action(lw->action_group, "WriteRotationKeepDate");
3863         gtk_action_set_sensitive(action, !(runcmd("which exiftran >/dev/null 2>&1") ||
3864                                                         runcmd("which mogrify >/dev/null 2>&1") || options->metadata.write_orientation));
3865
3866         action = gtk_action_group_get_action(lw->action_group, "StereoAuto");
3867         gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), layout_image_stereo_pixbuf_get(lw));
3868
3869         layout_util_sync_marks(lw);
3870         layout_util_sync_color(lw);
3871         layout_image_set_ignore_alpha(lw, lw->options.ignore_alpha);
3872 }
3873
3874 void layout_util_sync_thumb(LayoutWindow *lw)
3875 {
3876         GtkAction *action;
3877
3878         if (!lw->action_group) return;
3879
3880         action = gtk_action_group_get_action(lw->action_group, "Thumbnails");
3881         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_thumbnails);
3882         g_object_set(action, "sensitive", (lw->options.file_view_type == FILEVIEW_LIST), NULL);
3883 }
3884
3885 void layout_util_sync(LayoutWindow *lw)
3886 {
3887         layout_util_sync_views(lw);
3888         layout_util_sync_thumb(lw);
3889         layout_menu_recent_update(lw);
3890 //      layout_menu_edit_update(lw);
3891 }
3892
3893 /**
3894  * @brief Checks if event key is mapped to Help
3895  * @param event
3896  * @returns
3897  *
3898  * Used to check if the user has re-mapped the Help key
3899  * in Preferences/Keyboard
3900  *
3901  * Note: help_key.accel_mods and event->state
3902  * differ in the higher bits
3903  */
3904 gboolean is_help_key(GdkEventKey *event)
3905 {
3906         GtkAccelKey help_key;
3907         gboolean ret = FALSE;
3908         guint mask = GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK;
3909
3910         if (gtk_accel_map_lookup_entry("<Actions>/MenuActions/HelpContents", &help_key))
3911                 {
3912                 if (help_key.accel_key == event->keyval &&
3913                                         (help_key.accel_mods & mask) == (event->state & mask))
3914                         {
3915                         ret = TRUE;
3916                         }
3917                 }
3918
3919         return ret;
3920 }
3921
3922 /*
3923  *-----------------------------------------------------------------------------
3924  * sidebars
3925  *-----------------------------------------------------------------------------
3926  */
3927
3928 static gboolean layout_bar_enabled(LayoutWindow *lw)
3929 {
3930         return lw->bar && gtk_widget_get_visible(lw->bar);
3931 }
3932
3933 static void layout_bar_destroyed(GtkWidget *UNUSED(widget), gpointer data)
3934 {
3935         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
3936
3937         lw->bar = NULL;
3938 /*
3939     do not call layout_util_sync_views(lw) here
3940     this is called either when whole layout is destroyed - no need for update
3941     or when the bar is replaced - sync is called by upper function at the end of whole operation
3942
3943 */
3944 }
3945
3946 static void layout_bar_set_default(LayoutWindow *lw)
3947 {
3948         GtkWidget *bar;
3949
3950         if (!lw->utility_box) return;
3951
3952         bar = bar_new(lw);
3953         DEBUG_NAME(bar);
3954
3955         layout_bar_set(lw, bar);
3956
3957         bar_populate_default(bar);
3958 }
3959
3960 static void layout_bar_close(LayoutWindow *lw)
3961 {
3962         if (lw->bar)
3963                 {
3964                 bar_close(lw->bar);
3965                 lw->bar = NULL;
3966                 }
3967 }
3968
3969
3970 void layout_bar_set(LayoutWindow *lw, GtkWidget *bar)
3971 {
3972         if (!lw->utility_box) return;
3973
3974         layout_bar_close(lw); /* if any */
3975
3976         if (!bar) return;
3977         lw->bar = bar;
3978
3979         g_signal_connect(G_OBJECT(lw->bar), "destroy",
3980                          G_CALLBACK(layout_bar_destroyed), lw);
3981
3982
3983 //      gtk_box_pack_start(GTK_BOX(lw->utility_box), lw->bar, FALSE, FALSE, 0);
3984         gtk_paned_pack2(GTK_PANED(lw->utility_paned), lw->bar, FALSE, TRUE);
3985
3986         bar_set_fd(lw->bar, layout_image_get_fd(lw));
3987 }
3988
3989
3990 void layout_bar_toggle(LayoutWindow *lw)
3991 {
3992         if (layout_bar_enabled(lw))
3993                 {
3994                 gtk_widget_hide(lw->bar);
3995                 }
3996         else
3997                 {
3998                 if (!lw->bar)
3999                         {
4000                         layout_bar_set_default(lw);
4001                         }
4002                 gtk_widget_show(lw->bar);
4003                 bar_set_fd(lw->bar, layout_image_get_fd(lw));
4004                 }
4005         layout_util_sync_views(lw);
4006 }
4007
4008 static void layout_bar_new_image(LayoutWindow *lw)
4009 {
4010         if (!layout_bar_enabled(lw)) return;
4011
4012         bar_set_fd(lw->bar, layout_image_get_fd(lw));
4013 }
4014
4015 static void layout_bar_new_selection(LayoutWindow *lw, gint count)
4016 {
4017         if (!layout_bar_enabled(lw)) return;
4018
4019         bar_notify_selection(lw->bar, count);
4020 }
4021
4022 static gboolean layout_bar_sort_enabled(LayoutWindow *lw)
4023 {
4024         return lw->bar_sort && gtk_widget_get_visible(lw->bar_sort);
4025 }
4026
4027
4028 static void layout_bar_sort_destroyed(GtkWidget *UNUSED(widget), gpointer data)
4029 {
4030         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
4031
4032         lw->bar_sort = NULL;
4033
4034 /*
4035     do not call layout_util_sync_views(lw) here
4036     this is called either when whole layout is destroyed - no need for update
4037     or when the bar is replaced - sync is called by upper function at the end of whole operation
4038
4039 */
4040 }
4041
4042 static void layout_bar_sort_set_default(LayoutWindow *lw)
4043 {
4044         GtkWidget *bar;
4045
4046         if (!lw->utility_box) return;
4047
4048         bar = bar_sort_new_default(lw);
4049
4050         layout_bar_sort_set(lw, bar);
4051 }
4052
4053 static void layout_bar_sort_close(LayoutWindow *lw)
4054 {
4055         if (lw->bar_sort)
4056                 {
4057                 bar_sort_close(lw->bar_sort);
4058                 lw->bar_sort = NULL;
4059                 }
4060 }
4061
4062 void layout_bar_sort_set(LayoutWindow *lw, GtkWidget *bar)
4063 {
4064         if (!lw->utility_box) return;
4065
4066         layout_bar_sort_close(lw); /* if any */
4067
4068         if (!bar) return;
4069         lw->bar_sort = bar;
4070
4071         g_signal_connect(G_OBJECT(lw->bar_sort), "destroy",
4072                          G_CALLBACK(layout_bar_sort_destroyed), lw);
4073
4074         gtk_box_pack_end(GTK_BOX(lw->utility_box), lw->bar_sort, FALSE, FALSE, 0);
4075 }
4076
4077 void layout_bar_sort_toggle(LayoutWindow *lw)
4078 {
4079         if (layout_bar_sort_enabled(lw))
4080                 {
4081                 gtk_widget_hide(lw->bar_sort);
4082                 }
4083         else
4084                 {
4085                 if (!lw->bar_sort)
4086                         {
4087                         layout_bar_sort_set_default(lw);
4088                         }
4089                 gtk_widget_show(lw->bar_sort);
4090                 }
4091         layout_util_sync_views(lw);
4092 }
4093
4094 static void layout_bars_hide_toggle(LayoutWindow *lw)
4095 {
4096         if (lw->options.bars_state.hidden)
4097                 {
4098                 lw->options.bars_state.hidden = FALSE;
4099                 if (lw->options.bars_state.sort)
4100                         {
4101                         if (lw->bar_sort)
4102                                 {
4103                                 gtk_widget_show(lw->bar_sort);
4104                                 }
4105                         else
4106                                 {
4107                                 layout_bar_sort_set_default(lw);
4108                                 }
4109                         }
4110                 if (lw->options.bars_state.info)
4111                         {
4112                         gtk_widget_show(lw->bar);
4113                         }
4114                 layout_tools_float_set(lw, lw->options.tools_float,
4115                                                                         lw->options.bars_state.tools_hidden);
4116                 }
4117         else
4118                 {
4119                 lw->options.bars_state.hidden = TRUE;
4120                 lw->options.bars_state.sort = layout_bar_sort_enabled(lw);
4121                 lw->options.bars_state.info = layout_bar_enabled(lw);
4122                 lw->options.bars_state.tools_float = lw->options.tools_float;
4123                 lw->options.bars_state.tools_hidden = lw->options.tools_hidden;
4124
4125                 if (lw->bar)
4126                         {
4127                         gtk_widget_hide(lw->bar);
4128                         }
4129
4130                 if (lw->bar_sort)
4131                         gtk_widget_hide(lw->bar_sort);
4132                 layout_tools_float_set(lw, lw->options.tools_float, TRUE);
4133                 }
4134
4135         layout_util_sync_views(lw);
4136 }
4137
4138 void layout_bars_new_image(LayoutWindow *lw)
4139 {
4140         layout_bar_new_image(lw);
4141
4142         if (lw->exif_window) advanced_exif_set_fd(lw->exif_window, layout_image_get_fd(lw));
4143
4144         /* this should be called here to handle the metadata edited in bars */
4145         if (options->metadata.confirm_on_image_change)
4146                 metadata_write_queue_confirm(FALSE, NULL, NULL);
4147 }
4148
4149 void layout_bars_new_selection(LayoutWindow *lw, gint count)
4150 {
4151         layout_bar_new_selection(lw, count);
4152 }
4153
4154 GtkWidget *layout_bars_prepare(LayoutWindow *lw, GtkWidget *image)
4155 {
4156         if (lw->utility_box) return lw->utility_box;
4157         lw->utility_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
4158         lw->utility_paned = gtk_hpaned_new();
4159         DEBUG_NAME(lw->utility_paned);
4160         gtk_box_pack_start(GTK_BOX(lw->utility_box), lw->utility_paned, TRUE, TRUE, 0);
4161
4162         gtk_paned_pack1(GTK_PANED(lw->utility_paned), image, TRUE, FALSE);
4163         gtk_widget_show(lw->utility_paned);
4164
4165         gtk_widget_show(image);
4166
4167         g_object_ref(lw->utility_box);
4168         return lw->utility_box;
4169 }
4170
4171 void layout_bars_close(LayoutWindow *lw)
4172 {
4173         layout_bar_sort_close(lw);
4174         layout_bar_close(lw);
4175 }
4176
4177 static gboolean layout_exif_window_destroy(GtkWidget *UNUSED(widget), gpointer data)
4178 {
4179         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
4180         lw->exif_window = NULL;
4181
4182         return TRUE;
4183 }
4184
4185 void layout_exif_window_new(LayoutWindow *lw)
4186 {
4187         if (lw->exif_window) return;
4188
4189         lw->exif_window = advanced_exif_new(lw);
4190         if (!lw->exif_window) return;
4191         g_signal_connect(G_OBJECT(lw->exif_window), "destroy",
4192                          G_CALLBACK(layout_exif_window_destroy), lw);
4193         advanced_exif_set_fd(lw->exif_window, layout_image_get_fd(lw));
4194 }
4195
4196 static void layout_search_and_run_window_new(LayoutWindow *lw)
4197 {
4198         if (lw->sar_window)
4199                 {
4200                 gtk_window_present(GTK_WINDOW(lw->sar_window));
4201                 return;
4202                 }
4203
4204         lw->sar_window = search_and_run_new(lw);
4205 }
4206
4207 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */