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 = 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, 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, 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, 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         char *key_name, *converted_line;
1297         int keymap_index;
1298         guint index;
1299
1300         fd = g_file_open_tmp("geeqie_keymap_XXXXXX.svg", &tmp_file, &error);
1301         if (error)
1302                 {
1303                 log_printf("Error: Keyboard Map - cannot create file:%s\n",error->message);
1304                 g_error_free(error);
1305                 }
1306         else
1307                 {
1308                 array = g_ptr_array_new();
1309
1310                 gtk_accel_map_foreach(array, layout_menu_foreach_func);
1311
1312                 channel = g_io_channel_unix_new(fd);
1313
1314                 keymap_index = 0;
1315                 while (keymap_template[keymap_index])
1316                         {
1317                         if (g_strrstr(keymap_template[keymap_index], ">key:"))
1318                                 {
1319                                 pre_key = g_strsplit(keymap_template[keymap_index],">key:",2);
1320                                 post_key = g_strsplit(pre_key[1],"<",2);
1321
1322                                 index=0;
1323                                 key_name = " ";
1324                                 for (index=0; index < array->len-2; index=index+2)
1325                                         {
1326                                         if (!(g_ascii_strcasecmp(g_ptr_array_index(array,index+1), post_key[0])))
1327                                                 {
1328                                                 key_name = g_ptr_array_index(array,index+0);
1329                                                 break;
1330                                                 }
1331                                         }
1332
1333                                 index=0;
1334                                 while (keyboard_map_hardcoded[index][0])
1335                                         {
1336                                         if (!(g_strcmp0(keyboard_map_hardcoded[index][1], post_key[0])))
1337                                                 {
1338                                                 key_name = keyboard_map_hardcoded[index][0];
1339                                                 break;
1340                                                 }
1341                                         index++;
1342                                         }
1343
1344                                 converted_line = g_strconcat(pre_key[0], ">", key_name, "<", post_key[1], "\n", NULL);
1345                                 g_io_channel_write_chars(channel, converted_line, -1, NULL, &error);
1346                                 if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
1347
1348                                 g_free(converted_line);
1349                                 g_strfreev(pre_key);
1350                                 g_strfreev(post_key);
1351                                 }
1352                         else
1353                                 {
1354                                 g_io_channel_write_chars(channel, keymap_template[keymap_index], -1, NULL, &error);
1355                                 if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
1356                                 g_io_channel_write_chars(channel, "\n", -1, NULL, &error);
1357                                 if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
1358                                 }
1359                         keymap_index++;
1360                         }
1361
1362                 g_io_channel_flush(channel, &error);
1363                 if (error) {log_printf("Warning: Keyboard Map:%s\n",error->message); g_error_free(error);}
1364                 g_io_channel_unref(channel);
1365
1366                 index=0;
1367                 for (index=0; index < array->len-2; index=index+2)
1368                         {
1369                         g_free(g_ptr_array_index(array,index));
1370                         g_free(g_ptr_array_index(array,index+1));
1371                         }
1372                 g_ptr_array_unref(array);
1373
1374                 view_window_new(file_data_new_simple(tmp_file));
1375                 g_free(tmp_file);
1376                 }
1377 }
1378
1379 static void layout_menu_about_cb(GtkAction *UNUSED(action), gpointer data)
1380 {
1381         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1382
1383         layout_exit_fullscreen(lw);
1384         show_about_window(lw);
1385 }
1386
1387 static void layout_menu_log_window_cb(GtkAction *UNUSED(action), gpointer data)
1388 {
1389         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1390
1391         layout_exit_fullscreen(lw);
1392         log_window_new(lw);
1393 }
1394
1395
1396 /*
1397  *-----------------------------------------------------------------------------
1398  * select menu
1399  *-----------------------------------------------------------------------------
1400  */
1401
1402 static void layout_menu_select_all_cb(GtkAction *UNUSED(action), gpointer data)
1403 {
1404         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1405
1406         layout_select_all(lw);
1407 }
1408
1409 static void layout_menu_unselect_all_cb(GtkAction *UNUSED(action), gpointer data)
1410 {
1411         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1412
1413         layout_select_none(lw);
1414 }
1415
1416 static void layout_menu_invert_selection_cb(GtkAction *UNUSED(action), gpointer data)
1417 {
1418         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1419
1420         layout_select_invert(lw);
1421 }
1422
1423 static void layout_menu_file_filter_cb(GtkToggleAction *action, gpointer data)
1424 {
1425         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1426
1427         layout_file_filter_set(lw, gtk_toggle_action_get_active(action));
1428 }
1429
1430 static void layout_menu_marks_cb(GtkToggleAction *action, gpointer data)
1431 {
1432         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1433
1434         layout_marks_set(lw, gtk_toggle_action_get_active(action));
1435 }
1436
1437
1438 static void layout_menu_set_mark_sel_cb(GtkAction *action, gpointer data)
1439 {
1440         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1441         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1442         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1443
1444         layout_selection_to_mark(lw, mark, STM_MODE_SET);
1445 }
1446
1447 static void layout_menu_res_mark_sel_cb(GtkAction *action, gpointer data)
1448 {
1449         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1450         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1451         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1452
1453         layout_selection_to_mark(lw, mark, STM_MODE_RESET);
1454 }
1455
1456 static void layout_menu_toggle_mark_sel_cb(GtkAction *action, gpointer data)
1457 {
1458         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1459         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1460         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1461
1462         layout_selection_to_mark(lw, mark, STM_MODE_TOGGLE);
1463 }
1464
1465 static void layout_menu_sel_mark_cb(GtkAction *action, gpointer data)
1466 {
1467         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1468         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1469         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1470
1471         layout_mark_to_selection(lw, mark, MTS_MODE_SET);
1472 }
1473
1474 static void layout_menu_sel_mark_or_cb(GtkAction *action, gpointer data)
1475 {
1476         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1477         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1478         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1479
1480         layout_mark_to_selection(lw, mark, MTS_MODE_OR);
1481 }
1482
1483 static void layout_menu_sel_mark_and_cb(GtkAction *action, gpointer data)
1484 {
1485         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1486         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1487         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1488
1489         layout_mark_to_selection(lw, mark, MTS_MODE_AND);
1490 }
1491
1492 static void layout_menu_sel_mark_minus_cb(GtkAction *action, gpointer data)
1493 {
1494         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1495         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1496         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1497
1498         layout_mark_to_selection(lw, mark, MTS_MODE_MINUS);
1499 }
1500
1501 static void layout_menu_mark_filter_toggle_cb(GtkAction *action, gpointer data)
1502 {
1503         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1504         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(action), "mark_num"));
1505         g_assert(mark >= 1 && mark <= FILEDATA_MARKS_SIZE);
1506
1507         layout_marks_set(lw, TRUE);
1508         layout_mark_filter_toggle(lw, mark);
1509 }
1510
1511
1512 /*
1513  *-----------------------------------------------------------------------------
1514  * go menu
1515  *-----------------------------------------------------------------------------
1516  */
1517
1518 static void layout_menu_image_first_cb(GtkAction *UNUSED(action), gpointer data)
1519 {
1520         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1521         layout_image_first(lw);
1522 }
1523
1524 static void layout_menu_image_prev_cb(GtkAction *UNUSED(action), gpointer data)
1525 {
1526         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1527         gint i;
1528
1529         if (lw->options.split_pane_sync)
1530                 {
1531                 for (i = 0; i < MAX_SPLIT_IMAGES; i++)
1532                         {
1533                         if (lw->split_images[i])
1534                                 {
1535                                 if (i != -1)
1536                                         {
1537                                         DEBUG_1("image activate scroll %d", i);
1538                                         layout_image_activate(lw, i, FALSE);
1539                                         layout_image_prev(lw);
1540                                         }
1541                                 }
1542                         }
1543                 }
1544         else
1545                 {
1546                 layout_image_prev(lw);
1547                 }
1548 }
1549
1550 static void layout_menu_image_next_cb(GtkAction *UNUSED(action), gpointer data)
1551 {
1552         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1553         gint i;
1554
1555         if (lw->options.split_pane_sync)
1556                 {
1557                 for (i = 0; i < MAX_SPLIT_IMAGES; i++)
1558                         {
1559                         if (lw->split_images[i])
1560                                 {
1561                                 if (i != -1)
1562                                         {
1563                                         DEBUG_1("image activate scroll %d", i);
1564                                         layout_image_activate(lw, i, FALSE);
1565                                         layout_image_next(lw);
1566                                         }
1567                                 }
1568                         }
1569                 }
1570         else
1571                 {
1572                 layout_image_next(lw);
1573                 }
1574 }
1575
1576 static void layout_menu_page_first_cb(GtkAction *UNUSED(action), gpointer data)
1577 {
1578         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1579         FileData *fd = layout_image_get_fd(lw);
1580
1581         if (fd->page_total > 0)
1582                 {
1583                 file_data_set_page_num(fd, 1);
1584                 }
1585 }
1586
1587 static void layout_menu_page_last_cb(GtkAction *UNUSED(action), gpointer data)
1588 {
1589         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1590         FileData *fd = layout_image_get_fd(lw);
1591
1592         if (fd->page_total > 0)
1593                 {
1594                 file_data_set_page_num(fd, -1);
1595                 }
1596 }
1597
1598 static void layout_menu_page_next_cb(GtkAction *UNUSED(action), gpointer data)
1599 {
1600         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1601         FileData *fd = layout_image_get_fd(lw);
1602
1603         if (fd->page_total > 0)
1604                 {
1605                 file_data_inc_page_num(fd);
1606                 }
1607 }
1608
1609 static void layout_menu_page_previous_cb(GtkAction *UNUSED(action), gpointer data)
1610 {
1611         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1612         FileData *fd = layout_image_get_fd(lw);
1613
1614         if (fd->page_total > 0)
1615                 {
1616                 file_data_dec_page_num(fd);
1617                 }
1618 }
1619
1620 static void layout_menu_image_forward_cb(GtkAction *UNUSED(action), gpointer data)
1621 {
1622         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1623
1624         /* Obtain next image */
1625         layout_set_path(lw, image_chain_forward());
1626 }
1627
1628 static void layout_menu_image_back_cb(GtkAction *UNUSED(action), gpointer data)
1629 {
1630         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1631
1632         /* Obtain previous image */
1633         layout_set_path(lw, image_chain_back());
1634 }
1635
1636 static void layout_menu_split_pane_next_cb(GtkAction *UNUSED(action), gpointer data)
1637 {
1638         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1639         gint active_frame;
1640
1641         active_frame = lw->active_split_image;
1642
1643         if (active_frame < MAX_SPLIT_IMAGES-1 && lw->split_images[active_frame+1] )
1644                 {
1645                 active_frame++;
1646                 }
1647         else
1648                 {
1649                 active_frame = 0;
1650                 }
1651         layout_image_activate(lw, active_frame, FALSE);
1652 }
1653
1654 static void layout_menu_split_pane_prev_cb(GtkAction *UNUSED(action), gpointer data)
1655 {
1656         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1657         gint active_frame;
1658
1659         active_frame = lw->active_split_image;
1660
1661         if (active_frame >=1 && lw->split_images[active_frame-1] )
1662                 {
1663                 active_frame--;
1664                 }
1665         else
1666                 {
1667                 active_frame = MAX_SPLIT_IMAGES-1;
1668                 while (!lw->split_images[active_frame])
1669                         {
1670                         active_frame--;
1671                         }
1672                 }
1673         layout_image_activate(lw, active_frame, FALSE);
1674 }
1675
1676 static void layout_menu_split_pane_updown_cb(GtkAction *UNUSED(action), gpointer data)
1677 {
1678         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1679         gint active_frame;
1680
1681         active_frame = lw->active_split_image;
1682
1683         if (lw->split_images[MAX_SPLIT_IMAGES-1] )
1684                 {
1685                 active_frame = active_frame ^ 2;
1686                 }
1687         else
1688                 {
1689                 active_frame = active_frame ^ 1;
1690                 }
1691         layout_image_activate(lw, active_frame, FALSE);
1692 }
1693
1694 static void layout_menu_image_last_cb(GtkAction *UNUSED(action), gpointer data)
1695 {
1696         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1697         layout_image_last(lw);
1698 }
1699
1700 static void layout_menu_back_cb(GtkAction *UNUSED(action), gpointer data)
1701 {
1702         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1703         FileData *dir_fd;
1704
1705         /* Obtain previous path */
1706         dir_fd = file_data_new_dir(history_chain_back());
1707         layout_set_fd(lw, dir_fd);
1708         file_data_unref(dir_fd);
1709 }
1710
1711 static void layout_menu_forward_cb(GtkAction *UNUSED(action), gpointer data)
1712 {
1713         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1714         FileData *dir_fd;
1715
1716         /* Obtain next path */
1717         dir_fd = file_data_new_dir(history_chain_forward());
1718         layout_set_fd(lw, dir_fd);
1719         file_data_unref(dir_fd);
1720 }
1721
1722 static void layout_menu_home_cb(GtkAction *UNUSED(action), gpointer data)
1723 {
1724         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1725         const gchar *path;
1726
1727         if (lw->options.home_path && *lw->options.home_path)
1728                 path = lw->options.home_path;
1729         else
1730                 path = homedir();
1731
1732         if (path)
1733                 {
1734                 FileData *dir_fd = file_data_new_dir(path);
1735                 layout_set_fd(lw, dir_fd);
1736                 file_data_unref(dir_fd);
1737                 }
1738 }
1739
1740 static void layout_menu_up_cb(GtkAction *UNUSED(action), gpointer data)
1741 {
1742         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1743         ViewDir *vd = lw->vd;
1744         gchar *path;
1745
1746         if (!vd->dir_fd || strcmp(vd->dir_fd->path, G_DIR_SEPARATOR_S) == 0) return;
1747         path = remove_level_from_path(vd->dir_fd->path);
1748
1749         if (vd->select_func)
1750                 {
1751                 FileData *fd = file_data_new_dir(path);
1752                 vd->select_func(vd, fd, vd->select_data);
1753                 file_data_unref(fd);
1754                 }
1755
1756         g_free(path);
1757 }
1758
1759
1760 /*
1761  *-----------------------------------------------------------------------------
1762  * edit menu
1763  *-----------------------------------------------------------------------------
1764  */
1765
1766 static void layout_menu_edit_cb(GtkAction *action, gpointer data)
1767 {
1768         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1769         const gchar *key = gtk_action_get_name(action);
1770
1771         if (!editor_window_flag_set(key))
1772                 layout_exit_fullscreen(lw);
1773
1774         file_util_start_editor_from_filelist(key, layout_selection_list(lw), layout_get_path(lw), lw->window);
1775 }
1776
1777
1778 static void layout_menu_metadata_write_cb(GtkAction *UNUSED(action), gpointer UNUSED(data))
1779 {
1780         metadata_write_queue_confirm(TRUE, NULL, NULL);
1781 }
1782
1783 static GtkWidget *last_focussed = NULL;
1784 static void layout_menu_keyword_autocomplete_cb(GtkAction *UNUSED(action), gpointer data)
1785 {
1786         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1787         GtkWidget *tmp;
1788         gboolean auto_has_focus;
1789
1790         tmp = gtk_window_get_focus(GTK_WINDOW(lw->window));
1791         auto_has_focus = bar_keywords_autocomplete_focus(lw);
1792
1793         if (auto_has_focus)
1794                 {
1795                 gtk_widget_grab_focus(last_focussed);
1796                 }
1797         else
1798                 {
1799                 last_focussed = tmp;
1800                 }
1801 }
1802
1803 /*
1804  *-----------------------------------------------------------------------------
1805  * color profile button (and menu)
1806  *-----------------------------------------------------------------------------
1807  */
1808 #ifdef HAVE_LCMS
1809 static void layout_color_menu_enable_cb(GtkToggleAction *action, gpointer data)
1810 {
1811         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1812
1813         if (layout_image_color_profile_get_use(lw) == gtk_toggle_action_get_active(action)) return;
1814
1815         layout_image_color_profile_set_use(lw, gtk_toggle_action_get_active(action));
1816         layout_util_sync_color(lw);
1817         layout_image_refresh(lw);
1818 }
1819 #else
1820 static void layout_color_menu_enable_cb()
1821 {
1822 }
1823 #endif
1824
1825 #ifdef HAVE_LCMS
1826 static void layout_color_menu_use_image_cb(GtkToggleAction *action, gpointer data)
1827 {
1828         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1829         gint input;
1830         gboolean use_image;
1831
1832         if (!layout_image_color_profile_get(lw, &input, &use_image)) return;
1833         if (use_image == gtk_toggle_action_get_active(action)) return;
1834         layout_image_color_profile_set(lw, input, gtk_toggle_action_get_active(action));
1835         layout_util_sync_color(lw);
1836         layout_image_refresh(lw);
1837 }
1838 #else
1839 static void layout_color_menu_use_image_cb()
1840 {
1841 }
1842 #endif
1843
1844 #ifdef HAVE_LCMS
1845 static void layout_color_menu_input_cb(GtkRadioAction *action, GtkRadioAction *UNUSED(current), gpointer data)
1846 {
1847         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
1848         gint type;
1849         gint input;
1850         gboolean use_image;
1851
1852         type = gtk_radio_action_get_current_value(action);
1853         if (type < 0 || type >= COLOR_PROFILE_FILE + COLOR_PROFILE_INPUTS) return;
1854
1855         if (!layout_image_color_profile_get(lw, &input, &use_image)) return;
1856         if (type == input) return;
1857
1858         layout_image_color_profile_set(lw, type, use_image);
1859         layout_image_refresh(lw);
1860 }
1861 #else
1862 static void layout_color_menu_input_cb()
1863 {
1864 }
1865 #endif
1866
1867
1868 /*
1869  *-----------------------------------------------------------------------------
1870  * recent menu
1871  *-----------------------------------------------------------------------------
1872  */
1873
1874 static void layout_menu_recent_cb(GtkWidget *widget, gpointer UNUSED(data))
1875 {
1876         gint n;
1877         gchar *path;
1878
1879         n = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "recent_index"));
1880
1881         path = static_cast<gchar *>(g_list_nth_data(history_list_get_by_key("recent"), n));
1882
1883         if (!path) return;
1884
1885         /* make a copy of it */
1886         path = g_strdup(path);
1887         collection_window_new(path);
1888         g_free(path);
1889 }
1890
1891 static void layout_menu_recent_update(LayoutWindow *lw)
1892 {
1893         GtkWidget *menu;
1894         GtkWidget *recent;
1895         GtkWidget *item;
1896         GList *list;
1897         gint n;
1898
1899         if (!lw->ui_manager) return;
1900
1901         list = history_list_get_by_key("recent");
1902         n = 0;
1903
1904         menu = gtk_menu_new();
1905
1906         while (list)
1907                 {
1908                 const gchar *filename = filename_from_path((gchar *)list->data);
1909                 gchar *name;
1910                 gboolean free_name = FALSE;
1911
1912                 if (file_extension_match(filename, GQ_COLLECTION_EXT))
1913                         {
1914                         name = remove_extension_from_path(filename);
1915                         free_name = TRUE;
1916                         }
1917                 else
1918                         {
1919                         name = (gchar *) filename;
1920                         }
1921
1922                 item = menu_item_add_simple(menu, name, G_CALLBACK(layout_menu_recent_cb), lw);
1923                 if (free_name) g_free(name);
1924                 g_object_set_data(G_OBJECT(item), "recent_index", GINT_TO_POINTER(n));
1925                 list = list->next;
1926                 n++;
1927                 }
1928
1929         if (n == 0)
1930                 {
1931                 menu_item_add(menu, _("Empty"), NULL, NULL);
1932                 }
1933
1934         recent = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/FileMenu/OpenRecent");
1935         gtk_menu_item_set_submenu(GTK_MENU_ITEM(recent), menu);
1936         gtk_widget_set_sensitive(recent, (n != 0));
1937 }
1938
1939 void layout_recent_update_all(void)
1940 {
1941         GList *work;
1942
1943         work = layout_window_list;
1944         while (work)
1945                 {
1946                 LayoutWindow *lw = static_cast<LayoutWindow *>(work->data);
1947                 work = work->next;
1948
1949                 layout_menu_recent_update(lw);
1950                 }
1951 }
1952
1953 void layout_recent_add_path(const gchar *path)
1954 {
1955         if (!path) return;
1956
1957         history_list_add_to_key("recent", path, options->open_recent_list_maxsize);
1958
1959         layout_recent_update_all();
1960 }
1961
1962 /*
1963  *-----------------------------------------------------------------------------
1964  * window layout menu
1965  *-----------------------------------------------------------------------------
1966  */
1967 typedef struct _WindowNames WindowNames;
1968 struct _WindowNames
1969 {
1970         gboolean displayed;
1971         gchar *name;
1972         gchar *path;
1973 };
1974
1975 typedef struct _RenameWindow RenameWindow;
1976 struct _RenameWindow
1977 {
1978         GenericDialog *gd;
1979         LayoutWindow *lw;
1980
1981         GtkWidget *button_ok;
1982         GtkWidget *window_name_entry;
1983 };
1984
1985 typedef struct _DeleteWindow DeleteWindow;
1986 struct _DeleteWindow
1987 {
1988         GenericDialog *gd;
1989         LayoutWindow *lw;
1990
1991         GtkWidget *button_ok;
1992         GtkWidget *group;
1993 };
1994
1995 static gint layout_window_menu_list_sort_cb(gconstpointer a, gconstpointer b)
1996 {
1997         const WindowNames *wna = a;
1998         const WindowNames *wnb = b;
1999
2000         return g_strcmp0((gchar *)wna->name, (gchar *)wnb->name);
2001 }
2002
2003 static GList *layout_window_menu_list(GList *listin)
2004 {
2005         GList *list;
2006         WindowNames *wn;
2007         gboolean dupe;
2008         DIR *dp;
2009         struct dirent *dir;
2010         gchar *pathl;
2011
2012         pathl = path_from_utf8(get_window_layouts_dir());
2013         dp = opendir(pathl);
2014         if (!dp)
2015                 {
2016                 /* dir not found */
2017                 g_free(pathl);
2018                 return listin;
2019                 }
2020
2021         while ((dir = readdir(dp)) != NULL)
2022                 {
2023                 gchar *name_file = dir->d_name;
2024
2025                 if (g_str_has_suffix(name_file, ".xml"))
2026                         {
2027                         LayoutWindow *lw_tmp ;
2028                         gchar *name_utf8 = path_to_utf8(name_file);
2029                         gchar *name_base = g_strndup(name_utf8, strlen(name_utf8) - 4);
2030                         list = layout_window_list;
2031                         dupe = FALSE;
2032                         while (list)
2033                                 {
2034                                 lw_tmp = static_cast<LayoutWindow *>(list->data);
2035                                 if (g_strcmp0(lw_tmp->options.id, name_base) == 0)
2036                                         {
2037                                         dupe = TRUE;
2038                                         }
2039                                 list = list->next;
2040                                 }
2041                         gchar *dpath = g_build_filename(pathl, name_utf8, NULL);
2042                         wn  = g_new0(WindowNames, 1);
2043                         wn->displayed = dupe;
2044                         wn->name = g_strdup(name_base);
2045                         wn->path = g_strdup(dpath);
2046                         listin = g_list_append(listin, wn);
2047
2048                         g_free(dpath);
2049                         g_free(name_utf8);
2050                         g_free(name_base);
2051                         }
2052                 }
2053         closedir(dp);
2054
2055         g_free(pathl);
2056
2057         return g_list_sort(listin, layout_window_menu_list_sort_cb);
2058 }
2059
2060 static void layout_menu_new_window_cb(GtkWidget *UNUSED(widget), gpointer data)
2061 {
2062         gint n;
2063
2064         n = GPOINTER_TO_INT(data);
2065         GList *menulist = NULL;
2066
2067         menulist = layout_window_menu_list(menulist);
2068         WindowNames *wn = static_cast<WindowNames *>(g_list_nth(menulist, n )->data);
2069
2070         if (wn->path)
2071                 {
2072                 load_config_from_file(wn->path, FALSE);
2073                 }
2074         else
2075                 {
2076                 log_printf(_("Error: window layout name: %s does not exist\n"), wn->path);
2077                 }
2078 }
2079
2080 static void layout_menu_new_window_update(LayoutWindow *lw)
2081 {
2082         GtkWidget *menu;
2083         GtkWidget *sub_menu;
2084         GtkWidget *item;
2085         GList *children, *iter;
2086         gint n;
2087         GList *list = NULL;
2088         gint i = 0;
2089         WindowNames *wn;
2090
2091         if (!lw->ui_manager) return;
2092
2093         list = layout_window_menu_list(list);
2094
2095         menu = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/WindowsMenu/NewWindow");
2096         sub_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu));
2097
2098         children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
2099         for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
2100                 {
2101                 if (i >= 4) // separator, default, from current, separator
2102                         {
2103                         gtk_widget_destroy(GTK_WIDGET(iter->data));
2104                         }
2105                 }
2106         g_list_free(children);
2107
2108         menu_item_add_divider(sub_menu);
2109
2110         n = 0;
2111         while (list)
2112                 {
2113                 wn = static_cast<WindowNames *>(list->data);
2114                 item = menu_item_add_simple(sub_menu, wn->name, G_CALLBACK(layout_menu_new_window_cb), GINT_TO_POINTER(n));
2115                 if (wn->displayed)
2116                         {
2117                         gtk_widget_set_sensitive(item, FALSE);
2118                         }
2119                 list = list->next;
2120                 n++;
2121                 }
2122 }
2123
2124 static void window_rename_cancel_cb(GenericDialog *UNUSED(gd), gpointer data)
2125 {
2126         RenameWindow *rw = static_cast<RenameWindow *>(data);
2127
2128         generic_dialog_close(rw->gd);
2129         g_free(rw);
2130 }
2131
2132 static void window_rename_ok(GenericDialog *UNUSED(gd), gpointer data)
2133 {
2134         RenameWindow *rw = static_cast<RenameWindow *>(data);
2135         gchar *path;
2136         gboolean window_layout_name_exists = FALSE;
2137         GList *list = NULL;
2138         gchar *xml_name;
2139         gchar *new_id;
2140
2141         new_id = g_strdup(gtk_entry_get_text(GTK_ENTRY(rw->window_name_entry)));
2142
2143         list = layout_window_menu_list(list);
2144         while (list)
2145                 {
2146                 WindowNames *ln = static_cast<WindowNames *>(list->data);
2147                 if (g_strcmp0(ln->name, new_id) == 0)
2148                         {
2149                         gchar *buf;
2150                         buf = g_strdup_printf(_("Window layout name \"%s\" already exists."), new_id);
2151                         warning_dialog(_("Rename window"), buf, GTK_STOCK_DIALOG_WARNING, rw->gd->dialog);
2152                         g_free(buf);
2153                         window_layout_name_exists = TRUE;
2154                         break;
2155                         }
2156                 list = list->next;
2157                 }
2158
2159         if (!window_layout_name_exists)
2160                 {
2161                 xml_name = g_strdup_printf("%s.xml", rw->lw->options.id);
2162                 path = g_build_filename(get_window_layouts_dir(), xml_name, NULL);
2163
2164                 if (isfile(path))
2165                         {
2166                         unlink_file(path);
2167                         }
2168                 g_free(xml_name);
2169                 g_free(path);
2170
2171                 g_free(rw->lw->options.id);
2172                 rw->lw->options.id = g_strdup(new_id);
2173                 layout_menu_new_window_update(rw->lw);
2174                 layout_refresh(rw->lw);
2175                 image_update_title(rw->lw->image);
2176                 }
2177
2178         save_layout(rw->lw);
2179
2180         g_free(new_id);
2181         generic_dialog_close(rw->gd);
2182         g_free(rw);
2183 }
2184
2185 static void window_rename_ok_cb(GenericDialog *gd, gpointer data)
2186 {
2187         RenameWindow *rw = static_cast<RenameWindow *>(data);
2188
2189         window_rename_ok(gd, rw);
2190 }
2191
2192 static void window_rename_entry_activate_cb(GenericDialog *gd, gpointer data)
2193 {
2194         RenameWindow *rw = static_cast<RenameWindow *>(data);
2195
2196         window_rename_ok(gd, rw);
2197 }
2198
2199 static void window_delete_cancel_cb(GenericDialog *UNUSED(gd), gpointer data)
2200 {
2201         DeleteWindow *dw = static_cast<DeleteWindow *>(data);
2202
2203         g_free(dw);
2204 }
2205
2206 static void window_delete_ok_cb(GenericDialog *UNUSED(gd), gpointer data)
2207 {
2208         DeleteWindow *dw = static_cast<DeleteWindow *>(data);
2209         gchar *path;
2210         gchar *xml_name;
2211
2212         xml_name = g_strdup_printf("%s.xml", dw->lw->options.id);
2213         path = g_build_filename(get_window_layouts_dir(), xml_name, NULL);
2214
2215         layout_close(dw->lw);
2216         g_free(dw);
2217
2218         if (isfile(path))
2219                 {
2220                 unlink_file(path);
2221                 }
2222         g_free(xml_name);
2223         g_free(path);
2224 }
2225
2226 static void layout_menu_window_default_cb(GtkWidget *UNUSED(widget), gpointer UNUSED(data))
2227 {
2228         layout_new_from_default();
2229 }
2230
2231 static void layout_menu_windows_menu_cb(GtkWidget *UNUSED(widget), gpointer data)
2232 {
2233         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2234         GtkWidget *menu;
2235         GtkWidget *sub_menu;
2236         gchar *menu_label;
2237         GList *children, *iter;
2238         gint i;
2239
2240         menu = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/WindowsMenu/");
2241         sub_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu));
2242
2243         /* disable Delete for temporary windows */
2244         if (g_str_has_prefix(lw->options.id, "lw"))
2245                 {
2246                 i = 0;
2247                 children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
2248                 for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
2249                         {
2250                         menu_label = g_strdup(gtk_menu_item_get_label(GTK_MENU_ITEM(iter->data)));
2251                         if (g_strcmp0(menu_label, _("Delete window")) == 0)
2252                                 {
2253                                 gtk_widget_set_sensitive(GTK_WIDGET(iter->data), FALSE);
2254                                 }
2255                         g_free(menu_label);
2256                         }
2257                 g_list_free(children);
2258                 }
2259 }
2260
2261 static void layout_menu_view_menu_cb(GtkWidget *UNUSED(widget), gpointer data)
2262 {
2263         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2264         GtkWidget *menu;
2265         GtkWidget *sub_menu;
2266         gchar *menu_label;
2267         GList *children, *iter;
2268         gint i;
2269         FileData *fd;
2270
2271         menu = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu/ViewMenu/");
2272         sub_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu));
2273
2274         fd = layout_image_get_fd(lw);
2275
2276         i = 0;
2277         children = gtk_container_get_children(GTK_CONTAINER(sub_menu));
2278         for (iter = children; iter != NULL; iter = g_list_next(iter), i++)
2279                 {
2280                 menu_label = g_strdup(gtk_menu_item_get_label(GTK_MENU_ITEM(iter->data)));
2281                 if (g_strcmp0(menu_label, _("Open archive")) == 0)
2282                         {
2283                         if (fd && fd->format_class == FORMAT_CLASS_ARCHIVE)
2284                                 {
2285                                 gtk_widget_set_sensitive(GTK_WIDGET(iter->data), TRUE);
2286                                 }
2287                         else
2288                                 {
2289                                 gtk_widget_set_sensitive(GTK_WIDGET(iter->data), FALSE);
2290                                 }
2291                         }
2292                 g_free(menu_label);
2293                 }
2294         g_list_free(children);
2295 }
2296
2297 static void change_window_id(const gchar *infile, const gchar *outfile)
2298 {
2299         GFile *in_file;
2300         GFile *out_file;
2301         GFileInputStream *in_file_stream;
2302         GFileOutputStream *out_file_stream;
2303         GDataInputStream *in_data_stream;
2304         GDataOutputStream *out_data_stream;
2305         gchar *line;
2306         gchar *id_name;
2307
2308         id_name = layout_get_unique_id();
2309
2310         in_file = g_file_new_for_path(infile);
2311         in_file_stream = g_file_read(in_file, NULL, NULL);
2312         in_data_stream = g_data_input_stream_new(G_INPUT_STREAM(in_file_stream));
2313
2314         out_file = g_file_new_for_path(outfile);
2315         out_file_stream = g_file_append_to(out_file, G_FILE_CREATE_PRIVATE, NULL, NULL);
2316         out_data_stream = g_data_output_stream_new(G_OUTPUT_STREAM(out_file_stream));
2317
2318         while ((line = g_data_input_stream_read_line(in_data_stream, NULL, NULL, NULL)))
2319                 {
2320                 if (g_str_has_suffix(line, "<layout"))
2321                         {
2322                         g_data_output_stream_put_string(out_data_stream, line, NULL, NULL);
2323                         g_data_output_stream_put_string(out_data_stream, "\n", NULL, NULL);
2324                         g_free(line);
2325
2326                         line = g_data_input_stream_read_line(in_data_stream, NULL, NULL, NULL);
2327                         g_data_output_stream_put_string(out_data_stream, "id = \"", NULL, NULL);
2328                         g_data_output_stream_put_string(out_data_stream, id_name, NULL, NULL);
2329                         g_data_output_stream_put_string(out_data_stream, "\"\n", NULL, NULL);
2330                         }
2331                 else
2332                         {
2333                         g_data_output_stream_put_string(out_data_stream, line, NULL, NULL);
2334                         g_data_output_stream_put_string(out_data_stream, "\n", NULL, NULL);
2335                         }
2336                 g_free(line);
2337                 }
2338
2339         g_free(id_name);
2340         g_object_unref(out_data_stream);
2341         g_object_unref(in_data_stream);
2342         g_object_unref(out_file_stream);
2343         g_object_unref(in_file_stream);
2344         g_object_unref(out_file);
2345         g_object_unref(in_file);
2346 }
2347
2348 static void layout_menu_window_from_current_cb(GtkWidget *UNUSED(widget), gpointer data)
2349 {
2350         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2351         gint fd_in = -1;
2352         gint fd_out = -1;
2353         char * tmp_file_in;
2354         char * tmp_file_out;
2355         GError *error = NULL;
2356
2357         fd_in = g_file_open_tmp("geeqie_layout_name_XXXXXX.xml", &tmp_file_in, &error);
2358         if (error)
2359                 {
2360                 log_printf("Error: Window layout - cannot create file:%s\n",error->message);
2361                 g_error_free(error);
2362                 return;
2363                 }
2364         close(fd_in);
2365         fd_out = g_file_open_tmp("geeqie_layout_name_XXXXXX.xml", &tmp_file_out, &error);
2366         if (error)
2367                 {
2368                 log_printf("Error: Window layout - cannot create file:%s\n",error->message);
2369                 g_error_free(error);
2370                 return;
2371                 }
2372         close(fd_out);
2373
2374         save_config_to_file(tmp_file_in, options, lw);
2375         change_window_id(tmp_file_in, tmp_file_out);
2376         load_config_from_file(tmp_file_out, FALSE);
2377
2378         unlink_file(tmp_file_in);
2379         unlink_file(tmp_file_out);
2380         g_free(tmp_file_in);
2381         g_free(tmp_file_out);
2382 }
2383
2384 static void layout_menu_window_cb(GtkWidget *UNUSED(widget), gpointer data)
2385 {
2386         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2387
2388         layout_menu_new_window_update(lw);
2389 }
2390
2391 static void layout_menu_window_rename_cb(GtkWidget *UNUSED(widget), gpointer data)
2392 {
2393         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2394         RenameWindow *rw;
2395         GtkWidget *hbox;
2396
2397         rw = g_new0(RenameWindow, 1);
2398         rw->lw = lw;
2399
2400         rw->gd = generic_dialog_new(_("Rename window"), "rename_window", NULL, FALSE, window_rename_cancel_cb, rw);
2401         rw->button_ok = generic_dialog_add_button(rw->gd, GTK_STOCK_OK, _("OK"), window_rename_ok_cb, TRUE);
2402
2403         generic_dialog_add_message(rw->gd, NULL, _("rename window"), NULL, FALSE);
2404
2405         hbox = pref_box_new(rw->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
2406         pref_spacer(hbox, PREF_PAD_INDENT);
2407
2408         hbox = pref_box_new(rw->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2409
2410         rw->window_name_entry = gtk_entry_new();
2411         gtk_widget_set_can_focus(rw->window_name_entry, TRUE);
2412         gtk_editable_set_editable(GTK_EDITABLE(rw->window_name_entry), TRUE);
2413         gtk_entry_set_text(GTK_ENTRY(rw->window_name_entry), lw->options.id);
2414         gtk_box_pack_start(GTK_BOX(hbox), rw->window_name_entry, TRUE, TRUE, 0);
2415         gtk_widget_grab_focus(GTK_WIDGET(rw->window_name_entry));
2416         gtk_widget_show(rw->window_name_entry);
2417         g_signal_connect(rw->window_name_entry, "activate", G_CALLBACK(window_rename_entry_activate_cb), rw);
2418
2419         gtk_widget_show(rw->gd->dialog);
2420 }
2421
2422 static void layout_menu_window_delete_cb(GtkWidget *UNUSED(widget), gpointer data)
2423 {
2424         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
2425         DeleteWindow *dw;
2426         GtkWidget *hbox;
2427
2428         dw = g_new0(DeleteWindow, 1);
2429         dw->lw = lw;
2430
2431         dw->gd = generic_dialog_new(_("Delete window"), "delete_window", NULL, TRUE, window_delete_cancel_cb, dw);
2432         dw->button_ok = generic_dialog_add_button(dw->gd, GTK_STOCK_OK, _("OK"), window_delete_ok_cb, TRUE);
2433
2434         generic_dialog_add_message(dw->gd, NULL, _("Delete window layout"), NULL, FALSE);
2435
2436         hbox = pref_box_new(dw->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
2437         pref_spacer(hbox, PREF_PAD_INDENT);
2438         dw->group = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2439
2440         hbox = pref_box_new(dw->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2441         pref_label_new(hbox, (lw->options.id));
2442
2443         gtk_widget_show(dw->gd->dialog);
2444 }
2445
2446 /*
2447  *-----------------------------------------------------------------------------
2448  * menu
2449  *-----------------------------------------------------------------------------
2450  */
2451
2452 #define CB G_CALLBACK
2453 /**
2454  * tooltip is used as the description field in the Help manual shortcuts documentation
2455  *
2456  * struct GtkActionEntry:
2457  *  name, stock_id, label, accelerator, tooltip, callback
2458  */
2459 static GtkActionEntry menu_entries[] = {
2460   { "FileMenu",         NULL,                   N_("_File"),                            NULL,                   NULL,                                   NULL },
2461   { "GoMenu",           NULL,                   N_("_Go"),                              NULL,                   NULL,                                   NULL },
2462   { "EditMenu",         NULL,                   N_("_Edit"),                            NULL,                   NULL,                                   NULL },
2463   { "SelectMenu",       NULL,                   N_("_Select"),                          NULL,                   NULL,                                   NULL },
2464   { "OrientationMenu",  NULL,                   N_("_Orientation"),                     NULL,                   NULL,                                   NULL },
2465   { "RatingMenu",       NULL,                   N_("_Rating"),                                  NULL,                   NULL,                                   NULL },
2466   { "PreferencesMenu",  NULL,                   N_("P_references"),                     NULL,                   NULL,                                   NULL },
2467   { "ViewMenu",         NULL,                   N_("_View"),                            NULL,                   NULL,                                   CB(layout_menu_view_menu_cb)  },
2468   { "FileDirMenu",      NULL,                   N_("_Files and Folders"),               NULL,                   NULL,                                   NULL },
2469   { "ZoomMenu",         NULL,                   N_("_Zoom"),                            NULL,                   NULL,                                   NULL },
2470   { "ColorMenu",        NULL,                   N_("_Color Management"),                NULL,                   NULL,                                   NULL },
2471   { "ConnectZoomMenu",  NULL,                   N_("_Connected Zoom"),                  NULL,                   NULL,                                   NULL },
2472   { "SplitMenu",        NULL,                   N_("Spli_t"),                           NULL,                   NULL,                                   NULL },
2473   { "StereoMenu",       NULL,                   N_("Stere_o"),                          NULL,                   NULL,                                   NULL },
2474   { "OverlayMenu",      NULL,                   N_("Image _Overlay"),                   NULL,                   NULL,                                   NULL },
2475   { "PluginsMenu",      NULL,                   N_("_Plugins"),                         NULL,                   NULL,                                   NULL },
2476   { "WindowsMenu",              NULL,           N_("_Windows"),                         NULL,                   NULL,                                   CB(layout_menu_windows_menu_cb)  },
2477   { "HelpMenu",         NULL,                   N_("_Help"),                            NULL,                   NULL,                                   NULL },
2478
2479   { "Copy",             GTK_STOCK_COPY,         N_("_Copy..."),                         "<control>C",           N_("Copy..."),                          CB(layout_menu_copy_cb) },
2480   { "Move",     PIXBUF_INLINE_ICON_MOVE,                        N_("_Move..."),                         "<control>M",           N_("Move..."),                          CB(layout_menu_move_cb) },
2481   { "Rename",   PIXBUF_INLINE_ICON_RENAME,      N_("_Rename..."),                       "<control>R",           N_("Rename..."),                        CB(layout_menu_rename_cb) },
2482   { "Delete",   PIXBUF_INLINE_ICON_TRASH,       N_("Move to Trash..."),         "<control>D",   N_("Move to Trash..."),         CB(layout_menu_move_to_trash_cb) },
2483   { "DeleteAlt1",       PIXBUF_INLINE_ICON_TRASH,N_("Move to Trash..."),        "Delete",               N_("Move to Trash..."),         CB(layout_menu_move_to_trash_key_cb) },
2484   { "DeleteAlt2",       PIXBUF_INLINE_ICON_TRASH,N_("Move to Trash..."),        "KP_Delete",    N_("Move to Trash..."),         CB(layout_menu_move_to_trash_key_cb) },
2485   { "PermanentDelete",  GTK_STOCK_DELETE,       N_("Delete..."),                        "<shift>Delete",N_("Delete..."),                        CB(layout_menu_delete_cb) },
2486   { "SelectAll",        PIXBUF_INLINE_ICON_SELECT_ALL,                  N_("Select _all"),                      "<control>A",           N_("Select all"),                       CB(layout_menu_select_all_cb) },
2487   { "SelectNone",       PIXBUF_INLINE_ICON_SELECT_NONE,                 N_("Select _none"),                     "<control><shift>A",    N_("Select none"),                      CB(layout_menu_unselect_all_cb) },
2488   { "SelectInvert",     PIXBUF_INLINE_ICON_SELECT_INVERT,                       N_("_Invert Selection"),                "<control><shift>I",    N_("Invert Selection"),                 CB(layout_menu_invert_selection_cb) },
2489   { "CloseWindow",      GTK_STOCK_CLOSE,        N_("C_lose window"),                    "<control>W",           N_("Close window"),                     CB(layout_menu_close_cb) },
2490   { "Quit",             GTK_STOCK_QUIT,         N_("_Quit"),                            "<control>Q",           N_("Quit"),                             CB(layout_menu_exit_cb) },
2491   { "FirstImage",       GTK_STOCK_GOTO_TOP,     N_("_First Image"),                     "Home",                 N_("First Image"),                      CB(layout_menu_image_first_cb) },
2492   { "PrevImage",        GTK_STOCK_GO_UP,        N_("_Previous Image"),                  "BackSpace",            N_("Previous Image"),                   CB(layout_menu_image_prev_cb) },
2493   { "PrevImageAlt1",    GTK_STOCK_GO_UP,        N_("_Previous Image"),                  "Page_Up",              N_("Previous Image"),                   CB(layout_menu_image_prev_cb) },
2494   { "PrevImageAlt2",    GTK_STOCK_GO_UP,        N_("_Previous Image"),                  "KP_Page_Up",           N_("Previous Image"),                   CB(layout_menu_image_prev_cb) },
2495   { "NextImage",        GTK_STOCK_GO_DOWN,      N_("_Next Image"),                      "space",                N_("Next Image"),                       CB(layout_menu_image_next_cb) },
2496   { "NextImageAlt1",    GTK_STOCK_GO_DOWN,      N_("_Next Image"),                      "Page_Down",            N_("Next Image"),                       CB(layout_menu_image_next_cb) },
2497
2498   { "ImageForward",     GTK_STOCK_GOTO_LAST,    N_("Image Forward"),    NULL,   N_("Forward in image history"), CB(layout_menu_image_forward_cb) },
2499   { "ImageBack",        GTK_STOCK_GOTO_FIRST,   N_("Image Back"),               NULL,   N_("Back in image history"),            CB(layout_menu_image_back_cb) },
2500
2501   { "FirstPage",GTK_STOCK_MEDIA_PREVIOUS,       N_("_First Page"),              NULL,   N_( "First Page of multi-page image"),  CB(layout_menu_page_first_cb) },
2502   { "LastPage", GTK_STOCK_MEDIA_NEXT,           N_("_Last Page"),               NULL,   N_("Last Page of multi-page image"),    CB(layout_menu_page_last_cb) },
2503   { "NextPage", GTK_STOCK_MEDIA_FORWARD,        N_("_Next Page"),               NULL,   N_("Next Page of multi-page image"),    CB(layout_menu_page_next_cb) },
2504   { "PrevPage", GTK_STOCK_MEDIA_REWIND,         N_("_Previous Page"),   NULL,   N_("Previous Page of multi-page image"),        CB(layout_menu_page_previous_cb) },
2505
2506
2507   { "NextImageAlt2",    GTK_STOCK_GO_DOWN,      N_("_Next Image"),                      "KP_Page_Down",         N_("Next Image"),               CB(layout_menu_image_next_cb) },
2508   { "LastImage",        GTK_STOCK_GOTO_BOTTOM,  N_("_Last Image"),                      "End",                  N_("Last Image"),                       CB(layout_menu_image_last_cb) },
2509   { "Back",             GTK_STOCK_GO_BACK,      N_("_Back"),                    NULL,   N_("Back in folder history"),           CB(layout_menu_back_cb) },
2510   { "Forward",  GTK_STOCK_GO_FORWARD,   N_("_Forward"),         NULL,   N_("Forward in folder history"),        CB(layout_menu_forward_cb) },
2511   { "Home",             GTK_STOCK_HOME,         N_("_Home"),                    NULL,   N_("Home"),                             CB(layout_menu_home_cb) },
2512   { "Up",               GTK_STOCK_GO_UP,        N_("_Up"),                              NULL,   N_("Up one folder"),                            CB(layout_menu_up_cb) },
2513   { "NewWindow",        NULL,           N_("New window"),                       NULL,           N_("New window"),       CB(layout_menu_window_cb) },
2514   { "NewWindowDefault", NULL,   N_("default"),                  "<control>N",           N_("New window (default)"),     CB(layout_menu_window_default_cb)  },
2515   { "NewWindowFromCurrent",     NULL,   N_("from current"),                     NULL,           N_("from current"),     CB(layout_menu_window_from_current_cb)  },
2516   { "RenameWindow",     GTK_STOCK_EDIT,         N_("Rename window"),    NULL,   N_("Rename window"),    CB(layout_menu_window_rename_cb) },
2517   { "DeleteWindow",     GTK_STOCK_DELETE,               N_("Delete window"),    NULL,   N_("Delete window"),    CB(layout_menu_window_delete_cb) },
2518   { "NewCollection",    GTK_STOCK_INDEX,        N_("_New collection"),                  "C",                    N_("New collection"),                   CB(layout_menu_new_cb) },
2519   { "OpenCollection",   GTK_STOCK_OPEN,         N_("_Open collection..."),              "O",                    N_("Open collection..."),               CB(layout_menu_open_cb) },
2520   { "OpenRecent",       NULL,                   N_("Open recen_t"),                     NULL,                   N_("Open recent collection"),                   NULL },
2521   { "Search",           GTK_STOCK_FIND,         N_("_Search..."),                       "F3",                   N_("Search..."),                        CB(layout_menu_search_cb) },
2522   { "FindDupes",        GTK_STOCK_FIND,         N_("_Find duplicates..."),              "D",                    N_("Find duplicates..."),               CB(layout_menu_dupes_cb) },
2523   { "PanView",  PIXBUF_INLINE_ICON_PANORAMA,    N_("Pa_n view"),                        "<control>J",           N_("Pan view"),                         CB(layout_menu_pan_cb) },
2524   { "Print",            GTK_STOCK_PRINT,        N_("_Print..."),                        "<shift>P",             N_("Print..."),                         CB(layout_menu_print_cb) },
2525   { "NewFolder",        GTK_STOCK_DIRECTORY,    N_("N_ew folder..."),                   "<control>F",           N_("New folder..."),                    CB(layout_menu_dir_cb) },
2526   { "EnableGrouping",   NULL,                   N_("Enable file _grouping"),            NULL,                   N_("Enable file grouping"),             CB(layout_menu_enable_grouping_cb) },
2527   { "DisableGrouping",  NULL,                   N_("Disable file groupi_ng"),           NULL,                   N_("Disable file grouping"),            CB(layout_menu_disable_grouping_cb) },
2528   { "CopyPath",         NULL,                   N_("_Copy path to clipboard"),          NULL,                   N_("Copy path to clipboard"),           CB(layout_menu_copy_path_cb) },
2529   { "CopyPathUnquoted",         NULL,                   N_("_Copy path unquoted to clipboard"),         NULL,                   N_("Copy path unquoted to clipboard"),          CB(layout_menu_copy_path_unquoted_cb) },
2530   { "Rating0",          NULL,                   N_("_Rating 0"),        "<alt>KP_0",    N_("Rating 0"),                 CB(layout_menu_rating_0_cb) },
2531   { "Rating1",          NULL,                   N_("_Rating 1"),        "<alt>KP_1",    N_("Rating 1"),                 CB(layout_menu_rating_1_cb) },
2532   { "Rating2",          NULL,                   N_("_Rating 2"),        "<alt>KP_2",    N_("Rating 2"),                 CB(layout_menu_rating_2_cb) },
2533   { "Rating3",          NULL,                   N_("_Rating 3"),        "<alt>KP_3",    N_("Rating 3"),                 CB(layout_menu_rating_3_cb) },
2534   { "Rating4",          NULL,                   N_("_Rating 4"),        "<alt>KP_4",    N_("Rating 4"),                 CB(layout_menu_rating_4_cb) },
2535   { "Rating5",          NULL,                   N_("_Rating 5"),        "<alt>KP_5",    N_("Rating 5"),                 CB(layout_menu_rating_5_cb) },
2536   { "RatingM1",         NULL,                   N_("_Rating -1"),       "<alt>KP_Subtract",     N_("Rating -1"),        CB(layout_menu_rating_m1_cb) },
2537   { "RotateCW",         PIXBUF_INLINE_ICON_CW,                  N_("_Rotate clockwise 90°"),           "bracketright",         N_("Image Rotate clockwise 90°"),                      CB(layout_menu_alter_90_cb) },
2538   { "RotateCCW",        PIXBUF_INLINE_ICON_CCW, N_("Rotate _counterclockwise 90°"),            "bracketleft",          N_("Rotate counterclockwise 90°"),             CB(layout_menu_alter_90cc_cb) },
2539   { "Rotate180",        PIXBUF_INLINE_ICON_180, N_("Rotate 1_80°"),    "<shift>R",             N_("Image Rotate 180°"),                       CB(layout_menu_alter_180_cb) },
2540   { "Mirror",           PIXBUF_INLINE_ICON_MIRROR,      N_("_Mirror"),  "<shift>M",             N_("Image Mirror"),                             CB(layout_menu_alter_mirror_cb) },
2541   { "Flip",             PIXBUF_INLINE_ICON_FLIP,        N_("_Flip"),    "<shift>F",             N_("Image Flip"),                               CB(layout_menu_alter_flip_cb) },
2542   { "AlterNone",        PIXBUF_INLINE_ICON_ORIGINAL,    N_("_Original state"),  "<shift>O",             N_("Image rotate Original state"),                      CB(layout_menu_alter_none_cb) },
2543   { "Preferences",      GTK_STOCK_PREFERENCES,  N_("P_references..."),                  "<control>O",           N_("Preferences..."),                   CB(layout_menu_config_cb) },
2544   { "Plugins",          GTK_STOCK_PREFERENCES,  N_("Configure _Plugins..."),            NULL,                   N_("Configure Plugins..."),             CB(layout_menu_editors_cb) },
2545   { "LayoutConfig",     GTK_STOCK_PREFERENCES,  N_("_Configure this window..."),        NULL,                   N_("Configure this window..."),         CB(layout_menu_layout_config_cb) },
2546   { "Maintenance",      PIXBUF_INLINE_ICON_MAINTENANCE, N_("_Cache maintenance..."),    NULL,                   N_("Cache maintenance..."),             CB(layout_menu_remove_thumb_cb) },
2547   { "Wallpaper",        NULL,                   N_("Set as _wallpaper"),                NULL,                   N_("Set as wallpaper"),                 CB(layout_menu_wallpaper_cb) },
2548   { "SaveMetadata",     GTK_STOCK_SAVE,         N_("_Save metadata"),                   "<control>S",           N_("Save metadata"),                    CB(layout_menu_metadata_write_cb) },
2549   { "KeywordAutocomplete",      NULL,   N_("Keyword autocomplete"),             "<alt>K",               N_("Keyword Autocomplete"),                     CB(layout_menu_keyword_autocomplete_cb) },
2550   { "ZoomInAlt1",       GTK_STOCK_ZOOM_IN,      N_("Zoom _in"),                         "KP_Add",               N_("Zoom in"),                          CB(layout_menu_zoom_in_cb) },
2551   { "ZoomIn",           GTK_STOCK_ZOOM_IN,      N_("Zoom _in"),                         "equal",                N_("Zoom in"),                          CB(layout_menu_zoom_in_cb) },
2552   { "ZoomOut",          GTK_STOCK_ZOOM_OUT,     N_("Zoom _out"),                        "minus",                N_("Zoom out"),                         CB(layout_menu_zoom_out_cb) },
2553   { "ZoomOutAlt1",      GTK_STOCK_ZOOM_OUT,     N_("Zoom _out"),                        "KP_Subtract",          N_("Zoom out"),                         CB(layout_menu_zoom_out_cb) },
2554   { "Zoom100",          GTK_STOCK_ZOOM_100,     N_("Zoom _1:1"),                        "Z",                    N_("Zoom 1:1"),                         CB(layout_menu_zoom_1_1_cb) },
2555   { "Zoom100Alt1",      GTK_STOCK_ZOOM_100,     N_("Zoom _1:1"),                        "KP_Divide",            N_("Zoom 1:1"),                         CB(layout_menu_zoom_1_1_cb) },
2556   { "ZoomFitAlt1",      GTK_STOCK_ZOOM_FIT,     N_("_Zoom to fit"),                     "KP_Multiply",          N_("Zoom to fit"),                      CB(layout_menu_zoom_fit_cb) },
2557   { "ZoomFit",          GTK_STOCK_ZOOM_FIT,     N_("_Zoom to fit"),                     "X",                    N_("Zoom to fit"),                      CB(layout_menu_zoom_fit_cb) },
2558   { "ZoomFillHor",      PIXBUF_INLINE_ICON_ZOOMFILLHOR, N_("Fit _Horizontally"),                "H",                    N_("Fit Horizontally"),                 CB(layout_menu_zoom_fit_hor_cb) },
2559   { "ZoomFillVert",     PIXBUF_INLINE_ICON_ZOOMFILLVERT,        N_("Fit _Vertically"),                  "W",                    N_("Fit Vertically"),                   CB(layout_menu_zoom_fit_vert_cb) },
2560   { "Zoom200",          GTK_STOCK_FILE,                 N_("Zoom _2:1"),                        NULL,                   N_("Zoom 2:1"),                         CB(layout_menu_zoom_2_1_cb) },
2561   { "Zoom300",          GTK_STOCK_FILE,                 N_("Zoom _3:1"),                        NULL,                   N_("Zoom 3:1"),                         CB(layout_menu_zoom_3_1_cb) },
2562   { "Zoom400",          GTK_STOCK_FILE,                 N_("Zoom _4:1"),                        NULL,                   N_("Zoom 4:1"),                         CB(layout_menu_zoom_4_1_cb) },
2563   { "Zoom50",           GTK_STOCK_FILE,                 N_("Zoom 1:2"),                         NULL,                   N_("Zoom 1:2"),                         CB(layout_menu_zoom_1_2_cb) },
2564   { "Zoom33",           GTK_STOCK_FILE,                 N_("Zoom 1:3"),                         NULL,                   N_("Zoom 1:3"),                         CB(layout_menu_zoom_1_3_cb) },
2565   { "Zoom25",           GTK_STOCK_FILE,                 N_("Zoom 1:4"),                         NULL,                   N_("Zoom 1:4"),                         CB(layout_menu_zoom_1_4_cb) },
2566   { "ConnectZoomIn",    GTK_STOCK_ZOOM_IN,      N_("Zoom _in"),                         "plus",                 N_("Connected Zoom in"),                CB(layout_menu_connect_zoom_in_cb) },
2567   { "ConnectZoomInAlt1",GTK_STOCK_ZOOM_IN,      N_("Zoom _in"),                         "<shift>KP_Add",        N_("Connected Zoom in"),                CB(layout_menu_connect_zoom_in_cb) },
2568   { "ConnectZoomOut",   GTK_STOCK_ZOOM_OUT,     N_("Zoom _out"),                        "underscore",           N_("Connected Zoom out"),               CB(layout_menu_connect_zoom_out_cb) },
2569   { "ConnectZoomOutAlt1",GTK_STOCK_ZOOM_OUT,    N_("Zoom _out"),                        "<shift>KP_Subtract",   N_("Connected Zoom out"),               CB(layout_menu_connect_zoom_out_cb) },
2570   { "ConnectZoom100",   GTK_STOCK_ZOOM_100,     N_("Zoom _1:1"),                        "<shift>Z",             N_("Connected Zoom 1:1"),               CB(layout_menu_connect_zoom_1_1_cb) },
2571   { "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) },
2572   { "ConnectZoomFit",   GTK_STOCK_ZOOM_FIT,     N_("_Zoom to fit"),                     "<shift>X",             N_("Connected Zoom to fit"),            CB(layout_menu_connect_zoom_fit_cb) },
2573   { "ConnectZoomFitAlt1",GTK_STOCK_ZOOM_FIT,    N_("_Zoom to fit"),                     "<shift>KP_Multiply",   N_("Connected Zoom to fit"),            CB(layout_menu_connect_zoom_fit_cb) },
2574   { "ConnectZoomFillHor",NULL,                  N_("Fit _Horizontally"),                "<shift>H",             N_("Connected Fit Horizontally"),       CB(layout_menu_connect_zoom_fit_hor_cb) },
2575   { "ConnectZoomFillVert",NULL,                 N_("Fit _Vertically"),                  "<shift>W",             N_("Connected Fit Vertically"),         CB(layout_menu_connect_zoom_fit_vert_cb) },
2576   { "ConnectZoom200",   NULL,                   N_("Zoom _2:1"),                        NULL,                   N_("Connected Zoom 2:1"),               CB(layout_menu_connect_zoom_2_1_cb) },
2577   { "ConnectZoom300",   NULL,                   N_("Zoom _3:1"),                        NULL,                   N_("Connected Zoom 3:1"),               CB(layout_menu_connect_zoom_3_1_cb) },
2578   { "ConnectZoom400",   NULL,                   N_("Zoom _4:1"),                        NULL,                   N_("Connected Zoom 4:1"),               CB(layout_menu_connect_zoom_4_1_cb) },
2579   { "ConnectZoom50",    NULL,                   N_("Zoom 1:2"),                         NULL,                   N_("Connected Zoom 1:2"),               CB(layout_menu_connect_zoom_1_2_cb) },
2580   { "ConnectZoom33",    NULL,                   N_("Zoom 1:3"),                         NULL,                   N_("Connected Zoom 1:3"),               CB(layout_menu_connect_zoom_1_3_cb) },
2581   { "ConnectZoom25",    NULL,                   N_("Zoom 1:4"),                         NULL,                   N_("Connected Zoom 1:4"),               CB(layout_menu_connect_zoom_1_4_cb) },
2582   { "ViewInNewWindow",  NULL,                   N_("_View in new window"),              "<control>V",           N_("View in new window"),               CB(layout_menu_view_in_new_window_cb) },
2583   { "OpenArchive",      GTK_STOCK_OPEN,                 N_("Open archive"),             NULL,           N_("Open archive"),             CB(layout_menu_open_archive_cb) },
2584   { "FullScreen",       GTK_STOCK_FULLSCREEN,   N_("F_ull screen"),                     "F",                    N_("Full screen"),                      CB(layout_menu_fullscreen_cb) },
2585   { "FullScreenAlt1",   GTK_STOCK_FULLSCREEN,   N_("F_ull screen"),                     "V",                    N_("Full screen"),                      CB(layout_menu_fullscreen_cb) },
2586   { "FullScreenAlt2",   GTK_STOCK_FULLSCREEN,   N_("F_ull screen"),                     "F11",                  N_("Full screen"),                      CB(layout_menu_fullscreen_cb) },
2587   { "Escape",           GTK_STOCK_LEAVE_FULLSCREEN,N_("_Leave full screen"),            "Escape",               N_("Leave full screen"),                CB(layout_menu_escape_cb) },
2588   { "EscapeAlt1",       GTK_STOCK_LEAVE_FULLSCREEN,N_("_Leave full screen"),            "Q",                    N_("Leave full screen"),                CB(layout_menu_escape_cb) },
2589   { "ImageOverlayCycle",NULL,                   N_("_Cycle through overlay modes"),     "I",                    N_("Cycle through Overlay modes"),      CB(layout_menu_overlay_toggle_cb) },
2590   { "HistogramChanCycle",NULL,                  N_("Cycle through histogram ch_annels"),"K",                    N_("Cycle through histogram channels"), CB(layout_menu_histogram_toggle_channel_cb) },
2591   { "HistogramModeCycle",NULL,                  N_("Cycle through histogram mo_des"),   "J",                    N_("Cycle through histogram modes"),    CB(layout_menu_histogram_toggle_mode_cb) },
2592   { "HideTools",        PIXBUF_INLINE_ICON_HIDETOOLS,   N_("_Hide file list"),                  "<control>H",           N_("Hide file list"),                   CB(layout_menu_hide_cb) },
2593   { "SlideShowPause",   GTK_STOCK_MEDIA_PAUSE,  N_("_Pause slideshow"),                 "P",                    N_("Pause slideshow"),                  CB(layout_menu_slideshow_pause_cb) },
2594   { "SlideShowFaster",  GTK_STOCK_FILE, N_("Faster"),           "<control>equal",                       N_("Slideshow Faster"),                         CB(layout_menu_slideshow_faster_cb) },
2595   { "SlideShowSlower",  GTK_STOCK_FILE, N_("Slower"),           "<control>minus",                       N_("Slideshow Slower"),                         CB(layout_menu_slideshow_slower_cb) },
2596   { "Refresh",          GTK_STOCK_REFRESH,      N_("_Refresh"),                         "R",                    N_("Refresh"),                          CB(layout_menu_refresh_cb) },
2597   { "HelpContents",     GTK_STOCK_HELP,         N_("_Help manual"),                     "F1",                   N_("Help manual"),                              CB(layout_menu_help_cb) },
2598   { "HelpSearch",       NULL,           N_("On-line help search"),                      NULL,                   N_("On-line help search"),                              CB(layout_menu_help_search_cb) },
2599   { "HelpShortcuts",    NULL,                   N_("_Keyboard shortcuts"),              NULL,                   N_("Keyboard shortcuts"),               CB(layout_menu_help_keys_cb) },
2600   { "HelpKbd",          NULL,                   N_("_Keyboard map"),                    NULL,                   N_("Keyboard map"),                     CB(layout_menu_kbd_map_cb) },
2601   { "HelpNotes",        NULL,                   N_("_Readme"),                  NULL,                   N_("Readme"),                   CB(layout_menu_notes_cb) },
2602   { "HelpChangeLog",    NULL,                   N_("_ChangeLog"),                       NULL,                   N_("ChangeLog notes"),                  CB(layout_menu_changelog_cb) },
2603   { "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) },
2604   { "About",            GTK_STOCK_ABOUT,        N_("_About"),                           NULL,                   N_("About"),                            CB(layout_menu_about_cb) },
2605   { "LogWindow",        NULL,                   N_("_Log Window"),                      NULL,                   N_("Log Window"),                       CB(layout_menu_log_window_cb) },
2606   { "ExifWin",          PIXBUF_INLINE_ICON_EXIF,        N_("_Exif window"),                     "<control>E",           N_("Exif window"),                      CB(layout_menu_bar_exif_cb) },
2607   { "StereoCycle",      NULL,                   N_("_Cycle through stereo modes"),      NULL,                   N_("Cycle through stereo modes"),       CB(layout_menu_stereo_mode_next_cb) },
2608   { "SplitNextPane",    NULL,                   N_("_Next Pane"),       "<alt>Right",                   N_("Next Split Pane"),  CB(layout_menu_split_pane_next_cb) },
2609   { "SplitPreviousPane",        NULL,                   N_("_Previous Pane"),   "<alt>Left",                    N_("Previous Split Pane"),      CB(layout_menu_split_pane_prev_cb) },
2610   { "SplitUpPane",      NULL,                   N_("_Up Pane"), "<alt>Up",                      N_("Up Split Pane"),    CB(layout_menu_split_pane_updown_cb) },
2611   { "SplitDownPane",    NULL,                   N_("_Down Pane"),       "<alt>Down",                    N_("Down Split Pane"),  CB(layout_menu_split_pane_updown_cb) },
2612   { "WriteRotation",    NULL,                   N_("_Write orientation to file"),               NULL,           N_("Write orientation to file"),                        CB(layout_menu_write_rotate_cb) },
2613   { "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) },
2614   { "ClearMarks",       NULL,           N_("Clear Marks..."),                   NULL,           N_("Clear Marks"),                      CB(layout_menu_clear_marks_cb) },
2615 };
2616
2617 static GtkToggleActionEntry menu_toggle_entries[] = {
2618   { "Thumbnails",       PIXBUF_INLINE_ICON_THUMB,N_("Show _Thumbnails"),                "T",                    N_("Show Thumbnails"),                  CB(layout_menu_thumb_cb),        FALSE },
2619   { "ShowMarks",        PIXBUF_INLINE_ICON_MARKS,       N_("Show _Marks"),                      "M",                    N_("Show Marks"),                       CB(layout_menu_marks_cb),        FALSE  },
2620   { "ShowFileFilter", PIXBUF_INLINE_ICON_FILE_FILTER,   N_("Show File Filter"), NULL,   N_("Show File Filter"), CB(layout_menu_file_filter_cb),  FALSE  },
2621   { "ShowInfoPixel",    GTK_STOCK_COLOR_PICKER, N_("Pi_xel Info"),                      NULL,                   N_("Show Pixel Info"),                  CB(layout_menu_info_pixel_cb),   FALSE  },
2622   { "IgnoreAlpha", GTK_STOCK_STRIKETHROUGH,           N_("Hide _alpha"),          "<shift>A",     N_("Hide alpha channel"),       CB(layout_menu_alter_ignore_alpha_cb), FALSE},
2623   { "FloatTools",       PIXBUF_INLINE_ICON_FLOAT,N_("_Float file list"),                "L",                    N_("Float file list"),                  CB(layout_menu_float_cb),        FALSE  },
2624   { "HideToolbar",      NULL,                   N_("Hide tool_bar"),                    NULL,                   N_("Hide toolbar"),                     CB(layout_menu_toolbar_cb),      FALSE  },
2625   { "SBar",     PIXBUF_INLINE_ICON_INFO,        N_("_Info sidebar"),                    "<control>K",           N_("Info sidebar"),                     CB(layout_menu_bar_cb),          FALSE  },
2626   { "SBarSort", PIXBUF_INLINE_ICON_SORT,        N_("Sort _manager"),                    "<shift>S",             N_("Sort manager"),                     CB(layout_menu_bar_sort_cb),     FALSE  },
2627   { "HideBars",         NULL,                   N_("Hide Bars"),                        "grave",                N_("Hide Bars"),                        CB(layout_menu_hide_bars_cb),    FALSE  },
2628   { "SlideShow",        GTK_STOCK_MEDIA_PLAY,   N_("Toggle _slideshow"),                "S",                    N_("Toggle slideshow"),                 CB(layout_menu_slideshow_cb),    FALSE  },
2629   { "UseColorProfiles", GTK_STOCK_SELECT_COLOR, N_("Use _color profiles"),              NULL,                   N_("Use color profiles"),               CB(layout_color_menu_enable_cb), FALSE},
2630   { "UseImageProfile",  NULL,                   N_("Use profile from _image"),          NULL,                   N_("Use profile from image"),           CB(layout_color_menu_use_image_cb), FALSE},
2631   { "Grayscale",        PIXBUF_INLINE_ICON_GRAYSCALE,   N_("Toggle _grayscale"),        "<shift>G",             N_("Toggle grayscale"),         CB(layout_menu_alter_desaturate_cb), FALSE},
2632   { "ImageOverlay",     NULL,                   N_("Image _Overlay"),                   NULL,                   N_("Image Overlay"),                    CB(layout_menu_overlay_cb),      FALSE },
2633   { "ImageHistogram",   NULL,                   N_("_Show Histogram"),                  NULL,                   N_("Show Histogram"),                   CB(layout_menu_histogram_cb),    FALSE },
2634   { "RectangularSelection",     PIXBUF_INLINE_ICON_SELECT_RECTANGLE,    N_("Rectangular Selection"),                    "<alt>R",                       N_("Rectangular Selection"),                    CB(layout_menu_rectangular_selection_cb),        FALSE },
2635   { "Animate",  NULL,   N_("_Animation"),               "A",                    N_("Toggle animation"),                 CB(layout_menu_animate_cb),      FALSE  },
2636   { "ExifRotate",       GTK_STOCK_ORIENTATION_PORTRAIT,                 N_("_Exif rotate"),             "<alt>X",               N_("Toggle Exif rotate"),                       CB(layout_menu_exif_rotate_cb), FALSE },
2637   { "DrawRectangle",    PIXBUF_INLINE_ICON_DRAW_RECTANGLE,                      N_("Draw Rectangle"),           NULL,           N_("Draw Rectangle"),                   CB(layout_menu_select_rectangle_cb), FALSE },
2638   { "OverUnderExposed", PIXBUF_INLINE_ICON_EXPOSURE,    N_("Over/Under Exposed"),       "<shift>E",             N_("Highlight over/under exposed"),             CB(layout_menu_select_overunderexposed_cb), FALSE },
2639   { "SplitPaneSync",    PIXBUF_INLINE_SPLIT_PANE_SYNC,                  N_("Split Pane Sync"),  NULL,           N_("Split Pane Sync"),  CB(layout_menu_split_pane_sync_cb), FALSE },
2640 };
2641
2642 static GtkRadioActionEntry menu_radio_entries[] = {
2643   { "ViewList",         NULL,                   N_("Images as _List"),                  "<control>L",           N_("View Images as List"),              FILEVIEW_LIST },
2644   { "ViewIcons",        NULL,                   N_("Images as I_cons"),                 "<control>I",           N_("View Images as Icons"),             FILEVIEW_ICON }
2645 };
2646
2647 static GtkToggleActionEntry menu_view_dir_toggle_entries[] = {
2648   { "FolderTree",       NULL,                   N_("T_oggle Folder View"),                      "<control>T",           N_("Toggle Folders View"),              CB(layout_menu_view_dir_as_cb),FALSE },
2649 };
2650
2651 static GtkRadioActionEntry menu_split_radio_entries[] = {
2652   { "SplitHorizontal",  NULL,                   N_("_Horizontal"),                      "E",                    N_("Split panes horizontal."),                  SPLIT_HOR },
2653   { "SplitVertical",    NULL,                   N_("_Vertical"),                        "U",                    N_("Split panes vertical"),                             SPLIT_VERT },
2654   { "SplitQuad",        NULL,                   N_("_Quad"),                            NULL,                   N_("Split panes quad"),                         SPLIT_QUAD },
2655   { "SplitSingle",      NULL,                   N_("_Single"),                          "Y",                    N_("Single pane"),                              SPLIT_NONE }
2656 };
2657
2658 static GtkRadioActionEntry menu_color_radio_entries[] = {
2659   { "ColorProfile0",    NULL,                   N_("Input _0: sRGB"),                   NULL,                   N_("Input 0: sRGB"),                    COLOR_PROFILE_SRGB },
2660   { "ColorProfile1",    NULL,                   N_("Input _1: AdobeRGB compatible"),    NULL,                   N_("Input 1: AdobeRGB compatible"),     COLOR_PROFILE_ADOBERGB },
2661   { "ColorProfile2",    NULL,                   N_("Input _2"),                         NULL,                   N_("Input 2"),                          COLOR_PROFILE_FILE },
2662   { "ColorProfile3",    NULL,                   N_("Input _3"),                         NULL,                   N_("Input 3"),                          COLOR_PROFILE_FILE + 1 },
2663   { "ColorProfile4",    NULL,                   N_("Input _4"),                         NULL,                   N_("Input 4"),                          COLOR_PROFILE_FILE + 2 },
2664   { "ColorProfile5",    NULL,                   N_("Input _5"),                         NULL,                   N_("Input 5"),                          COLOR_PROFILE_FILE + 3 }
2665 };
2666
2667 static GtkRadioActionEntry menu_histogram_channel[] = {
2668   { "HistogramChanR",   NULL,                   N_("Histogram on _Red"),                NULL,                   N_("Histogram on Red"),         HCHAN_R },
2669   { "HistogramChanG",   NULL,                   N_("Histogram on _Green"),              NULL,                   N_("Histogram on Green"),       HCHAN_G },
2670   { "HistogramChanB",   NULL,                   N_("Histogram on _Blue"),               NULL,                   N_("Histogram on Blue"),        HCHAN_B },
2671   { "HistogramChanRGB", NULL,                   N_("_Histogram on RGB"),                        NULL,                   N_("Histogram on RGB"),         HCHAN_RGB },
2672   { "HistogramChanV",   NULL,                   N_("Histogram on _Value"),              NULL,                   N_("Histogram on Value"),       HCHAN_MAX }
2673 };
2674
2675 static GtkRadioActionEntry menu_histogram_mode[] = {
2676   { "HistogramModeLin", NULL,                   N_("Li_near Histogram"),                NULL,                   N_("Linear Histogram"),         0 },
2677   { "HistogramModeLog", NULL,                   N_("_Log Histogram"),                   NULL,                   N_("Log Histogram"),            1 },
2678 };
2679
2680 static GtkRadioActionEntry menu_stereo_mode_entries[] = {
2681   { "StereoAuto",       NULL,                   N_("_Auto"),                            NULL,                   N_("Stereo Auto"),              STEREO_PIXBUF_DEFAULT },
2682   { "StereoSBS",        NULL,                   N_("_Side by Side"),                    NULL,                   N_("Stereo Side by Side"),      STEREO_PIXBUF_SBS },
2683   { "StereoCross",      NULL,                   N_("_Cross"),                           NULL,                   N_("Stereo Cross"),             STEREO_PIXBUF_CROSS },
2684   { "StereoOff",        NULL,                   N_("_Off"),                             NULL,                   N_("Stereo Off"),               STEREO_PIXBUF_NONE }
2685 };
2686
2687
2688 #undef CB
2689
2690 static const gchar *menu_ui_description =
2691 "<ui>"
2692 "  <menubar name='MainMenu'>"
2693 "    <menu action='FileMenu'>"
2694 "      <menuitem action='NewCollection'/>"
2695 "      <menuitem action='OpenCollection'/>"
2696 "      <menuitem action='OpenRecent'/>"
2697 "      <placeholder name='OpenSection'/>"
2698 "      <separator/>"
2699 "      <menuitem action='Search'/>"
2700 "      <menuitem action='FindDupes'/>"
2701 "      <placeholder name='SearchSection'/>"
2702 "      <separator/>"
2703 "      <menuitem action='Print'/>"
2704 "      <placeholder name='PrintSection'/>"
2705 "      <separator/>"
2706 "      <menuitem action='NewFolder'/>"
2707 "      <menuitem action='Copy'/>"
2708 "      <menuitem action='Move'/>"
2709 "      <menuitem action='Rename'/>"
2710 "      <separator/>"
2711 "      <menuitem action='Delete'/>"
2712 "      <menuitem action='PermanentDelete'/>"
2713 "      <separator/>"
2714 "      <placeholder name='FileOpsSection'/>"
2715 "      <separator/>"
2716 "      <placeholder name='QuitSection'/>"
2717 "      <menuitem action='Quit'/>"
2718 "      <separator/>"
2719 "    </menu>"
2720 "    <menu action='GoMenu'>"
2721 "      <menuitem action='FirstImage'/>"
2722 "      <menuitem action='PrevImage'/>"
2723 "      <menuitem action='NextImage'/>"
2724 "      <menuitem action='LastImage'/>"
2725 "      <menuitem action='ImageBack'/>"
2726 "      <menuitem action='ImageForward'/>"
2727 "      <separator/>"
2728 "      <menuitem action='Back'/>"
2729 "      <menuitem action='Forward'/>"
2730 "      <menuitem action='Up'/>"
2731 "      <menuitem action='Home'/>"
2732 "      <separator/>"
2733 "      <menuitem action='FirstPage'/>"
2734 "      <menuitem action='LastPage'/>"
2735 "      <menuitem action='NextPage'/>"
2736 "      <menuitem action='PrevPage'/>"
2737 "    </menu>"
2738 "    <menu action='SelectMenu'>"
2739 "      <menuitem action='SelectAll'/>"
2740 "      <menuitem action='SelectNone'/>"
2741 "      <menuitem action='SelectInvert'/>"
2742 "      <menuitem action='RectangularSelection'/>"
2743 "      <menuitem action='ShowFileFilter'/>"
2744 "      <placeholder name='SelectSection'/>"
2745 "      <separator/>"
2746 "      <menuitem action='CopyPath'/>"
2747 "      <menuitem action='CopyPathUnquoted'/>"
2748 "      <placeholder name='ClipboardSection'/>"
2749 "      <separator/>"
2750 "      <menuitem action='ShowMarks'/>"
2751 "      <menuitem action='ClearMarks'/>"
2752 "      <placeholder name='MarksSection'/>"
2753 "      <separator/>"
2754 "    </menu>"
2755 "    <menu action='EditMenu'>"
2756 "      <placeholder name='EditSection'/>"
2757 "      <separator/>"
2758 "      <menu action='OrientationMenu'>"
2759 "        <menuitem action='RotateCW'/>"
2760 "        <menuitem action='RotateCCW'/>"
2761 "        <menuitem action='Rotate180'/>"
2762 "        <menuitem action='Mirror'/>"
2763 "        <menuitem action='Flip'/>"
2764 "        <menuitem action='AlterNone'/>"
2765 "        <separator/>"
2766 "        <menuitem action='ExifRotate'/>"
2767 "        <separator/>"
2768 "        <menuitem action='WriteRotation'/>"
2769 "        <menuitem action='WriteRotationKeepDate'/>"
2770 "        <separator/>"
2771 "      </menu>"
2772 "      <menu action='RatingMenu'>"
2773 "        <menuitem action='Rating0'/>"
2774 "        <menuitem action='Rating1'/>"
2775 "        <menuitem action='Rating2'/>"
2776 "        <menuitem action='Rating3'/>"
2777 "        <menuitem action='Rating4'/>"
2778 "        <menuitem action='Rating5'/>"
2779 "        <menuitem action='RatingM1'/>"
2780 "        <separator/>"
2781 "      </menu>"
2782 "      <menuitem action='SaveMetadata'/>"
2783 "      <menuitem action='KeywordAutocomplete'/>"
2784 "      <placeholder name='PropertiesSection'/>"
2785 "      <separator/>"
2786 "      <menuitem action='DrawRectangle'/>"
2787 "      <separator/>"
2788 "      <menuitem action='Preferences'/>"
2789 "      <menuitem action='Plugins'/>"
2790 "      <menuitem action='LayoutConfig'/>"
2791 "      <menuitem action='Maintenance'/>"
2792 "      <placeholder name='PreferencesSection'/>"
2793 "      <separator/>"
2794 "      <separator/>"
2795 "    </menu>"
2796 "    <menu action='PluginsMenu'>"
2797 "    </menu>"
2798 "    <menu action='ViewMenu'>"
2799 "      <menuitem action='ViewInNewWindow'/>"
2800 "      <menuitem action='PanView'/>"
2801 "      <menuitem action='ExifWin'/>"
2802 "      <menuitem action='OpenArchive'/>"
2803 "      <placeholder name='WindowSection'/>"
2804 "      <separator/>"
2805 "      <menu action='FileDirMenu'>"
2806 "        <menuitem action='FolderTree'/>"
2807 "        <placeholder name='FolderSection'/>"
2808 "        <separator/>"
2809 "        <menuitem action='ViewList'/>"
2810 "        <menuitem action='ViewIcons'/>"
2811 "        <menuitem action='Thumbnails'/>"
2812 "        <placeholder name='ListSection'/>"
2813 "        <separator/>"
2814 "        <menuitem action='FloatTools'/>"
2815 "        <menuitem action='HideTools'/>"
2816 "        <menuitem action='HideToolbar'/>"
2817 "      </menu>"
2818 "      <placeholder name='DirSection'/>"
2819 "      <separator/>"
2820 "      <menu action='ZoomMenu'>"
2821 "        <menu action='ConnectZoomMenu'>"
2822 "          <menuitem action='ConnectZoomIn'/>"
2823 "          <menuitem action='ConnectZoomOut'/>"
2824 "          <menuitem action='ConnectZoomFit'/>"
2825 "          <menuitem action='ConnectZoomFillHor'/>"
2826 "          <menuitem action='ConnectZoomFillVert'/>"
2827 "          <menuitem action='ConnectZoom100'/>"
2828 "          <menuitem action='ConnectZoom200'/>"
2829 "          <menuitem action='ConnectZoom300'/>"
2830 "          <menuitem action='ConnectZoom400'/>"
2831 "          <menuitem action='ConnectZoom50'/>"
2832 "          <menuitem action='ConnectZoom33'/>"
2833 "          <menuitem action='ConnectZoom25'/>"
2834 "        </menu>"
2835 "        <menuitem action='ZoomIn'/>"
2836 "        <menuitem action='ZoomOut'/>"
2837 "        <menuitem action='ZoomFit'/>"
2838 "        <menuitem action='ZoomFillHor'/>"
2839 "        <menuitem action='ZoomFillVert'/>"
2840 "        <menuitem action='Zoom100'/>"
2841 "        <menuitem action='Zoom200'/>"
2842 "        <menuitem action='Zoom300'/>"
2843 "        <menuitem action='Zoom400'/>"
2844 "        <menuitem action='Zoom50'/>"
2845 "        <menuitem action='Zoom33'/>"
2846 "        <menuitem action='Zoom25'/>"
2847 "      </menu>"
2848 "      <menu action='SplitMenu'>"
2849 "        <menuitem action='SplitHorizontal'/>"
2850 "        <menuitem action='SplitVertical'/>"
2851 "        <menuitem action='SplitQuad'/>"
2852 "        <menuitem action='SplitSingle'/>"
2853 "        <separator/>"
2854 "        <menuitem action='SplitNextPane'/>"
2855 "        <menuitem action='SplitPreviousPane'/>"
2856 "        <menuitem action='SplitUpPane'/>"
2857 "        <menuitem action='SplitDownPane'/>"
2858 "        <separator/>"
2859 "        <menuitem action='SplitPaneSync'/>"
2860 "      </menu>"
2861 "      <menu action='StereoMenu'>"
2862 "        <menuitem action='StereoAuto'/>"
2863 "        <menuitem action='StereoSBS'/>"
2864 "        <menuitem action='StereoCross'/>"
2865 "        <menuitem action='StereoOff'/>"
2866 "        <separator/>"
2867 "        <menuitem action='StereoCycle'/>"
2868 "      </menu>"
2869 "      <menu action='ColorMenu'>"
2870 "        <menuitem action='UseColorProfiles'/>"
2871 "        <menuitem action='UseImageProfile'/>"
2872 "        <menuitem action='ColorProfile0'/>"
2873 "        <menuitem action='ColorProfile1'/>"
2874 "        <menuitem action='ColorProfile2'/>"
2875 "        <menuitem action='ColorProfile3'/>"
2876 "        <menuitem action='ColorProfile4'/>"
2877 "        <menuitem action='ColorProfile5'/>"
2878 "        <separator/>"
2879 "        <menuitem action='Grayscale'/>"
2880 "      </menu>"
2881 "      <menu action='OverlayMenu'>"
2882 "        <menuitem action='ImageOverlay'/>"
2883 "        <menuitem action='ImageHistogram'/>"
2884 "        <menuitem action='ImageOverlayCycle'/>"
2885 "        <separator/>"
2886 "        <menuitem action='HistogramChanR'/>"
2887 "        <menuitem action='HistogramChanG'/>"
2888 "        <menuitem action='HistogramChanB'/>"
2889 "        <menuitem action='HistogramChanRGB'/>"
2890 "        <menuitem action='HistogramChanV'/>"
2891 "        <menuitem action='HistogramChanCycle'/>"
2892 "        <separator/>"
2893 "        <menuitem action='HistogramModeLin'/>"
2894 "        <menuitem action='HistogramModeLog'/>"
2895 "        <menuitem action='HistogramModeCycle'/>"
2896 "      </menu>"
2897 "      <menuitem action='OverUnderExposed'/>"
2898 "      <menuitem action='FullScreen'/>"
2899 "      <placeholder name='ViewSection'/>"
2900 "      <separator/>"
2901 "      <menuitem action='SBar'/>"
2902 "      <menuitem action='SBarSort'/>"
2903 "      <menuitem action='HideBars'/>"
2904 "      <menuitem action='ShowInfoPixel'/>"
2905 "      <menuitem action='IgnoreAlpha'/>"
2906 "      <placeholder name='ToolsSection'/>"
2907 "      <separator/>"
2908 "      <menuitem action='Animate'/>"
2909 "      <menuitem action='SlideShow'/>"
2910 "      <menuitem action='SlideShowPause'/>"
2911 "      <menuitem action='SlideShowFaster'/>"
2912 "      <menuitem action='SlideShowSlower'/>"
2913 "      <separator/>"
2914 "      <menuitem action='Refresh'/>"
2915 "      <placeholder name='SlideShowSection'/>"
2916 "      <separator/>"
2917 "    </menu>"
2918 "    <menu action='WindowsMenu'>"
2919 "      <menu action='NewWindow'>"
2920 "        <menuitem action='NewWindowDefault'/>"
2921 "        <menuitem action='NewWindowFromCurrent'/>"
2922 "        <separator/>"
2923 "       </menu>"
2924 "      <menuitem action='RenameWindow'/>"
2925 "      <menuitem action='DeleteWindow'/>"
2926 "      <menuitem action='CloseWindow'/>"
2927 "    </menu>"
2928 "    <menu action='HelpMenu'>"
2929 "      <separator/>"
2930 "      <menuitem action='HelpContents'/>"
2931 "      <menuitem action='SearchAndRunCommand'/>"
2932 "      <menuitem action='HelpSearch'/>"
2933 "      <menuitem action='HelpShortcuts'/>"
2934 "      <menuitem action='HelpKbd'/>"
2935 "      <menuitem action='HelpNotes'/>"
2936 "      <menuitem action='HelpChangeLog'/>"
2937 "      <placeholder name='HelpSection'/>"
2938 "      <separator/>"
2939 "      <menuitem action='About'/>"
2940 "      <separator/>"
2941 "      <menuitem action='LogWindow'/>"
2942 "      <separator/>"
2943 "    </menu>"
2944 "  </menubar>"
2945 "  <toolbar name='ToolBar'>"
2946 "  </toolbar>"
2947 "  <toolbar name='StatusBar'>"
2948 "  </toolbar>"
2949 "<accelerator action='PrevImageAlt1'/>"
2950 "<accelerator action='PrevImageAlt2'/>"
2951 "<accelerator action='NextImageAlt1'/>"
2952 "<accelerator action='NextImageAlt2'/>"
2953 "<accelerator action='DeleteAlt1'/>"
2954 "<accelerator action='DeleteAlt2'/>"
2955 "<accelerator action='FullScreenAlt1'/>"
2956 "<accelerator action='FullScreenAlt2'/>"
2957 "<accelerator action='Escape'/>"
2958 "<accelerator action='EscapeAlt1'/>"
2959
2960 "<accelerator action='ZoomInAlt1'/>"
2961 "<accelerator action='ZoomOutAlt1'/>"
2962 "<accelerator action='Zoom100Alt1'/>"
2963 "<accelerator action='ZoomFitAlt1'/>"
2964
2965 "<accelerator action='ConnectZoomInAlt1'/>"
2966 "<accelerator action='ConnectZoomOutAlt1'/>"
2967 "<accelerator action='ConnectZoom100Alt1'/>"
2968 "<accelerator action='ConnectZoomFitAlt1'/>"
2969 "</ui>";
2970
2971 static gchar *menu_translate(const gchar *path, gpointer UNUSED(data))
2972 {
2973         return (gchar *)(_(path));
2974 }
2975
2976 static void layout_actions_setup_mark(LayoutWindow *lw, gint mark, const gchar *name_tmpl,
2977                                       const gchar *label_tmpl, const gchar *accel_tmpl, const gchar *tooltip_tmpl, GCallback cb)
2978 {
2979         gchar name[50];
2980         gchar label[100];
2981         gchar accel[50];
2982         gchar tooltip[100];
2983         GtkActionEntry entry = { name, NULL, label, accel, tooltip, cb };
2984         GtkAction *action;
2985
2986         g_snprintf(name, sizeof(name), name_tmpl, mark);
2987         g_snprintf(label, sizeof(label), label_tmpl, mark);
2988
2989         if (accel_tmpl)
2990                 g_snprintf(accel, sizeof(accel), accel_tmpl, mark % 10);
2991         else
2992                 entry.accelerator = NULL;
2993
2994         if (tooltip_tmpl)
2995                 g_snprintf(tooltip, sizeof(tooltip), tooltip_tmpl, mark);
2996         else
2997                 entry.tooltip = NULL;
2998
2999         gtk_action_group_add_actions(lw->action_group, &entry, 1, lw);
3000         action = gtk_action_group_get_action(lw->action_group, name);
3001         g_object_set_data(G_OBJECT(action), "mark_num", GINT_TO_POINTER(mark > 0 ? mark : 10));
3002 }
3003
3004 static void layout_actions_setup_marks(LayoutWindow *lw)
3005 {
3006         gint mark;
3007         GError *error;
3008         GString *desc = g_string_new(
3009                                 "<ui>"
3010                                 "  <menubar name='MainMenu'>"
3011                                 "    <menu action='SelectMenu'>");
3012
3013         for (mark = 1; mark <= FILEDATA_MARKS_SIZE; mark++)
3014                 {
3015                 gint i = (mark < 10 ? mark : 0);
3016
3017                 layout_actions_setup_mark(lw, i, "Mark%d",              _("Mark _%d"), NULL, NULL, NULL);
3018                 layout_actions_setup_mark(lw, i, "SetMark%d",   _("_Set mark %d"),                      NULL,           _("Set mark %d"), G_CALLBACK(layout_menu_set_mark_sel_cb));
3019                 layout_actions_setup_mark(lw, i, "ResetMark%d", _("_Reset mark %d"),                    NULL,           _("Reset mark %d"), G_CALLBACK(layout_menu_res_mark_sel_cb));
3020                 layout_actions_setup_mark(lw, i, "ToggleMark%d",        _("_Toggle mark %d"),                   "%d",           _("Toggle mark %d"), G_CALLBACK(layout_menu_toggle_mark_sel_cb));
3021                 layout_actions_setup_mark(lw, i, "ToggleMark%dAlt1",    _("_Toggle mark %d"),                   "KP_%d",        _("Toggle mark %d"), G_CALLBACK(layout_menu_toggle_mark_sel_cb));
3022                 layout_actions_setup_mark(lw, i, "SelectMark%d",        _("Se_lect mark %d"),                   "<control>%d",  _("Select mark %d"), G_CALLBACK(layout_menu_sel_mark_cb));
3023                 layout_actions_setup_mark(lw, i, "SelectMark%dAlt1",    _("_Select mark %d"),                   "<control>KP_%d", _("Select mark %d"), G_CALLBACK(layout_menu_sel_mark_cb));
3024                 layout_actions_setup_mark(lw, i, "AddMark%d",   _("_Add mark %d"),                      NULL,           _("Add mark %d"), G_CALLBACK(layout_menu_sel_mark_or_cb));
3025                 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));
3026                 layout_actions_setup_mark(lw, i, "UnselMark%d", _("_Unselect mark %d"),                 NULL,           _("Unselect mark %d"), G_CALLBACK(layout_menu_sel_mark_minus_cb));
3027                 layout_actions_setup_mark(lw, i, "FilterMark%d",        _("_Filter mark %d"),                   NULL,           _("Filter mark %d"), G_CALLBACK(layout_menu_mark_filter_toggle_cb));
3028
3029                 g_string_append_printf(desc,
3030                                 "      <menu action='Mark%d'>"
3031                                 "        <menuitem action='ToggleMark%d'/>"
3032                                 "        <menuitem action='SetMark%d'/>"
3033                                 "        <menuitem action='ResetMark%d'/>"
3034                                 "        <separator/>"
3035                                 "        <menuitem action='SelectMark%d'/>"
3036                                 "        <menuitem action='AddMark%d'/>"
3037                                 "        <menuitem action='IntMark%d'/>"
3038                                 "        <menuitem action='UnselMark%d'/>"
3039                                 "        <separator/>"
3040                                 "        <menuitem action='FilterMark%d'/>"
3041                                 "      </menu>",
3042                                 i, i, i, i, i, i, i, i, i);
3043                 }
3044
3045         g_string_append(desc,
3046                                 "    </menu>"
3047                                 "  </menubar>");
3048         for (mark = 1; mark <= FILEDATA_MARKS_SIZE; mark++)
3049                 {
3050                 gint i = (mark < 10 ? mark : 0);
3051
3052                 g_string_append_printf(desc,
3053                                 "<accelerator action='ToggleMark%dAlt1'/>"
3054                                 "<accelerator action='SelectMark%dAlt1'/>",
3055                                 i, i);
3056                 }
3057         g_string_append(desc,   "</ui>" );
3058
3059         error = NULL;
3060         if (!gtk_ui_manager_add_ui_from_string(lw->ui_manager, desc->str, -1, &error))
3061                 {
3062                 g_message("building menus failed: %s", error->message);
3063                 g_error_free(error);
3064                 exit(EXIT_FAILURE);
3065                 }
3066         g_string_free(desc, TRUE);
3067 }
3068
3069 static GList *layout_actions_editor_menu_path(EditorDescription *editor)
3070 {
3071         gchar **split = g_strsplit(editor->menu_path, "/", 0);
3072         gint i = 0;
3073         GList *ret = NULL;
3074
3075         if (split[0] == NULL)
3076                 {
3077                 g_strfreev(split);
3078                 return NULL;
3079                 }
3080
3081         while (split[i])
3082                 {
3083                 ret = g_list_prepend(ret, g_strdup(split[i]));
3084                 i++;
3085                 }
3086
3087         g_strfreev(split);
3088
3089         ret = g_list_prepend(ret, g_strdup(editor->key));
3090
3091         return g_list_reverse(ret);
3092 }
3093
3094 static void layout_actions_editor_add(GString *desc, GList *path, GList *old_path)
3095 {
3096         gint to_open, to_close, i;
3097         while (path && old_path && strcmp((gchar *)path->data, (gchar *)old_path->data) == 0)
3098                 {
3099                 path = path->next;
3100                 old_path = old_path->next;
3101                 }
3102         to_open = g_list_length(path) - 1;
3103         to_close = g_list_length(old_path) - 1;
3104
3105         if (to_close > 0)
3106                 {
3107                 old_path = g_list_last(old_path);
3108                 old_path = old_path->prev;
3109                 }
3110
3111         for (i =  0; i < to_close; i++)
3112                 {
3113                 gchar *name = static_cast<gchar *>(old_path->data);
3114                 if (g_str_has_suffix(name, "Section"))
3115                         {
3116                         g_string_append(desc,   "      </placeholder>");
3117                         }
3118                 else if (g_str_has_suffix(name, "Menu"))
3119                         {
3120                         g_string_append(desc,   "    </menu>");
3121                         }
3122                 else
3123                         {
3124                         g_warning("invalid menu path item %s", name);
3125                         }
3126                 old_path = old_path->prev;
3127                 }
3128
3129         for (i =  0; i < to_open; i++)
3130                 {
3131                 gchar *name = static_cast<gchar *>(path->data);
3132                 if (g_str_has_suffix(name, "Section"))
3133                         {
3134                         g_string_append_printf(desc,    "      <placeholder name='%s'>", name);
3135                         }
3136                 else if (g_str_has_suffix(name, "Menu"))
3137                         {
3138                         g_string_append_printf(desc,    "    <menu action='%s'>", name);
3139                         }
3140                 else
3141                         {
3142                         g_warning("invalid menu path item %s", name);
3143                         }
3144                 path = path->next;
3145                 }
3146
3147         if (path)
3148                 g_string_append_printf(desc, "      <menuitem action='%s'/>", (gchar *)path->data);
3149 }
3150
3151 static void layout_actions_setup_editors(LayoutWindow *lw)
3152 {
3153         GError *error;
3154         GList *editors_list;
3155         GList *work;
3156         GList *old_path;
3157         GString *desc;
3158
3159         if (lw->ui_editors_id)
3160                 {
3161                 gtk_ui_manager_remove_ui(lw->ui_manager, lw->ui_editors_id);
3162                 }
3163
3164         if (lw->action_group_editors)
3165                 {
3166                 gtk_ui_manager_remove_action_group(lw->ui_manager, lw->action_group_editors);
3167                 g_object_unref(lw->action_group_editors);
3168                 }
3169         lw->action_group_editors = gtk_action_group_new("MenuActionsExternal");
3170         gtk_ui_manager_insert_action_group(lw->ui_manager, lw->action_group_editors, 1);
3171
3172         /* lw->action_group_editors contains translated entries, no translate func is required */
3173         desc = g_string_new(
3174                                 "<ui>"
3175                                 "  <menubar name='MainMenu'>");
3176
3177         editors_list = editor_list_get();
3178
3179         old_path = NULL;
3180         work = editors_list;
3181         while (work)
3182                 {
3183                 GList *path;
3184                 EditorDescription *editor = static_cast<EditorDescription *>(work->data);
3185                 GtkActionEntry entry = { editor->key,
3186                                          NULL,
3187                                          editor->name,
3188                                          editor->hotkey,
3189                                          editor->comment ? editor->comment : editor->name,
3190                                          G_CALLBACK(layout_menu_edit_cb) };
3191
3192                 if (editor->icon)
3193                         {
3194                         entry.stock_id = editor->key;
3195                         }
3196                 gtk_action_group_add_actions(lw->action_group_editors, &entry, 1, lw);
3197
3198                 path = layout_actions_editor_menu_path(editor);
3199                 layout_actions_editor_add(desc, path, old_path);
3200
3201                 string_list_free(old_path);
3202                 old_path = path;
3203                 work = work->next;
3204                 }
3205
3206         layout_actions_editor_add(desc, NULL, old_path);
3207         string_list_free(old_path);
3208
3209         g_string_append(desc,   "  </menubar>"
3210                                 "</ui>" );
3211
3212         error = NULL;
3213
3214         lw->ui_editors_id = gtk_ui_manager_add_ui_from_string(lw->ui_manager, desc->str, -1, &error);
3215         if (!lw->ui_editors_id)
3216                 {
3217                 g_message("building menus failed: %s", error->message);
3218                 g_error_free(error);
3219                 exit(EXIT_FAILURE);
3220                 }
3221         g_string_free(desc, TRUE);
3222         g_list_free(editors_list);
3223 }
3224
3225 void layout_actions_setup(LayoutWindow *lw)
3226 {
3227         GError *error;
3228         gint i;
3229
3230         DEBUG_1("%s layout_actions_setup: start", get_exec_time());
3231         if (lw->ui_manager) return;
3232
3233         lw->action_group = gtk_action_group_new("MenuActions");
3234         gtk_action_group_set_translate_func(lw->action_group, menu_translate, NULL, NULL);
3235
3236         gtk_action_group_add_actions(lw->action_group,
3237                                      menu_entries, G_N_ELEMENTS(menu_entries), lw);
3238         gtk_action_group_add_toggle_actions(lw->action_group,
3239                                             menu_toggle_entries, G_N_ELEMENTS(menu_toggle_entries), lw);
3240         gtk_action_group_add_radio_actions(lw->action_group,
3241                                            menu_radio_entries, G_N_ELEMENTS(menu_radio_entries),
3242                                            0, G_CALLBACK(layout_menu_list_cb), lw);
3243         gtk_action_group_add_radio_actions(lw->action_group,
3244                                            menu_split_radio_entries, G_N_ELEMENTS(menu_split_radio_entries),
3245                                            0, G_CALLBACK(layout_menu_split_cb), lw);
3246         gtk_action_group_add_toggle_actions(lw->action_group,
3247                                            menu_view_dir_toggle_entries, G_N_ELEMENTS(menu_view_dir_toggle_entries),
3248                                             lw);
3249         gtk_action_group_add_radio_actions(lw->action_group,
3250                                            menu_color_radio_entries, COLOR_PROFILE_FILE + COLOR_PROFILE_INPUTS,
3251                                            0, G_CALLBACK(layout_color_menu_input_cb), lw);
3252         gtk_action_group_add_radio_actions(lw->action_group,
3253                                            menu_histogram_channel, G_N_ELEMENTS(menu_histogram_channel),
3254                                            0, G_CALLBACK(layout_menu_histogram_channel_cb), lw);
3255         gtk_action_group_add_radio_actions(lw->action_group,
3256                                            menu_histogram_mode, G_N_ELEMENTS(menu_histogram_mode),
3257                                            0, G_CALLBACK(layout_menu_histogram_mode_cb), lw);
3258         gtk_action_group_add_radio_actions(lw->action_group,
3259                                            menu_stereo_mode_entries, G_N_ELEMENTS(menu_stereo_mode_entries),
3260                                            0, G_CALLBACK(layout_menu_stereo_mode_cb), lw);
3261
3262
3263         lw->ui_manager = gtk_ui_manager_new();
3264         gtk_ui_manager_set_add_tearoffs(lw->ui_manager, TRUE);
3265         gtk_ui_manager_insert_action_group(lw->ui_manager, lw->action_group, 0);
3266
3267         DEBUG_1("%s layout_actions_setup: add menu", get_exec_time());
3268         error = NULL;
3269         if (!gtk_ui_manager_add_ui_from_string(lw->ui_manager, menu_ui_description, -1, &error))
3270                 {
3271                 g_message("building menus failed: %s", error->message);
3272                 g_error_free(error);
3273                 exit(EXIT_FAILURE);
3274                 }
3275
3276         DEBUG_1("%s layout_actions_setup: add toolbar", get_exec_time());
3277         for (i = 0; i < TOOLBAR_COUNT; i++)
3278                 {
3279                 layout_toolbar_clear(lw, i);
3280                 layout_toolbar_add_default(lw, i);
3281                 }
3282
3283         DEBUG_1("%s layout_actions_setup: marks", get_exec_time());
3284         layout_actions_setup_marks(lw);
3285
3286         DEBUG_1("%s layout_actions_setup: editors", get_exec_time());
3287         layout_actions_setup_editors(lw);
3288
3289         DEBUG_1("%s layout_actions_setup: status_update_write", get_exec_time());
3290         layout_util_status_update_write(lw);
3291
3292         DEBUG_1("%s layout_actions_setup: actions_add_window", get_exec_time());
3293         layout_actions_add_window(lw, lw->window);
3294         DEBUG_1("%s layout_actions_setup: end", get_exec_time());
3295 }
3296
3297 static gint layout_editors_reload_idle_id = -1;
3298 static GList *layout_editors_desktop_files = NULL;
3299
3300 static gboolean layout_editors_reload_idle_cb(gpointer UNUSED(data))
3301 {
3302         if (!layout_editors_desktop_files)
3303                 {
3304                 DEBUG_1("%s layout_editors_reload_idle_cb: get_desktop_files", get_exec_time());
3305                 layout_editors_desktop_files = editor_get_desktop_files();
3306                 return TRUE;
3307                 }
3308
3309         editor_read_desktop_file(layout_editors_desktop_files->data);
3310         g_free(layout_editors_desktop_files->data);
3311         layout_editors_desktop_files = g_list_delete_link(layout_editors_desktop_files, layout_editors_desktop_files);
3312
3313
3314         if (!layout_editors_desktop_files)
3315                 {
3316                 GList *work;
3317                 DEBUG_1("%s layout_editors_reload_idle_cb: setup_editors", get_exec_time());
3318                 editor_table_finish();
3319
3320                 work = layout_window_list;
3321                 while (work)
3322                         {
3323                         LayoutWindow *lw = static_cast<LayoutWindow *>(work->data);
3324                         work = work->next;
3325                         layout_actions_setup_editors(lw);
3326                         if (lw->bar_sort_enabled)
3327                                 {
3328                                 layout_bar_sort_toggle(lw);
3329                                 }
3330                         }
3331
3332                 DEBUG_1("%s layout_editors_reload_idle_cb: setup_editors done", get_exec_time());
3333
3334                 layout_editors_reload_idle_id = -1;
3335                 return FALSE;
3336                 }
3337         return TRUE;
3338 }
3339
3340 void layout_editors_reload_start(void)
3341 {
3342         DEBUG_1("%s layout_editors_reload_start", get_exec_time());
3343
3344         if (layout_editors_reload_idle_id != -1)
3345                 {
3346                 g_source_remove(layout_editors_reload_idle_id);
3347                 string_list_free(layout_editors_desktop_files);
3348                 }
3349
3350         editor_table_clear();
3351         layout_editors_reload_idle_id = g_idle_add(layout_editors_reload_idle_cb, NULL);
3352 }
3353
3354 void layout_editors_reload_finish(void)
3355 {
3356         if (layout_editors_reload_idle_id != -1)
3357                 {
3358                 DEBUG_1("%s layout_editors_reload_finish", get_exec_time());
3359                 g_source_remove(layout_editors_reload_idle_id);
3360                 while (layout_editors_reload_idle_id != -1)
3361                         {
3362                         layout_editors_reload_idle_cb(NULL);
3363                         }
3364                 }
3365 }
3366
3367 void layout_actions_add_window(LayoutWindow *lw, GtkWidget *window)
3368 {
3369         GtkAccelGroup *group;
3370
3371         if (!lw->ui_manager) return;
3372
3373         group = gtk_ui_manager_get_accel_group(lw->ui_manager);
3374         gtk_window_add_accel_group(GTK_WINDOW(window), group);
3375 }
3376
3377 GtkWidget *layout_actions_menu_bar(LayoutWindow *lw)
3378 {
3379         if (lw->menu_bar) return lw->menu_bar;
3380         lw->menu_bar = gtk_ui_manager_get_widget(lw->ui_manager, "/MainMenu");
3381         g_object_ref(lw->menu_bar);
3382         return lw->menu_bar;
3383 }
3384
3385 GtkWidget *layout_actions_toolbar(LayoutWindow *lw, ToolbarType type)
3386 {
3387         if (lw->toolbar[type]) return lw->toolbar[type];
3388         switch (type)
3389                 {
3390                 case TOOLBAR_MAIN:
3391                         lw->toolbar[type] = gtk_ui_manager_get_widget(lw->ui_manager, "/ToolBar");
3392                         gtk_toolbar_set_icon_size(GTK_TOOLBAR(lw->toolbar[type]), GTK_ICON_SIZE_SMALL_TOOLBAR);
3393                         gtk_toolbar_set_style(GTK_TOOLBAR(lw->toolbar[type]), GTK_TOOLBAR_ICONS);
3394                         break;
3395                 case TOOLBAR_STATUS:
3396                         lw->toolbar[type] = gtk_ui_manager_get_widget(lw->ui_manager, "/StatusBar");
3397                         gtk_toolbar_set_icon_size(GTK_TOOLBAR(lw->toolbar[type]), GTK_ICON_SIZE_MENU);
3398                         gtk_toolbar_set_style(GTK_TOOLBAR(lw->toolbar[type]), GTK_TOOLBAR_ICONS);
3399                         gtk_toolbar_set_show_arrow(GTK_TOOLBAR(lw->toolbar[type]), FALSE);
3400                         break;
3401                 default:
3402                         break;
3403                 }
3404         g_object_ref(lw->toolbar[type]);
3405         return lw->toolbar[type];
3406 }
3407
3408 GtkWidget *layout_actions_menu_tool_bar(LayoutWindow *lw)
3409 {
3410         GtkWidget *menu_bar;
3411         GtkWidget *toolbar;
3412
3413         if (lw->menu_tool_bar) return lw->menu_tool_bar;
3414
3415         menu_bar = layout_actions_menu_bar(lw);
3416         DEBUG_NAME(menu_bar);
3417         toolbar = layout_actions_toolbar(lw, TOOLBAR_MAIN);
3418         DEBUG_NAME(toolbar);
3419         lw->menu_tool_bar = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
3420
3421         gtk_box_pack_start(GTK_BOX(lw->menu_tool_bar), menu_bar, FALSE, FALSE, 0);
3422         gtk_box_pack_start(GTK_BOX(lw->menu_tool_bar), toolbar, FALSE, FALSE, 0);
3423
3424         g_object_ref(lw->menu_tool_bar);
3425         return lw->menu_tool_bar;
3426 }
3427
3428 void layout_toolbar_clear(LayoutWindow *lw, ToolbarType type)
3429 {
3430         if (lw->toolbar_merge_id[type])
3431                 {
3432                 gtk_ui_manager_remove_ui(lw->ui_manager, lw->toolbar_merge_id[type]);
3433                 gtk_ui_manager_ensure_update(lw->ui_manager);
3434                 }
3435         string_list_free(lw->toolbar_actions[type]);
3436         lw->toolbar_actions[type] = NULL;
3437
3438         lw->toolbar_merge_id[type] = gtk_ui_manager_new_merge_id(lw->ui_manager);
3439 }
3440
3441 void layout_toolbar_add(LayoutWindow *lw, ToolbarType type, const gchar *action)
3442 {
3443         const gchar *path = NULL;
3444
3445         if (!action || !lw->ui_manager) return;
3446
3447         if (g_list_find_custom(lw->toolbar_actions[type], action, (GCompareFunc)strcmp)) return;
3448
3449         switch (type)
3450                 {
3451                 case TOOLBAR_MAIN:
3452                         path = "/ToolBar";
3453                         break;
3454                 case TOOLBAR_STATUS:
3455                         path = "/StatusBar";
3456                         break;
3457                 default:
3458                         break;
3459                 }
3460
3461
3462         if (g_str_has_suffix(action, ".desktop"))
3463                 {
3464                 /* this may be called before the external editors are read
3465                    create a dummy action for now */
3466                 if (!lw->action_group_editors)
3467                         {
3468                         lw->action_group_editors = gtk_action_group_new("MenuActionsExternal");
3469                         gtk_ui_manager_insert_action_group(lw->ui_manager, lw->action_group_editors, 1);
3470                         }
3471                 if (!gtk_action_group_get_action(lw->action_group_editors, action))
3472                         {
3473                         GtkActionEntry entry = { action,
3474                                                  GTK_STOCK_MISSING_IMAGE,
3475                                                  action,
3476                                                  NULL,
3477                                                  NULL,
3478                                                  NULL };
3479                         DEBUG_1("Creating temporary action %s", action);
3480                         gtk_action_group_add_actions(lw->action_group_editors, &entry, 1, lw);
3481                         }
3482                 }
3483         gtk_ui_manager_add_ui(lw->ui_manager, lw->toolbar_merge_id[type], path, action, action, GTK_UI_MANAGER_TOOLITEM, FALSE);
3484         lw->toolbar_actions[type] = g_list_append(lw->toolbar_actions[type], g_strdup(action));
3485 }
3486
3487
3488 void layout_toolbar_add_default(LayoutWindow *lw, ToolbarType type)
3489 {
3490         LayoutWindow *lw_first;
3491         GList *work_action;
3492
3493         switch (type)
3494                 {
3495                 case TOOLBAR_MAIN:
3496                         if (layout_window_list)
3497                                 {
3498                                 lw_first = static_cast<LayoutWindow *>(layout_window_list->data);
3499                                 if (lw_first->toolbar_actions[TOOLBAR_MAIN])
3500                                         {
3501                                         work_action = lw_first->toolbar_actions[type];
3502                                         while (work_action)
3503                                                 {
3504                                                 gchar *action = static_cast<gchar *>(work_action->data);
3505                                                 work_action = work_action->next;
3506                                                 layout_toolbar_add(lw, type, action);
3507                                                 }
3508                                         }
3509                                 else
3510                                         {
3511                                         layout_toolbar_add(lw, type, "Thumbnails");
3512                                         layout_toolbar_add(lw, type, "Back");
3513                                         layout_toolbar_add(lw, type, "Forward");
3514                                         layout_toolbar_add(lw, type, "Up");
3515                                         layout_toolbar_add(lw, type, "Home");
3516                                         layout_toolbar_add(lw, type, "Refresh");
3517                                         layout_toolbar_add(lw, type, "ZoomIn");
3518                                         layout_toolbar_add(lw, type, "ZoomOut");
3519                                         layout_toolbar_add(lw, type, "ZoomFit");
3520                                         layout_toolbar_add(lw, type, "Zoom100");
3521                                         layout_toolbar_add(lw, type, "Preferences");
3522                                         layout_toolbar_add(lw, type, "FloatTools");
3523                                         }
3524                                 }
3525                         else
3526                                 {
3527                                 layout_toolbar_add(lw, type, "Thumbnails");
3528                                 layout_toolbar_add(lw, type, "Back");
3529                                 layout_toolbar_add(lw, type, "Forward");
3530                                 layout_toolbar_add(lw, type, "Up");
3531                                 layout_toolbar_add(lw, type, "Home");
3532                                 layout_toolbar_add(lw, type, "Refresh");
3533                                 layout_toolbar_add(lw, type, "ZoomIn");
3534                                 layout_toolbar_add(lw, type, "ZoomOut");
3535                                 layout_toolbar_add(lw, type, "ZoomFit");
3536                                 layout_toolbar_add(lw, type, "Zoom100");
3537                                 layout_toolbar_add(lw, type, "Preferences");
3538                                 layout_toolbar_add(lw, type, "FloatTools");
3539                                 }
3540                         break;
3541                 case TOOLBAR_STATUS:
3542                         if (layout_window_list)
3543                                 {
3544                                 lw_first = static_cast<LayoutWindow *>(layout_window_list->data);
3545                                 if (lw_first->toolbar_actions[TOOLBAR_MAIN])
3546                                         {
3547                                         work_action = lw_first->toolbar_actions[type];
3548                                         while (work_action)
3549                                                 {
3550                                                 gchar *action = static_cast<gchar *>(work_action->data);
3551                                                 work_action = work_action->next;
3552                                                 layout_toolbar_add(lw, type, action);
3553                                                 }
3554                                         }
3555                                 else
3556                                         {
3557                                         layout_toolbar_add(lw, type, "ExifRotate");
3558                                         layout_toolbar_add(lw, type, "ShowInfoPixel");
3559                                         layout_toolbar_add(lw, type, "UseColorProfiles");
3560                                         layout_toolbar_add(lw, type, "SaveMetadata");
3561                                         }
3562                                 }
3563                         else
3564                                 {
3565                                 layout_toolbar_add(lw, type, "ExifRotate");
3566                                 layout_toolbar_add(lw, type, "ShowInfoPixel");
3567                                 layout_toolbar_add(lw, type, "UseColorProfiles");
3568                                 layout_toolbar_add(lw, type, "SaveMetadata");
3569                                 }
3570                         break;
3571                 default:
3572                         break;
3573                 }
3574 }
3575
3576
3577
3578 void layout_toolbar_write_config(LayoutWindow *lw, ToolbarType type, GString *outstr, gint indent)
3579 {
3580         const gchar *name = NULL;
3581         GList *work = lw->toolbar_actions[type];
3582
3583         switch (type)
3584                 {
3585                 case TOOLBAR_MAIN:
3586                         name = "toolbar";
3587                         break;
3588                 case TOOLBAR_STATUS:
3589                         name = "statusbar";
3590                         break;
3591                 default:
3592                         break;
3593                 }
3594
3595         WRITE_NL(); WRITE_STRING("<%s>", name);
3596         indent++;
3597         WRITE_NL(); WRITE_STRING("<clear/>");
3598         while (work)
3599                 {
3600                 gchar *action = static_cast<gchar *>(work->data);
3601                 work = work->next;
3602                 WRITE_NL(); WRITE_STRING("<toolitem ");
3603                 write_char_option(outstr, indent + 1, "action", action);
3604                 WRITE_STRING("/>");
3605                 }
3606         indent--;
3607         WRITE_NL(); WRITE_STRING("</%s>", name);
3608 }
3609
3610 void layout_toolbar_add_from_config(LayoutWindow *lw, ToolbarType type, const char **attribute_names, const gchar **attribute_values)
3611 {
3612         gchar *action = NULL;
3613
3614         while (*attribute_names)
3615                 {
3616                 const gchar *option = *attribute_names++;
3617                 const gchar *value = *attribute_values++;
3618
3619                 if (READ_CHAR_FULL("action", action)) continue;
3620
3621                 log_printf("unknown attribute %s = %s\n", option, value);
3622                 }
3623
3624         layout_toolbar_add(lw, type, action);
3625         g_free(action);
3626 }
3627
3628 /*
3629  *-----------------------------------------------------------------------------
3630  * misc
3631  *-----------------------------------------------------------------------------
3632  */
3633
3634 void layout_util_status_update_write(LayoutWindow *lw)
3635 {
3636         GtkAction *action;
3637         gint n = metadata_queue_length();
3638         action = gtk_action_group_get_action(lw->action_group, "SaveMetadata");
3639         gtk_action_set_sensitive(action, n > 0);
3640         if (n > 0)
3641                 {
3642                 gchar *buf = g_strdup_printf(_("Number of files with unsaved metadata: %d"), n);
3643                 g_object_set(G_OBJECT(action), "tooltip", buf, NULL);
3644                 g_free(buf);
3645                 }
3646         else
3647                 {
3648                 g_object_set(G_OBJECT(action), "tooltip", _("No unsaved metadata"), NULL);
3649                 }
3650 }
3651
3652 void layout_util_status_update_write_all(void)
3653 {
3654         GList *work;
3655
3656         work = layout_window_list;
3657         while (work)
3658                 {
3659                 LayoutWindow *lw = static_cast<LayoutWindow *>(work->data);
3660                 work = work->next;
3661
3662                 layout_util_status_update_write(lw);
3663                 }
3664 }
3665
3666 static gchar *layout_color_name_parse(const gchar *name)
3667 {
3668         if (!name || !*name) return g_strdup(_("Empty"));
3669         return g_strdelimit(g_strdup(name), "_", '-');
3670 }
3671
3672 void layout_util_sync_color(LayoutWindow *lw)
3673 {
3674         GtkAction *action;
3675         gint input = 0;
3676         gboolean use_color;
3677         gboolean use_image = FALSE;
3678         gint i;
3679         gchar action_name[15];
3680 #ifdef HAVE_LCMS
3681         gchar *image_profile;
3682         gchar *screen_profile;
3683 #endif
3684
3685         if (!lw->action_group) return;
3686         if (!layout_image_color_profile_get(lw, &input, &use_image)) return;
3687
3688         use_color = layout_image_color_profile_get_use(lw);
3689
3690         action = gtk_action_group_get_action(lw->action_group, "UseColorProfiles");
3691 #ifdef HAVE_LCMS
3692         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), use_color);
3693         if (layout_image_color_profile_get_status(lw, &image_profile, &screen_profile))
3694                 {
3695                 gchar *buf;
3696                 buf = g_strdup_printf(_("Image profile: %s\nScreen profile: %s"), image_profile, screen_profile);
3697                 g_object_set(G_OBJECT(action), "tooltip", buf, NULL);
3698                 g_free(image_profile);
3699                 g_free(screen_profile);
3700                 g_free(buf);
3701                 }
3702         else
3703                 {
3704                 g_object_set(G_OBJECT(action), "tooltip", _("Click to enable color management"), NULL);
3705                 }
3706 #else
3707         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), FALSE);
3708         gtk_action_set_sensitive(action, FALSE);
3709         g_object_set(G_OBJECT(action), "tooltip", _("Color profiles not supported"), NULL);
3710 #endif
3711
3712         action = gtk_action_group_get_action(lw->action_group, "UseImageProfile");
3713         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), use_image);
3714         gtk_action_set_sensitive(action, use_color);
3715
3716         for (i = 0; i < COLOR_PROFILE_FILE + COLOR_PROFILE_INPUTS; i++)
3717                 {
3718                 sprintf(action_name, "ColorProfile%d", i);
3719                 action = gtk_action_group_get_action(lw->action_group, action_name);
3720
3721                 if (i >= COLOR_PROFILE_FILE)
3722                         {
3723                         const gchar *name = options->color_profile.input_name[i - COLOR_PROFILE_FILE];
3724                         const gchar *file = options->color_profile.input_file[i - COLOR_PROFILE_FILE];
3725                         gchar *end;
3726                         gchar *buf;
3727
3728                         if (!name || !name[0]) name = filename_from_path(file);
3729
3730                         end = layout_color_name_parse(name);
3731                         buf = g_strdup_printf(_("Input _%d: %s"), i, end);
3732                         g_free(end);
3733
3734                         g_object_set(G_OBJECT(action), "label", buf, NULL);
3735                         g_free(buf);
3736
3737                         gtk_action_set_visible(action, file && file[0]);
3738                         }
3739
3740                 gtk_action_set_sensitive(action, !use_image);
3741                 gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), (i == input));
3742                 }
3743
3744         action = gtk_action_group_get_action(lw->action_group, "Grayscale");
3745         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), layout_image_get_desaturate(lw));
3746 }
3747
3748 void layout_util_sync_file_filter(LayoutWindow *lw)
3749 {
3750         GtkAction *action;
3751
3752         if (!lw->action_group) return;
3753
3754         action = gtk_action_group_get_action(lw->action_group, "ShowFileFilter");
3755         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_file_filter);
3756 }
3757
3758 void layout_util_sync_marks(LayoutWindow *lw)
3759 {
3760         GtkAction *action;
3761
3762         if (!lw->action_group) return;
3763
3764         action = gtk_action_group_get_action(lw->action_group, "ShowMarks");
3765         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_marks);
3766 }
3767
3768 static void layout_util_sync_views(LayoutWindow *lw)
3769 {
3770         GtkAction *action;
3771         OsdShowFlags osd_flags = image_osd_get(lw->image);
3772
3773         if (!lw->action_group) return;
3774
3775         action = gtk_action_group_get_action(lw->action_group, "FolderTree");
3776         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.dir_view_type);
3777
3778         action = gtk_action_group_get_action(lw->action_group, "SplitSingle");
3779         gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), lw->split_mode);
3780
3781         action = gtk_action_group_get_action(lw->action_group, "SplitNextPane");
3782         gtk_action_set_sensitive(action, !(lw->split_mode == SPLIT_NONE));
3783         action = gtk_action_group_get_action(lw->action_group, "SplitPreviousPane");
3784         gtk_action_set_sensitive(action, !(lw->split_mode == SPLIT_NONE));
3785         action = gtk_action_group_get_action(lw->action_group, "SplitUpPane");
3786         gtk_action_set_sensitive(action, !(lw->split_mode == SPLIT_NONE));
3787         action = gtk_action_group_get_action(lw->action_group, "SplitDownPane");
3788         gtk_action_set_sensitive(action, !(lw->split_mode == SPLIT_NONE));
3789
3790         action = gtk_action_group_get_action(lw->action_group, "SplitPaneSync");
3791         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.split_pane_sync);
3792
3793         action = gtk_action_group_get_action(lw->action_group, "ViewIcons");
3794         gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), lw->options.file_view_type);
3795
3796         action = gtk_action_group_get_action(lw->action_group, "FloatTools");
3797         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.tools_float);
3798
3799         action = gtk_action_group_get_action(lw->action_group, "SBar");
3800         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), layout_bar_enabled(lw));
3801
3802         action = gtk_action_group_get_action(lw->action_group, "SBarSort");
3803         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), layout_bar_sort_enabled(lw));
3804
3805         action = gtk_action_group_get_action(lw->action_group, "HideToolbar");
3806         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.toolbar_hidden);
3807
3808         action = gtk_action_group_get_action(lw->action_group, "ShowInfoPixel");
3809         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_info_pixel);
3810
3811         action = gtk_action_group_get_action(lw->action_group, "SlideShow");
3812         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), layout_image_slideshow_active(lw));
3813
3814         action = gtk_action_group_get_action(lw->action_group, "IgnoreAlpha");
3815         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.ignore_alpha);
3816
3817         action = gtk_action_group_get_action(lw->action_group, "Animate");
3818         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.animate);
3819
3820         action = gtk_action_group_get_action(lw->action_group, "ImageOverlay");
3821         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), osd_flags != OSD_SHOW_NOTHING);
3822
3823         action = gtk_action_group_get_action(lw->action_group, "ImageHistogram");
3824         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), osd_flags & OSD_SHOW_HISTOGRAM);
3825
3826         action = gtk_action_group_get_action(lw->action_group, "ExifRotate");
3827         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), options->image.exif_rotate_enable);
3828
3829         action = gtk_action_group_get_action(lw->action_group, "OverUnderExposed");
3830         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), options->overunderexposed);
3831
3832         action = gtk_action_group_get_action(lw->action_group, "DrawRectangle");
3833         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), options->draw_rectangle);
3834
3835         action = gtk_action_group_get_action(lw->action_group, "RectangularSelection");
3836         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), options->collections.rectangular_selection);
3837
3838         action = gtk_action_group_get_action(lw->action_group, "ShowFileFilter");
3839         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_file_filter);
3840
3841         action = gtk_action_group_get_action(lw->action_group, "HideBars");
3842         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), (lw->options.bars_state.hidden));
3843
3844         if (osd_flags & OSD_SHOW_HISTOGRAM)
3845                 {
3846                 action = gtk_action_group_get_action(lw->action_group, "HistogramChanR");
3847                 gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), image_osd_histogram_get_channel(lw->image));
3848
3849                 action = gtk_action_group_get_action(lw->action_group, "HistogramModeLin");
3850                 gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), image_osd_histogram_get_mode(lw->image));
3851                 }
3852
3853         action = gtk_action_group_get_action(lw->action_group, "ConnectZoomMenu");
3854         gtk_action_set_sensitive(action, lw->split_mode != SPLIT_NONE);
3855
3856         action = gtk_action_group_get_action(lw->action_group, "WriteRotation");
3857         gtk_action_set_sensitive(action, !(runcmd("which exiftran >/dev/null 2>&1") ||
3858                                                         runcmd("which mogrify >/dev/null 2>&1") || options->metadata.write_orientation));
3859         action = gtk_action_group_get_action(lw->action_group, "WriteRotationKeepDate");
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
3863         action = gtk_action_group_get_action(lw->action_group, "StereoAuto");
3864         gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), layout_image_stereo_pixbuf_get(lw));
3865
3866         layout_util_sync_marks(lw);
3867         layout_util_sync_color(lw);
3868         layout_image_set_ignore_alpha(lw, lw->options.ignore_alpha);
3869 }
3870
3871 void layout_util_sync_thumb(LayoutWindow *lw)
3872 {
3873         GtkAction *action;
3874
3875         if (!lw->action_group) return;
3876
3877         action = gtk_action_group_get_action(lw->action_group, "Thumbnails");
3878         gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), lw->options.show_thumbnails);
3879         g_object_set(action, "sensitive", (lw->options.file_view_type == FILEVIEW_LIST), NULL);
3880 }
3881
3882 void layout_util_sync(LayoutWindow *lw)
3883 {
3884         layout_util_sync_views(lw);
3885         layout_util_sync_thumb(lw);
3886         layout_menu_recent_update(lw);
3887 //      layout_menu_edit_update(lw);
3888 }
3889
3890 /**
3891  * @brief Checks if event key is mapped to Help
3892  * @param event
3893  * @returns
3894  *
3895  * Used to check if the user has re-mapped the Help key
3896  * in Preferences/Keyboard
3897  *
3898  * Note: help_key.accel_mods and event->state
3899  * differ in the higher bits
3900  */
3901 gboolean is_help_key(GdkEventKey *event)
3902 {
3903         GtkAccelKey help_key;
3904         gboolean ret = FALSE;
3905         guint mask = GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK;
3906
3907         if (gtk_accel_map_lookup_entry("<Actions>/MenuActions/HelpContents", &help_key))
3908                 {
3909                 if (help_key.accel_key == event->keyval &&
3910                                         (help_key.accel_mods & mask) == (event->state & mask))
3911                         {
3912                         ret = TRUE;
3913                         }
3914                 }
3915
3916         return ret;
3917 }
3918
3919 /*
3920  *-----------------------------------------------------------------------------
3921  * sidebars
3922  *-----------------------------------------------------------------------------
3923  */
3924
3925 static gboolean layout_bar_enabled(LayoutWindow *lw)
3926 {
3927         return lw->bar && gtk_widget_get_visible(lw->bar);
3928 }
3929
3930 static void layout_bar_destroyed(GtkWidget *UNUSED(widget), gpointer data)
3931 {
3932         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
3933
3934         lw->bar = NULL;
3935 /*
3936     do not call layout_util_sync_views(lw) here
3937     this is called either when whole layout is destroyed - no need for update
3938     or when the bar is replaced - sync is called by upper function at the end of whole operation
3939
3940 */
3941 }
3942
3943 static void layout_bar_set_default(LayoutWindow *lw)
3944 {
3945         GtkWidget *bar;
3946
3947         if (!lw->utility_box) return;
3948
3949         bar = bar_new(lw);
3950         DEBUG_NAME(bar);
3951
3952         layout_bar_set(lw, bar);
3953
3954         bar_populate_default(bar);
3955 }
3956
3957 static void layout_bar_close(LayoutWindow *lw)
3958 {
3959         if (lw->bar)
3960                 {
3961                 bar_close(lw->bar);
3962                 lw->bar = NULL;
3963                 }
3964 }
3965
3966
3967 void layout_bar_set(LayoutWindow *lw, GtkWidget *bar)
3968 {
3969         if (!lw->utility_box) return;
3970
3971         layout_bar_close(lw); /* if any */
3972
3973         if (!bar) return;
3974         lw->bar = bar;
3975
3976         g_signal_connect(G_OBJECT(lw->bar), "destroy",
3977                          G_CALLBACK(layout_bar_destroyed), lw);
3978
3979
3980 //      gtk_box_pack_start(GTK_BOX(lw->utility_box), lw->bar, FALSE, FALSE, 0);
3981         gtk_paned_pack2(GTK_PANED(lw->utility_paned), lw->bar, FALSE, TRUE);
3982
3983         bar_set_fd(lw->bar, layout_image_get_fd(lw));
3984 }
3985
3986
3987 void layout_bar_toggle(LayoutWindow *lw)
3988 {
3989         if (layout_bar_enabled(lw))
3990                 {
3991                 gtk_widget_hide(lw->bar);
3992                 }
3993         else
3994                 {
3995                 if (!lw->bar)
3996                         {
3997                         layout_bar_set_default(lw);
3998                         }
3999                 gtk_widget_show(lw->bar);
4000                 bar_set_fd(lw->bar, layout_image_get_fd(lw));
4001                 }
4002         layout_util_sync_views(lw);
4003 }
4004
4005 static void layout_bar_new_image(LayoutWindow *lw)
4006 {
4007         if (!layout_bar_enabled(lw)) return;
4008
4009         bar_set_fd(lw->bar, layout_image_get_fd(lw));
4010 }
4011
4012 static void layout_bar_new_selection(LayoutWindow *lw, gint count)
4013 {
4014         if (!layout_bar_enabled(lw)) return;
4015
4016         bar_notify_selection(lw->bar, count);
4017 }
4018
4019 static gboolean layout_bar_sort_enabled(LayoutWindow *lw)
4020 {
4021         return lw->bar_sort && gtk_widget_get_visible(lw->bar_sort);
4022 }
4023
4024
4025 static void layout_bar_sort_destroyed(GtkWidget *UNUSED(widget), gpointer data)
4026 {
4027         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
4028
4029         lw->bar_sort = NULL;
4030
4031 /*
4032     do not call layout_util_sync_views(lw) here
4033     this is called either when whole layout is destroyed - no need for update
4034     or when the bar is replaced - sync is called by upper function at the end of whole operation
4035
4036 */
4037 }
4038
4039 static void layout_bar_sort_set_default(LayoutWindow *lw)
4040 {
4041         GtkWidget *bar;
4042
4043         if (!lw->utility_box) return;
4044
4045         bar = bar_sort_new_default(lw);
4046
4047         layout_bar_sort_set(lw, bar);
4048 }
4049
4050 static void layout_bar_sort_close(LayoutWindow *lw)
4051 {
4052         if (lw->bar_sort)
4053                 {
4054                 bar_sort_close(lw->bar_sort);
4055                 lw->bar_sort = NULL;
4056                 }
4057 }
4058
4059 void layout_bar_sort_set(LayoutWindow *lw, GtkWidget *bar)
4060 {
4061         if (!lw->utility_box) return;
4062
4063         layout_bar_sort_close(lw); /* if any */
4064
4065         if (!bar) return;
4066         lw->bar_sort = bar;
4067
4068         g_signal_connect(G_OBJECT(lw->bar_sort), "destroy",
4069                          G_CALLBACK(layout_bar_sort_destroyed), lw);
4070
4071         gtk_box_pack_end(GTK_BOX(lw->utility_box), lw->bar_sort, FALSE, FALSE, 0);
4072 }
4073
4074 void layout_bar_sort_toggle(LayoutWindow *lw)
4075 {
4076         if (layout_bar_sort_enabled(lw))
4077                 {
4078                 gtk_widget_hide(lw->bar_sort);
4079                 }
4080         else
4081                 {
4082                 if (!lw->bar_sort)
4083                         {
4084                         layout_bar_sort_set_default(lw);
4085                         }
4086                 gtk_widget_show(lw->bar_sort);
4087                 }
4088         layout_util_sync_views(lw);
4089 }
4090
4091 static void layout_bars_hide_toggle(LayoutWindow *lw)
4092 {
4093         if (lw->options.bars_state.hidden)
4094                 {
4095                 lw->options.bars_state.hidden = FALSE;
4096                 if (lw->options.bars_state.sort)
4097                         {
4098                         if (lw->bar_sort)
4099                                 {
4100                                 gtk_widget_show(lw->bar_sort);
4101                                 }
4102                         else
4103                                 {
4104                                 layout_bar_sort_set_default(lw);
4105                                 }
4106                         }
4107                 if (lw->options.bars_state.info)
4108                         {
4109                         gtk_widget_show(lw->bar);
4110                         }
4111                 layout_tools_float_set(lw, lw->options.tools_float,
4112                                                                         lw->options.bars_state.tools_hidden);
4113                 }
4114         else
4115                 {
4116                 lw->options.bars_state.hidden = TRUE;
4117                 lw->options.bars_state.sort = layout_bar_sort_enabled(lw);
4118                 lw->options.bars_state.info = layout_bar_enabled(lw);
4119                 lw->options.bars_state.tools_float = lw->options.tools_float;
4120                 lw->options.bars_state.tools_hidden = lw->options.tools_hidden;
4121
4122                 if (lw->bar)
4123                         {
4124                         gtk_widget_hide(lw->bar);
4125                         }
4126
4127                 if (lw->bar_sort)
4128                         gtk_widget_hide(lw->bar_sort);
4129                 layout_tools_float_set(lw, lw->options.tools_float, TRUE);
4130                 }
4131
4132         layout_util_sync_views(lw);
4133 }
4134
4135 void layout_bars_new_image(LayoutWindow *lw)
4136 {
4137         layout_bar_new_image(lw);
4138
4139         if (lw->exif_window) advanced_exif_set_fd(lw->exif_window, layout_image_get_fd(lw));
4140
4141         /* this should be called here to handle the metadata edited in bars */
4142         if (options->metadata.confirm_on_image_change)
4143                 metadata_write_queue_confirm(FALSE, NULL, NULL);
4144 }
4145
4146 void layout_bars_new_selection(LayoutWindow *lw, gint count)
4147 {
4148         layout_bar_new_selection(lw, count);
4149 }
4150
4151 GtkWidget *layout_bars_prepare(LayoutWindow *lw, GtkWidget *image)
4152 {
4153         if (lw->utility_box) return lw->utility_box;
4154         lw->utility_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
4155         lw->utility_paned = gtk_hpaned_new();
4156         DEBUG_NAME(lw->utility_paned);
4157         gtk_box_pack_start(GTK_BOX(lw->utility_box), lw->utility_paned, TRUE, TRUE, 0);
4158
4159         gtk_paned_pack1(GTK_PANED(lw->utility_paned), image, TRUE, FALSE);
4160         gtk_widget_show(lw->utility_paned);
4161
4162         gtk_widget_show(image);
4163
4164         g_object_ref(lw->utility_box);
4165         return lw->utility_box;
4166 }
4167
4168 void layout_bars_close(LayoutWindow *lw)
4169 {
4170         layout_bar_sort_close(lw);
4171         layout_bar_close(lw);
4172 }
4173
4174 static gboolean layout_exif_window_destroy(GtkWidget *UNUSED(widget), gpointer data)
4175 {
4176         LayoutWindow *lw = static_cast<LayoutWindow *>(data);
4177         lw->exif_window = NULL;
4178
4179         return TRUE;
4180 }
4181
4182 void layout_exif_window_new(LayoutWindow *lw)
4183 {
4184         if (lw->exif_window) return;
4185
4186         lw->exif_window = advanced_exif_new(lw);
4187         if (!lw->exif_window) return;
4188         g_signal_connect(G_OBJECT(lw->exif_window), "destroy",
4189                          G_CALLBACK(layout_exif_window_destroy), lw);
4190         advanced_exif_set_fd(lw->exif_window, layout_image_get_fd(lw));
4191 }
4192
4193 static void layout_search_and_run_window_new(LayoutWindow *lw)
4194 {
4195         if (lw->sar_window)
4196                 {
4197                 gtk_window_present(GTK_WINDOW(lw->sar_window));
4198                 return;
4199                 }
4200
4201         lw->sar_window = search_and_run_new(lw);
4202 }
4203
4204 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */