edit.c

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    Copyright (C) 2023-2025 Aurélien PIERRE.
    Copyright (C) 2023 Luca Zulberti.
    
    Ansel is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    Ansel is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "common/conf.h"
#include "common/paths.h"   // DT_PATH_MAX
#include "common/act_on.h"
#include "common/history_actions.h"
#include "gui/common/history_actions_gui.h"
#include "control/jobs/control_jobs.h"
#include "gui/actions/menu.h"
#ifdef __APPLE__
#include "osx/osx.h"   // dt_osx_disallow_fullscreen(), used under GDK_WINDOWING_QUARTZ below
#endif
#include "gui/preferences.h"
#include "common/undo.h"
#include "common/selection.h"
#include "caches/image_cache.h"
#include "history/history.h"
#include "develop/history_merge.h"
#include "gui/develop/history_merge_gui.h"
#include "develop/dev_history.h"
#include "develop/develop.h"
#include "control/control.h"
#include "control/user_message.h"
#include <gtk/gtk.h>
#include <glib.h>
#include "gui/application.h"
#include "widgets/accelerators.h"
#include "common/glib_utils.h"
 
 
MAKE_ACCEL_WRAPPER(dt_gui_preferences_show)
 
static gboolean undo_sensitive_callback()
{
  dt_view_manager_t *const vm = dt_view_manager_get_global();
  if(IS_NULL_PTR(vm)) return FALSE;
  const dt_view_t *cv = dt_view_manager_get_current_view(vm);
  if(IS_NULL_PTR(cv)) return FALSE;
 
  gboolean sensitive = FALSE;
 
  if(!strcmp(cv->module_name, "lighttable"))
    sensitive = dt_is_undo_list_populated(dt_undo_get_global(), DT_UNDO_LIGHTTABLE);
  else if(!strcmp(cv->module_name, "darkroom"))
    sensitive = dt_is_undo_list_populated(dt_undo_get_global(), DT_UNDO_DEVELOP);
  else if(!strcmp(cv->module_name, "darkroom"))
    sensitive = dt_is_undo_list_populated(dt_undo_get_global(), DT_UNDO_MAP);
 
  return sensitive;
}
 
/* Popping a lighttable undo record runs on the GUI thread, and a batch is not cheap: undoing a
 * removal of 984 images took 23 s, measured, with nothing repainting and the application looking
 * hung. Say so before blocking -- the toast is posted and the main loop pumped just enough to
 * paint it -- then let the progress cursor carry the wait, the way every other synchronous
 * GUI-thread operation here does (libs/snapshots.c, libs/duplicate.c, common/iop-autoset.c).
 *
 * Only above a threshold: an ordinary rating change is one record and instant, and announcing
 * that would be noise on every Ctrl+Z. The pump is bounded and happens BEFORE any data is
 * touched, so it cannot re-enter the pop it is announcing. */
#define DT_UNDO_ANNOUNCE_FROM 20
 
static gboolean _undo_announce(const int records, const char *message)
{
  if(records < DT_UNDO_ANNOUNCE_FROM) return FALSE;
 
  dt_control_log("%s", message);
  for(int i = 0; i < 32 && gtk_events_pending(); i++) gtk_main_iteration_do(FALSE);
  dt_control_change_cursor_by_name_and_flush("progress");
  return TRUE;
}
 
static void _undo_announce_end(const gboolean announced)
{
  if(announced) dt_control_commit_cursor();
}
 
static gboolean undo_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  dt_view_manager_t *const vm = dt_view_manager_get_global();
  if(IS_NULL_PTR(vm) || !undo_sensitive_callback()) return FALSE;
  const dt_view_t *cv = dt_view_manager_get_current_view(vm);
  if(IS_NULL_PTR(cv)) return FALSE;
 
  uint32_t filter = 0;
  if(!strcmp(cv->module_name, "lighttable"))    filter = DT_UNDO_LIGHTTABLE;
  else if(!strcmp(cv->module_name, "darkroom")) filter = DT_UNDO_DEVELOP;
  else if(!strcmp(cv->module_name, "map"))      filter = DT_UNDO_MAP;
 
  if(filter)
  {
    const int records = dt_undo_list_length(dt_undo_get_global(), filter);
    const gboolean announced = _undo_announce(records, _("undoing, please wait…"));
    dt_undo_do_undo(dt_undo_get_global(), filter);
    _undo_announce_end(announced);
  }
  // Beware: it needs to block callbacks declared in view, which may not be loaded.
  // Another piece of shitty peculiar design that doesn't comply with the logic of the rest of the soft.
  // That's what you get from ignoring modularity principles.
  // For now we just ignore the peculiar stuff, no idea how annoying it is, seems it's only GUI candy.
 
  return TRUE;
}
 
 
static gboolean redo_sensitive_callback()
{
  dt_view_manager_t *const vm = dt_view_manager_get_global();
  if(IS_NULL_PTR(vm)) return FALSE;
  const dt_view_t *cv = dt_view_manager_get_current_view(vm);
  if(IS_NULL_PTR(cv)) return FALSE;
 
  gboolean sensitive = FALSE;
 
  if(!strcmp(cv->module_name, "lighttable"))
    sensitive = dt_is_redo_list_populated(dt_undo_get_global(), DT_UNDO_LIGHTTABLE);
  else if(!strcmp(cv->module_name, "darkroom"))
    sensitive = dt_is_redo_list_populated(dt_undo_get_global(), DT_UNDO_DEVELOP);
  else if(!strcmp(cv->module_name, "darkroom"))
    sensitive = dt_is_redo_list_populated(dt_undo_get_global(), DT_UNDO_MAP);
 
  return sensitive;
}
 
 
static gboolean redo_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  dt_view_manager_t *const vm = dt_view_manager_get_global();
  if(IS_NULL_PTR(vm) || !redo_sensitive_callback()) return FALSE;
  const dt_view_t *cv = dt_view_manager_get_current_view(vm);
  if(IS_NULL_PTR(cv)) return FALSE;
 
  uint32_t filter = 0;
  if(!strcmp(cv->module_name, "lighttable"))    filter = DT_UNDO_LIGHTTABLE;
  else if(!strcmp(cv->module_name, "darkroom")) filter = DT_UNDO_DEVELOP;
  else if(!strcmp(cv->module_name, "map"))      filter = DT_UNDO_MAP;
 
  if(filter)
  {
    const int records = dt_redo_list_length(dt_undo_get_global(), filter);
    const gboolean announced = _undo_announce(records, _("redoing, please wait…"));
    dt_undo_do_redo(dt_undo_get_global(), filter);
    _undo_announce_end(announced);
  }
  //   see undo_callback()
 
  return TRUE;
}
 
static gboolean compress_history_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  GList *imgs = dt_act_on_get_images();
  if(IS_NULL_PTR(imgs)) return FALSE;
 
  gboolean is_darkroom_image_in_list = dt_dev_history_is_image_in_dev(imgs);
 
  if(is_darkroom_image_in_list)
  {
    dt_develop_t *dev = dt_dev_get_global();
    dt_dev_undo_start_record(dev);
    dt_history_compress_on_image(dev->image_storage.id);
    dt_dev_undo_end_record(dev);
    dt_apply_dev_history_update(dev);
 
    // Avoid running a headless compression for the current darkroom image: the history module
    // (src/libs/history.c) compresses directly from the loaded pipeline.
    imgs = g_list_remove(imgs, GINT_TO_POINTER(dev->image_storage.id));
  }
 
  if(imgs) dt_history_compress_on_list(imgs);
 
  g_list_free(imgs);
  imgs = NULL;
  return TRUE;
}
 
// delete_history_callback() sits in gui/common/history_actions_gui.c rather than here with
// its siblings: it is shared verbatim with the darkroom history module's reset button
// (libs/history.c), so neither menu owns it.
 
static gboolean copy_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  // Allow copy only when exactly one file is selected
  if(dt_selection_get_length(dt_selection_get_global()) != 1)
  {
    dt_control_log(_("Copy is allowed only with exactly one image selected"));
    return FALSE;
  }
 
  GList *imgs = dt_selection_get_list(dt_selection_get_global());
  gboolean is_darkroom_image_in_list = dt_dev_history_is_image_in_dev(imgs);
  g_list_free(imgs);
  imgs = NULL;
 
  if(is_darkroom_image_in_list)
  {
    // Copy/paste reloads the source history from the database right away.
    // Flush the current darkroom history synchronously here so the copied
    // source matches the edit stack currently shown in the GUI.
    dt_dev_write_history(dt_dev_get_global(), FALSE);
  }
 
  dt_history_copy(dt_selection_get_first_id(dt_selection_get_global()));
  return TRUE;
}
 
 
static gboolean copy_parts_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  // Allow copy only when exactly one file is selected
  if(dt_selection_get_length(dt_selection_get_global()) != 1)
  {
    dt_control_log(_("Copy is allowed only with exactly one image selected"));
    return FALSE;
  }
 
  GList *imgs = dt_selection_get_list(dt_selection_get_global());
  gboolean is_darkroom_image_in_list = dt_dev_history_is_image_in_dev(imgs);
  g_list_free(imgs);
  imgs = NULL;
 
  if(is_darkroom_image_in_list)
  {
    // Selective copy opens the same immediate DB read path as full copy.
    // Keep the persisted history in sync with the current darkroom stack
    // before building the copy/paste state from this image.
    dt_dev_write_history(dt_dev_get_global(), FALSE);
  }
 
  dt_history_copy_parts(dt_selection_get_first_id(dt_selection_get_global()));
  return TRUE;
}
 
 
static gboolean paste_sensitive_callback()
{
  return dt_history_copy_paste_get()->copied_imageid > 0;
}
 
static gboolean paste_all_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  if(!paste_sensitive_callback())
  {
    dt_control_log(_("Paste needs selected images to work"));
    return FALSE;
  }
 
  if(dt_conf_get_bool("history/paste/ask"))
  {
    if(!dt_gui_merge_options_dialog(_("Paste history — merge settings"),
                                    "history/paste/mode",
                                    "history/paste/copy_iop_order",
                                    "history/paste/ask",
                                    TRUE))
      return FALSE;
  }
 
  GList *imgs = dt_selection_get_list(dt_selection_get_global());
 
  // We don't allow pasting on darkroom image
  if(dt_dev_history_is_image_in_dev(imgs))
    imgs = g_list_remove(imgs, GINT_TO_POINTER(dt_dev_get_global()->image_storage.id));
 
  if(imgs) dt_history_paste_on_list(imgs);
 
  g_list_free(imgs);
  imgs = NULL;
  return TRUE;
}
 
static gboolean paste_parts_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  if(!paste_sensitive_callback())
  {
    dt_control_log(_("Paste needs selected images to work"));
    return FALSE;
  }
 
  if(dt_conf_get_bool("history/paste/ask"))
  {
    if(!dt_gui_merge_options_dialog(_("Paste history (parts) — merge settings"),
                                    "history/paste/mode",
                                    "history/paste/copy_iop_order",
                                    "history/paste/ask",
                                    TRUE))
      return FALSE;
  }
 
  GList *imgs = dt_selection_get_list(dt_selection_get_global());
 
  if(!dt_history_paste_parts_prepare())
  {
    g_list_free(imgs);
    imgs = NULL;
    return FALSE;
  }
 
  // We don't allow pasting on darkroom image
  if(dt_dev_history_is_image_in_dev(imgs))
    imgs = g_list_remove(imgs, GINT_TO_POINTER(dt_dev_get_global()->image_storage.id));
 
  if(imgs) dt_history_paste_parts_on_list(imgs);
 
  dt_control_queue_redraw_center();
  g_list_free(imgs);
  imgs = NULL;
  return TRUE;
}
 
static gboolean load_xmp_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  // dt_selection_get_list() only sees the lighttable selection, which is typically empty
  // while in darkroom (the menu entry's sensitivity check, has_active_images(), already
  // falls back to the active darkroom image via dt_act_on_get_images_nb() -- fetch the
  // same way here or this silently no-ops in darkroom).
  GList *imgs = dt_act_on_get_images();
  if(IS_NULL_PTR(imgs)) return FALSE;
 
  const int act_on_one = g_list_is_singleton(imgs); // list length == 1?
  GtkWidget *win = dt_gui_main_window();
  GtkFileChooserNative *filechooser = gtk_file_chooser_native_new(
          _("open sidecar file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN,
          _("_open"), _("_cancel"));
  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), FALSE);
 
  if(act_on_one)
  {
    //single image to load xmp to, assume we want to load from same dir
    const int32_t imgid = GPOINTER_TO_INT(imgs->data);
    const dt_image_t *img = dt_image_cache_get(imgid, 'r');
    if(img && img->film_id != -1)
    {
      char pathname[DT_PATH_MAX] = { 0 };
      dt_image_film_roll_directory(img, pathname, sizeof(pathname));
      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), pathname);
    }
    else
    {
      // handle situation where there's some problem with cache/film_id
      // i guess that's impossible, but better safe than sorry ;)
      dt_conf_get_folder_to_file_chooser("ui_last/import_path", GTK_FILE_CHOOSER(filechooser));
    }
    dt_image_cache_read_release(img);
  }
  else
  {
    // multiple images, use "last import" preference
    dt_conf_get_folder_to_file_chooser("ui_last/import_path", GTK_FILE_CHOOSER(filechooser));
  }
 
  GtkFileFilter *filter;
  filter = GTK_FILE_FILTER(gtk_file_filter_new());
  gtk_file_filter_add_pattern(filter, "*.xmp");
  gtk_file_filter_add_pattern(filter, "*.XMP");
  gtk_file_filter_set_name(filter, _("XMP sidecar files"));
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
 
  filter = GTK_FILE_FILTER(gtk_file_filter_new());
  gtk_file_filter_add_pattern(filter, "*");
  gtk_file_filter_set_name(filter, _("all files"));
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
 
  if(gtk_native_dialog_run(GTK_NATIVE_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
  {
    gchar *dtfilename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
    if(dt_history_load_and_apply_on_list(dtfilename, imgs) != 0)
    {
      GtkWidget *dialog
          = gtk_message_dialog_new(GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR,
                                   GTK_BUTTONS_CLOSE, _("error loading file '%s'"), dtfilename);
#ifdef GDK_WINDOWING_QUARTZ
      dt_osx_disallow_fullscreen(dialog);
#endif
      gtk_dialog_run(GTK_DIALOG(dialog));
      gtk_widget_destroy(dialog);
 
    }
    else
    {
      dt_control_queue_redraw_center();
    }
    if(!act_on_one)
    {
      //remember last import path if applying history to multiple images
      dt_conf_set_folder_from_file_chooser("ui_last/import_path", GTK_FILE_CHOOSER(filechooser));
    }
    dt_free(dtfilename);
  }
 
  if(dt_dev_history_is_image_in_dev(imgs))
    dt_apply_dev_history_update(dt_dev_get_global());
 
  g_object_unref(filechooser);
  g_list_free(imgs);
  imgs = NULL;
  return TRUE;
}
 
static gboolean duplicate_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  if(has_active_images())
  {
    GList *imgs = dt_selection_get_list(dt_selection_get_global());
    if(dt_dev_history_is_image_in_dev(imgs))
    {
      // Duplication copies history from the source image into the new version.
      // When the source is the current darkroom image, persist its live history
      // before the background duplicate job reloads it from the database.
      dt_dev_write_history(dt_dev_get_global(), FALSE);
    }
    g_list_free(imgs);
    imgs = NULL;
 
    dt_control_duplicate_images(FALSE);
    return TRUE;
  }
 
  dt_control_log(_("Duplication needs selected images to work"));
  return FALSE;
}
 
static gboolean new_history_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  if(has_active_images())
  {
    GList *imgs = dt_selection_get_list(dt_selection_get_global());
    if(dt_dev_history_is_image_in_dev(imgs))
    {
      // Creating a new duplicate version still starts from the current source
      // image state, so flush the live darkroom history before duplicating it.
      dt_dev_write_history(dt_dev_get_global(), FALSE);
    }
    g_list_free(imgs);
    imgs = NULL;
 
    dt_control_duplicate_images(TRUE);
    return TRUE;
  }
 
  dt_control_log(_("Creating new historys needs selected images to work"));
  return TRUE;
}
 
 
static gboolean shortcuts_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  dt_accels_window(dt_gui_get_accels(), GTK_WINDOW(dt_gui_main_window()));
  return TRUE;
}
 
static gboolean history_append_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_int("history/paste/mode", DT_HISTORY_MERGE_APPEND);
  return TRUE;
}
 
static gboolean history_append_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_int("history/paste/mode") == DT_HISTORY_MERGE_APPEND;
}
 
static gboolean history_prepend_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_int("history/paste/mode", DT_HISTORY_MERGE_PREPEND);
  return TRUE;
}
 
static gboolean history_prepend_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_int("history/paste/mode") == DT_HISTORY_MERGE_PREPEND;
}
 
static gboolean history_replace_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                        GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_int("history/paste/mode", DT_HISTORY_MERGE_REPLACE);
  return TRUE;
}
 
static gboolean history_replace_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_int("history/paste/mode") == DT_HISTORY_MERGE_REPLACE;
}
 
static gboolean copy_iop_order_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_bool("history/paste/copy_iop_order", !dt_conf_get_bool("history/paste/copy_iop_order"));
  return TRUE;
}
 
static gboolean copy_iop_order_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_bool("history/paste/copy_iop_order");
}
 
static gboolean paste_ask_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_bool("history/paste/ask", !dt_conf_get_bool("history/paste/ask"));
  return TRUE;
}
 
static gboolean paste_ask_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_bool("history/paste/ask");
}
 
void append_edit(GtkWidget **menus, GList **lists, const dt_menus_t index)
{
  add_sub_menu_entry(menus, lists, _("Undo"), index, NULL, undo_callback, NULL, NULL, undo_sensitive_callback, GDK_KEY_z, DT_PRIMARY_MASK);
 
  add_sub_menu_entry(menus, lists, _("Redo"), index, NULL, redo_callback, NULL, NULL, redo_sensitive_callback, GDK_KEY_y, DT_PRIMARY_MASK);
 
  add_menu_separator(menus[index]);
 
  add_sub_menu_entry(menus, lists, _("Copy history (all)"), index, NULL, copy_callback, NULL, NULL, has_selection, GDK_KEY_c, DT_PRIMARY_MASK);
 
  add_sub_menu_entry(menus, lists, _("Copy history (parts)..."), index, NULL, copy_parts_callback, NULL, NULL, has_selection, GDK_KEY_c, DT_PRIMARY_MASK | GDK_SHIFT_MASK);
 
  add_sub_menu_entry(menus, lists, _("Paste history (all)"), index, NULL, paste_all_callback, NULL, NULL,
                     paste_sensitive_callback, GDK_KEY_v, DT_PRIMARY_MASK);
 
  add_sub_menu_entry(menus, lists, _("Paste history (parts)..."), index, NULL, paste_parts_callback, NULL, NULL,
                     paste_sensitive_callback, GDK_KEY_v, DT_PRIMARY_MASK | GDK_SHIFT_MASK);
 
  add_menu_separator(menus[index]);
 
  // History merging options
 
  add_top_submenu_entry(menus, lists, _("History pasting mode"), index);
  GtkWidget *parent = get_last_widget(lists);
 
  add_sub_sub_menu_entry(menus, parent, lists, _("Prepend"), index, NULL,
                         history_prepend_callback, history_prepend_checked_callback, NULL, NULL, 0, 0);
  gtk_widget_set_tooltip_text(get_last_widget(lists),
                              _("Paste copied history BEFORE the current history.\n"
                                "CURRENT EDITS are applied afterwards and win conflicts."));
 
  add_sub_sub_menu_entry(menus, parent, lists, _("Append"), index, NULL,
                         history_append_callback, history_append_checked_callback, NULL, NULL, 0, 0);
  gtk_widget_set_tooltip_text(get_last_widget(lists),
                              _("Paste copied history AFTER the current history.\n"
                                "COPIED EDITS are applied afterwards and win conflicts."));
 
  add_sub_sub_menu_entry(menus, parent, lists, _("Replace"), index, NULL,
                         history_replace_callback, history_replace_checked_callback, NULL, NULL, 0, 0);
  gtk_widget_set_tooltip_text(get_last_widget(lists),
                              _("Discard the current history and replace it entirely with the copied history."));
 
  add_top_submenu_entry(menus, lists, _("Nodes pasting mode"), index);
  parent = get_last_widget(lists);
 
  add_sub_sub_menu_entry(menus, parent, lists, _("Copy module order"), index, NULL,
                         copy_iop_order_callback, copy_iop_order_checked_callback, NULL, NULL, 0, 0);
 
  add_sub_menu_entry(menus, lists, _("Ask merge settings before paste"), index, NULL,
                     paste_ask_callback, paste_ask_checked_callback, NULL, NULL, 0, 0);
 
  add_menu_separator(menus[index]);
 
  add_sub_menu_entry(menus, lists, _("Load history from XMP..."), index, NULL,
                     load_xmp_callback, NULL, NULL, has_active_images, 0, 0);
 
  add_sub_menu_entry(menus, lists, _("Create new history"), index, NULL,
                    new_history_callback, NULL, NULL, has_active_images, GDK_KEY_n, DT_PRIMARY_MASK);
 
  add_sub_menu_entry(menus, lists, _("Duplicate existing history"), index, NULL,
                     duplicate_callback, NULL, NULL, has_active_images, GDK_KEY_d, DT_PRIMARY_MASK);
 
  add_sub_menu_entry(menus, lists, _("Compress history"), index, NULL,
                     compress_history_callback, NULL, NULL, has_active_images, 0, 0);
 
  add_sub_menu_entry(menus, lists, _("Delete history"), index, NULL,
                     delete_history_callback, NULL, NULL, has_active_images, 0, 0);
 
  add_menu_separator(menus[index]);
 
  add_sub_menu_entry(menus, lists, _("Preferences..."), index, NULL, GET_ACCEL_WRAPPER(dt_gui_preferences_show), NULL, NULL, NULL, 0, 0);
  add_sub_menu_entry(menus, lists, _("Keyboard shortcuts..."), index, NULL, shortcuts_callback, NULL, NULL, NULL, 0, 0);
}