accelerators.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2011-2013, 2015 Jérémy Rosen.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2012 Henrik Andersson.
    Copyright (C) 2012 johannes hanika.
    Copyright (C) 2012 Moritz Lipp.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012, 2014-2017, 2020 Tobias Ellinghaus.
    Copyright (C) 2012-2013 Ulrich Pegelow.
    Copyright (C) 2013, 2016, 2020-2022 Pascal Obry.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2013 Yari Adan.
    Copyright (C) 2019-2020, 2022 Aldric Renaudin.
    Copyright (C) 2019 Diederik ter Rahe.
    Copyright (C) 2019 Philippe Weyland.
    Copyright (C) 2020-2021 Chris Elston.
    Copyright (C) 2020-2022 Diederik Ter Rahe.
    Copyright (C) 2020 Heiko Bauke.
    Copyright (C) 2020-2021 Hubert Kowalski.
    Copyright (C) 2020 Marco.
    Copyright (C) 2021 Marco Carrarini.
    Copyright (C) 2021 Mark-64.
    Copyright (C) 2021 Ralf Brown.
    Copyright (C) 2021 Victor Forsiuk.
    Copyright (C) 2022-2023, 2025 Aurélien PIERRE.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Miloš Komarčević.
    Copyright (C) 2023 Luca Zulberti.
    Copyright (C) 2026 Guillaume Stutin.
    
    darktable 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.
    
    darktable 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 darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "widgets/accelerators.h"
 
#include <glib/gi18n.h>
#include "widgets/widget_settings.h"
#include "widgets/widget_style.h"
#include "system/macros.h"
#include "system/mem_alloc.h"
#include "widgets/gtkentry.h"
#include "widgets/gdkkeys.h"
#include "widgets/icon_cell_renderer.h"
 
/* ------------------------------------------------------------------------------------------
 * Host hooks (see accelerators.h). Each is optional and inert when unregistered.
 * ------------------------------------------------------------------------------------------ */
static dt_accels_t *_accels_global = NULL;
static dt_accels_top_offset_handler_t _top_offset_handler = NULL;
static dt_accels_refocus_handler_t _refocus_handler = NULL;
static dt_accels_recent_get_handler_t _recent_get = NULL;
static dt_accels_recent_set_handler_t _recent_set = NULL;
 
void dt_accels_set_global(dt_accels_t *accels)
{
  _accels_global = accels;
}
 
dt_accels_t *dt_accels_get_global(void)
{
  return _accels_global;
}
 
void dt_accels_set_top_offset_handler(dt_accels_top_offset_handler_t handler)
{
  _top_offset_handler = handler;
}
 
void dt_accels_set_refocus_handler(dt_accels_refocus_handler_t handler)
{
  _refocus_handler = handler;
}
 
void dt_accels_set_recent_handlers(dt_accels_recent_get_handler_t get,
                                   dt_accels_recent_set_handler_t set)
{
  _recent_get = get;
  _recent_set = set;
}
 
#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif
 
#include <assert.h>
#include <glib.h>
 
// Separator used to space between query and command in accels search
#define DT_ACCEL_SEARCH_INLINE_SEPARATOR "    >  "
#define DT_ACCEL_SEARCH_DISPATCH_RETRY_DELAY_MS 50
 
typedef struct {
  GClosure  *base;
  gpointer  parent_data; // Reference to the closure->data of the parent shortcut instance, if any
  /* The widget this closure acts on, or NULL when it acts on something that is not a widget.
   *
   * This used to be recovered by asking `GTK_IS_WIDGET(base->data)`, which is undefined: `base->data`
   * is whatever the registering caller passed as its callback payload, and that is a GtkWidget for
   * menu entries and toolbox buttons but a `dt_shortcut_t *`, a `dt_lib_module_t *` or a
   * `dt_iop_module_t *` everywhere else. GLib's type check reads `((GTypeInstance *)p)->g_class` and
   * then dereferences THAT as a class, so on a non-GObject it walks whatever the struct's first field
   * happens to hold -- `dt_shortcut_t` opens with a `GtkWidget *`, the module structs with a
   * `GList *`. It answered FALSE by luck as long as the walk stayed inside mapped memory, and
   * segfaulted when it did not (Sentry 131420071 / 129371422). A pointer's type is known where it is
   * registered and nowhere else, so it is recorded here instead of guessed later. */
  GtkWidget *widget;
} PayloadClosure;
 
typedef struct _accel_removal_t
{
  const char *path;
  gpointer data;
} _accel_removal_t;
 
 
static void _g_list_closure_unref(gpointer data)
{
  PayloadClosure *pc = (PayloadClosure *)data;
  if(pc->base) g_closure_unref(pc->base);
  /* The weak pointer must go before the struct holding it does, or the widget's eventual destruction
   * writes NULL into freed memory. */
  if(pc->widget) g_object_remove_weak_pointer(G_OBJECT(pc->widget), (gpointer *)&pc->widget);
  dt_free(pc);
}
 
static inline void _shortcut_set_widget_data(GtkWidget *widget, dt_shortcut_t *shortcut)
{
  if(IS_NULL_PTR(widget)) return;
  g_object_set_data(G_OBJECT(widget), DT_ACCELS_WIDGET_SHORTCUT_KEY, shortcut);
  if(!g_object_get_data(G_OBJECT(widget), DT_ACCELS_WIDGET_TOOLTIP_DISABLED_KEY))
    gtk_widget_set_has_tooltip(widget, TRUE);
}
 
static gboolean _accels_tooltip_query_hook(GSignalInvocationHint *hint, guint n_param_values,
                                           const GValue *param_values, gpointer data)
{
  (void)hint;
  (void)data;
  if(n_param_values < 5) return TRUE;
 
  GtkWidget *widget = g_value_get_object(&param_values[0]);
  if(IS_NULL_PTR(widget)) return TRUE;
 
  if(!gtk_widget_get_has_tooltip(widget)) return TRUE;
  if(g_object_get_data(G_OBJECT(widget), DT_ACCELS_WIDGET_TOOLTIP_DISABLED_KEY)) return TRUE;
 
  const char *base_markup = g_object_get_data(G_OBJECT(widget), "dt-accel-tooltip-base-markup");
  const char *base_text = base_markup ? NULL : g_object_get_data(G_OBJECT(widget), "dt-accel-tooltip-base-text");
  const gboolean base_none = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "dt-accel-tooltip-base-none"));
 
  if(IS_NULL_PTR(base_markup) && IS_NULL_PTR(base_text) && !base_none)
  {
    gchar *current_markup = gtk_widget_get_tooltip_markup(widget);
    if(current_markup && current_markup[0])
    {
      g_object_set_data_full(G_OBJECT(widget), "dt-accel-tooltip-base-markup", current_markup, g_free);
      base_markup = current_markup;
    }
    else
    {
      dt_free(current_markup);
      gchar *current_text = gtk_widget_get_tooltip_text(widget);
      if(current_text && current_text[0])
      {
        g_object_set_data_full(G_OBJECT(widget), "dt-accel-tooltip-base-text", current_text, g_free);
        base_text = current_text;
      }
      else
      {
        dt_free(current_text);
        g_object_set_data(G_OBJECT(widget), "dt-accel-tooltip-base-none", GINT_TO_POINTER(1));
      }
    }
  }
 
  dt_shortcut_t *shortcut = g_object_get_data(G_OBJECT(widget), DT_ACCELS_WIDGET_SHORTCUT_KEY);
  if(IS_NULL_PTR(shortcut))
  {
    const char *accel_path = g_object_get_data(G_OBJECT(widget), "accel-path");
    if(accel_path && dt_accels_get_global())
    {
      dt_accels_t *accels = dt_accels_get_global();
      dt_pthread_mutex_lock(&accels->lock);
      shortcut = (dt_shortcut_t *)g_hash_table_lookup(accels->acceleratables, accel_path);
      dt_pthread_mutex_unlock(&accels->lock);
    }
  }
 
  if(IS_NULL_PTR(shortcut) || shortcut->key == 0)
  {
    if(base_markup)
      gtk_widget_set_tooltip_markup(widget, base_markup);
    else if(base_text)
      gtk_widget_set_tooltip_text(widget, base_text);
    return TRUE;
  }
 
  gchar *shortcut_label = gtk_accelerator_get_label(shortcut->key, dt_accels_display_mods(shortcut->mods));
  if(IS_NULL_PTR(shortcut_label) || !shortcut_label[0])
  {
    dt_free(shortcut_label);
    return TRUE;
  }
 
  const char *shortcut_desc = (shortcut->description && shortcut->description[0]) ? shortcut->description : _("Shortcut");
  if(base_markup && base_markup[0])
  {
    gchar *esc_label = g_markup_escape_text(shortcut_label, -1);
    gchar *esc_desc = g_markup_escape_text(shortcut_desc, -1);
    gchar *new_markup = g_strdup_printf("%s\n<small>%s: %s</small>", base_markup, esc_desc, esc_label);
    gtk_widget_set_tooltip_markup(widget, new_markup);
    dt_free(new_markup);
    dt_free(esc_label);
    dt_free(esc_desc);
  }
  else if(base_text && base_text[0])
  {
    gchar *new_text = g_strdup_printf("%s\n%s: %s", base_text, shortcut_desc, shortcut_label);
    gtk_widget_set_tooltip_text(widget, new_text);
    dt_free(new_text);
  }
  else
  {
    gchar *new_text = g_strdup_printf("%s: %s", shortcut_desc, shortcut_label);
    gtk_widget_set_tooltip_text(widget, new_text);
    dt_free(new_text);
  }
 
  dt_free(shortcut_label);
 
  return TRUE;
}
 
static void _accels_install_tooltip_hook(void)
{
  static gulong hook_id = 0;
  if(hook_id != 0) return;
 
  const guint signal_id = g_signal_lookup("query-tooltip", GTK_TYPE_WIDGET);
  if(signal_id == 0) return;
 
  hook_id = g_signal_add_emission_hook(signal_id, 0, _accels_tooltip_query_hook, NULL, NULL);
}
 
 
static void _clean_shortcut(gpointer data)
{
  dt_shortcut_t *shortcut = (dt_shortcut_t *)data;
  dt_free(shortcut->path);
  g_list_free_full(shortcut->closure, _g_list_closure_unref);
  shortcut->closure = NULL;
  dt_free(shortcut);
}
 
 
// Return the last closure in the list
PayloadClosure *dt_shortcut_get_payload_closure(dt_shortcut_t *shortcut)
{
  GList *link = g_list_last(shortcut->closure);
  if(link)
    return (PayloadClosure *)link->data;
  else
    return NULL;
}
 
GClosure *dt_shortcut_get_closure(dt_shortcut_t *shortcut)
{
  PayloadClosure *pc = dt_shortcut_get_payload_closure(shortcut);
  if(pc)
    return pc->base;
  else
    return NULL;
}
 
 
// Remove the accel closure instance from shortcut that references data
// as its input or as its parent. Useful when module instances are destroyed,
// so we destroy the shortcut attached to the parent module, and the shortcut
// attached to all its children.
void dt_shortcut_remove_closure(dt_shortcut_t *shortcut, gpointer data)
{
  if(IS_NULL_PTR(shortcut->closure)) return;
 
  PayloadClosure *cl = NULL;
  GList *link = NULL;
 
  if(data)
  {
    // Look for closures referencing data in their direct closure args
    for(link = g_list_first(shortcut->closure); link; link = g_list_next(link))
    {
      PayloadClosure *closure = (PayloadClosure *)link->data;
      if(closure->base->data == data || closure->parent_data == data)
      {
        cl = closure;
        break;
      }
    }
  }
  else
  {
    link = g_list_last(shortcut->closure);
    if(link) cl = (PayloadClosure *)link->data;
  }
 
  if(cl)
  {
    /* Unlink first, then release through the SAME function the list's own destroy notify uses.
     * This used to unref the closure and dt_free() the struct inline, which skipped
     * g_object_remove_weak_pointer(): the weak pointer registered in dt_shortcut_set_closure()
     * records the address &pc->widget, so leaving it behind means the widget's eventual
     * destruction writes NULL into a freed PayloadClosure. That is heap corruption, and it
     * aborts wherever the next allocation lands rather than here -- at startup, in the sqlite3
     * call under dt_iop_load_modules_so(), because _init_module_so() builds and immediately
     * destroys a throwaway GUI instance for every module, which is precisely what this function
     * is called for. */
    shortcut->closure = g_list_delete_link(shortcut->closure, link);
    _g_list_closure_unref(cl);
    // fprintf(stdout, "removing: %s at %p - %i entries remaining\n", shortcut->path, data, g_list_length(shortcut->closure));
  }
}
 
 
static void _find_parent_hashtable(gpointer _key, gpointer value, gpointer user_data)
{
  dt_shortcut_t *parent_shortcut = (dt_shortcut_t *)value;
  dt_shortcut_t *child_shortcut = (dt_shortcut_t *)user_data;
 
  // Remove the last branch of the path to build the path of the immediate ancestor
  gchar **child_parts = g_strsplit(child_shortcut->path, "/", -1);
  guint n = g_strv_length(child_parts);
  dt_free(child_parts[n - 1]);
  gchar *parent_path = g_strjoinv ("/", child_parts);
  g_strfreev(child_parts);
 
  // This should technically match only once in the HashTable for_each()
  if(!g_strcmp0(parent_shortcut->path, parent_path))
  {
    GClosure *parent_closure = dt_shortcut_get_closure(parent_shortcut);
    PayloadClosure *child_closure = dt_shortcut_get_payload_closure(child_shortcut);
    if(parent_closure && child_closure)
      child_closure->parent_data = parent_closure->data;
 
    /*
    fprintf(stdout, "%s is the parent of %s - pointer %p\n", parent_shortcut->path, child_shortcut->path,
            parent_closure->data);
    */
  }
 
  dt_free(parent_path);
}
 
 
// Lookup all existing shortcuts that share their path root with this one,
// Consider them as parent of this one,
// write this one into their (dt_shortcut_t *)->children table.
// This assumes that parents are declared before children, which makes sense for widgets.
static void _insert_parent_data_into_children(dt_shortcut_t *shortcut)
{
  g_hash_table_foreach(shortcut->accels->acceleratables, _find_parent_hashtable, (gpointer)shortcut);
}
 
 
// Append a new closure in the list
void dt_shortcut_set_closure(dt_shortcut_t *shortcut,
                             gboolean (*action_callback)(GtkAccelGroup *group, GObject *acceleratable,
                                                         guint keyval, GdkModifierType mods, gpointer user_data),
                             gpointer data, GtkWidget *widget)
{
  PayloadClosure *pc = malloc(sizeof(PayloadClosure));
  pc->base = g_cclosure_new(G_CALLBACK(action_callback), data, NULL);
  pc->parent_data = NULL;
  /* Weak, so a widget destroyed while its closure is still listed reads back as NULL rather than as a
   * dangling pointer the dispatcher would hand to GTK. Rebuilding the accel table on a view or module
   * switch is exactly when that happens. */
  pc->widget = widget;
  if(pc->widget) g_object_add_weak_pointer(G_OBJECT(pc->widget), (gpointer *)&pc->widget);
 
  g_closure_set_marshal(pc->base, g_cclosure_marshal_generic);
  g_closure_ref(pc->base);
  g_closure_sink(pc->base);
  shortcut->closure = g_list_append(shortcut->closure, pc);
  // fprintf(stdout, "appending closure for %s - %i entries\n", shortcut->path, g_list_length(shortcut->closure));
  _insert_parent_data_into_children(shortcut);
}
 
 
dt_accels_t * dt_accels_init(char *config_file, GtkAccelFlags flags)
{
  dt_accels_t *accels = malloc(sizeof(dt_accels_t));
  accels->config_file = g_strdup(config_file);
  accels->global_accels = gtk_accel_group_new();
  accels->darkroom_accels = gtk_accel_group_new();
  accels->lighttable_accels = gtk_accel_group_new();
  accels->map_accels = gtk_accel_group_new();
  accels->print_accels = gtk_accel_group_new();
  accels->slideshow_accels = gtk_accel_group_new();
  accels->acceleratables = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, _clean_shortcut);
  accels->active_group = NULL;
  accels->reset = 1;
  accels->keymap = gdk_keymap_get_for_display(gdk_display_get_default());
  accels->default_mod_mask = gtk_accelerator_get_default_mod_mask();
  accels->init = !g_file_test(accels->config_file, G_FILE_TEST_EXISTS);
  accels->active_key.accel_flags = 0;
  accels->active_key.accel_key = 0;
  accels->active_key.accel_mods = 0;
  accels->scroll.callback = NULL;
  accels->scroll.data = NULL;
  accels->disable_accels = FALSE;
  accels->flags = flags;
  dt_pthread_mutex_init(&accels->lock, NULL);
  _accels_install_tooltip_hook();
  return accels;
}
 
 
void dt_accels_cleanup(dt_accels_t *accels)
{
  gtk_accel_map_save(accels->config_file);
 
  accels->active_group = NULL;
 
  g_object_unref(accels->global_accels);
  g_object_unref(accels->darkroom_accels);
  g_object_unref(accels->lighttable_accels);
  g_object_unref(accels->map_accels);
  g_object_unref(accels->print_accels);
  g_object_unref(accels->slideshow_accels);
  accels->global_accels = NULL;
  accels->darkroom_accels = NULL;
  accels->lighttable_accels = NULL;
  accels->map_accels = NULL;
  accels->print_accels = NULL;
  accels->slideshow_accels = NULL;
 
  dt_pthread_mutex_lock(&accels->lock);
  g_hash_table_unref(accels->acceleratables);
  dt_pthread_mutex_unlock(&accels->lock);
 
  dt_pthread_mutex_destroy(&accels->lock);
 
  dt_free(accels->config_file);
  dt_free(accels);
}
 
 
void dt_accels_connect_active_group(dt_accels_t *accels, const gchar *group)
{
  if(IS_NULL_PTR(accels)) return;
 
  if(!g_strcmp0(group, "lighttable") && accels->lighttable_accels)
  {
    accels->reset--;
    accels->active_group = accels->lighttable_accels;
  }
  else if(!g_strcmp0(group, "darkroom") && accels->darkroom_accels)
  {
    accels->reset--;
    accels->active_group = accels->darkroom_accels;
  }
  else if(!g_strcmp0(group, "map") && accels->map_accels)
  {
    accels->reset--;
    accels->active_group = accels->map_accels;
  }
  else if(!g_strcmp0(group, "print") && accels->print_accels)
  {
    accels->reset--;
    accels->active_group = accels->print_accels;
  }
  else if(!g_strcmp0(group, "slideshow") && accels->slideshow_accels)
  {
    accels->reset--;
    accels->active_group = accels->slideshow_accels;
  }
  else
  {
    fprintf(stderr, "[dt_accels_connect_active_group] INFO: unknown value: `%s'\n", group);
  }
}
 
 
void dt_accels_disconnect_active_group(dt_accels_t *accels)
{
  if(IS_NULL_PTR(accels)) return;
  accels->active_group = NULL;
  accels->reset++;
}
 
 
// Whether a keyboardrc entry is recognized as "still at default" is decided purely by GTK's
// own accelerator-string round-trip, not by comparing raw GdkModifierType bits here: a
// shortcut registered with DT_PRIMARY_MASK is saved via gtk_accel_map_save() as the portable
// "<Primary>" token whenever the live value equals this platform's own
// gtk_accelerator_get_default_mod_mask()-relevant primary bit (GDK_CONTROL_MASK on X11/Win32,
// GDK_MOD2_MASK on Quartz -- see _gtk_get_primary_accel_mod() in GTK's own gtkprivate.c), and
// gtk_accel_map_load() resolves that same token back to whichever bit is native on the
// platform actually running -- transparently migrating an old or foreign-platform save.
// A shortcut deliberately rebound to the literal Ctrl key on Quartz saves as the literal
// "<Control>" token instead, and must never be reinterpreted as the Cmd default: comparing
// only the resolved numeric values here, with no extra fuzzy-matching layer, is what lets a
// real user override survive intact.
static gboolean _update_shortcut_state(dt_shortcut_t *shortcut, GtkAccelKey *key, gboolean init)
{
  gboolean changed = FALSE;
  if(shortcut->type == DT_SHORTCUT_UNSET)
  {
    // accel_map table is initially populated with shortcut->type = DT_SHORTCUT_UNSET
    // so that means the entry is new
    if(init || shortcut->locked)
    {
      // We have no user config file, or the shortcut is locked by the app.
      // Both ways, init shortcuts with defaults,
      // then a brand new config will be saved on exiting the app.
      // Note: they might still be zero, not all shortcuts are assigned.
      key->accel_key = shortcut->key;
      key->accel_mods = shortcut->mods;
      gtk_accel_map_change_entry(shortcut->path, shortcut->key, shortcut->mods, TRUE);
      shortcut->type = DT_SHORTCUT_DEFAULT;
    }
    else if(key->accel_key == shortcut->key && key->accel_mods == shortcut->mods)
    {
      // We loaded user config file and found our defaults in it. Nothing to do.
      shortcut->type = DT_SHORTCUT_DEFAULT;
    }
    else
    {
      // We loaded user config file, and user made changes in there.
      // We will need to update our "defaults", which now become rather a memory of previous state.
      // A path the config never mentioned cannot land here anymore: _insert_accel() seeds the
      // accel_map entry with this shortcut's own default, so an absent path arrives equal to it
      // and takes the branch above. Reaching this one means the file really did say something else.
      shortcut->key = key->accel_key;
      shortcut->mods = key->accel_mods;
      shortcut->type = DT_SHORTCUT_USER;
    }
 
    // UNSET state always needs update, it means it's the first time we connect accels
    changed = TRUE;
  }
  else if(shortcut->locked && (key->accel_key != shortcut->key || key->accel_mods != shortcut->mods))
  {
    // Something changed a locked shortcut. Revert to defaults.
    key->accel_key = shortcut->key;
    key->accel_mods = shortcut->mods;
    gtk_accel_map_change_entry(shortcut->path, shortcut->key, shortcut->mods, TRUE);
    shortcut->type = DT_SHORTCUT_DEFAULT;
    changed = TRUE;
  }
  else if(key->accel_key != shortcut->key || key->accel_mods != shortcut->mods)
  {
    shortcut->key = key->accel_key;
    shortcut->mods = key->accel_mods;
    shortcut->type = DT_SHORTCUT_USER;
    changed = TRUE;
  }
 
  return changed;
}
 
static void _add_widget_accel(dt_shortcut_t *shortcut, GtkAccelFlags flags)
{
  gtk_widget_add_accelerator(shortcut->widget, shortcut->signal, shortcut->accel_group, shortcut->key,
                             shortcut->mods, flags);
 
  // Numpad numbers register as different keys. Find the numpad equivalent key here, if any.
  guint alt_char = dt_keys_numpad_alternatives(shortcut->key);
  if(shortcut->key != alt_char)
    gtk_widget_add_accelerator(shortcut->widget, shortcut->signal, shortcut->accel_group, alt_char, shortcut->mods,
                               flags);
}
 
 
static void _remove_widget_accel(dt_shortcut_t *shortcut, const GtkAccelKey *old_key)
{
  gtk_widget_remove_accelerator(shortcut->widget, shortcut->accel_group, old_key->accel_key, old_key->accel_mods);
 
  // Numpad numbers register as different keys. Find the numpad equivalent key here, if any.
  guint alt_char = dt_keys_numpad_alternatives(old_key->accel_key);
  if(old_key->accel_key != alt_char)
    gtk_widget_remove_accelerator(shortcut->widget, shortcut->accel_group, alt_char, old_key->accel_mods);
}
 
 
static void _remove_generic_accel(dt_shortcut_t *shortcut)
{
  // Need to increase the number of references to avoid loosing the closure just yet.
  GClosure *cl = dt_shortcut_get_closure(shortcut);
  if(IS_NULL_PTR(cl)) return;
  g_closure_ref(cl);
  g_closure_sink(cl);
  gtk_accel_group_disconnect(shortcut->accel_group, cl);
  g_closure_unref(cl);
}
 
 
static void _add_generic_accel(dt_shortcut_t *shortcut, GtkAccelFlags flags)
{
  GClosure *closure = dt_shortcut_get_closure(shortcut);
  if(closure)
    gtk_accel_group_connect(shortcut->accel_group, shortcut->key, shortcut->mods, flags | GTK_ACCEL_VISIBLE, closure);
}
 
 
static void _connect_accel(dt_shortcut_t *shortcut);
 
static void _insert_accel(dt_accels_t *accels, dt_shortcut_t *shortcut)
{
  // Register the app default as the accel_map entry's OWN default, not as an entry with no
  // keys. Both spellings let the user config win -- gtk_accel_map_add_entry() only sets the
  // current value when it creates the entry, and gtk_accel_map_load() has already run by now
  // (see gui/application.c), so a path the user config knows about keeps whatever that file
  // said. The difference is what happens to a path the config does NOT know about, and with
  // (0, 0) that case was indistinguishable from a shortcut the user had cleared: the entry
  // came back with key 0, _update_shortcut_state() compared it against a non-zero app default,
  // concluded "the user changed this" and recorded the shortcut as permanently unbound. Every
  // newly added default shortcut was therefore born dead for anyone with an existing config.
  //
  // Accel pathes are built from TRANSLATED menu labels (that is why the config file is
  // localized), so the same happens when a label's translation lands or changes: the shortcut
  // is looked up under a path that config has never seen. That is how F5 stopped applying the
  // purple label in French -- the fr catalogue gained "Violet" for a menu entry that used to
  // fall back to the English "Purple", and the F5 saved under the old path was orphaned.
  //
  // Passing the default here also makes GTK's own changed/unchanged bookkeeping mean what we
  // need on the way out: gtk_accel_map_save() comments out an entry that still sits at its
  // default and writes the others verbatim, so a shortcut the user cleared is saved as a real
  // (path "") line and is read back as a known path with key 0 -- still cleared, this time
  // because the file says so rather than because the file is silent.
  //
  // One-time cost of the change: a config written by an older build recorded a cleared default
  // shortcut as a commented line, which reads back as "unknown path", so such a shortcut is
  // restored to its default once. It is then saved under the new spelling and stays cleared
  // from there on.
  gtk_accel_map_add_entry(shortcut->path, shortcut->key, shortcut->mods);
  dt_pthread_mutex_lock(&accels->lock);
  g_hash_table_insert(accels->acceleratables, shortcut->path, shortcut);
 
  // dt_accels_load_user_config() now runs before any widget/menu is built (see
  // gui/application.c), so the user's saved keys are already in the GtkAccelMap by this
  // point -- reconcile right away instead of waiting for the next dt_accels_connect_accels()
  // pass. A GtkAccelLabel reads the accel map once, when gtk_widget_set_accel_path() is
  // called just after this (e.g. gui/actions/menu.c's set_menu_entry()); if that read still
  // sees the raw, unreconciled value, the menu's displayed shortcut is stuck showing it even
  // after a later pass corrects the live dt_shortcut_t. Done under the same lock every other
  // caller of _connect_accel() (dt_accels_connect_accels()'s g_hash_table_foreach) already
  // holds it under.
  _connect_accel(shortcut);
  dt_pthread_mutex_unlock(&accels->lock);
}
 
 
// Since accel groups are no longer attached to any GtkWindow (see dt_accels_dispatch,
// which handles everything internally to avoid the crashes from issue #484), a plain
// widget+signal shortcut needs its own closure too, or the internal dispatcher has
// nothing to invoke: gtk_widget_add_accelerator() alone is a dead end here.
static gboolean _widget_shortcut_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                          GdkModifierType mods, gpointer user_data)
{
  dt_shortcut_t *shortcut = (dt_shortcut_t *)user_data;
  if(IS_NULL_PTR(shortcut->widget) || IS_NULL_PTR(shortcut->signal)) return FALSE;
  g_signal_emit_by_name(shortcut->widget, shortcut->signal);
  return TRUE;
}
 
 
static gboolean _virtual_shortcut_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                       GdkModifierType mods, gpointer user_data)
{
  dt_shortcut_t *shortcut = (dt_shortcut_t *)user_data;
  if(IS_NULL_PTR(shortcut->widget)) return FALSE;
 
  // Focus the target widget
  gtk_widget_grab_focus(shortcut->widget);
 
  // Hardware-decode the shortcut key
  guint keycode = 0;
  GdkKeymapKey *keys = NULL;
  gint n = 0;
  GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
  if(gdk_keymap_get_entries_for_keyval(keymap, shortcut->key, &keys, &n))
  {
    if(n > 0) keycode = keys[0].keycode;
    dt_free(keys);
  }
 
  // Create a virtual key stroke using our shortcut keys
  GdkEvent *ev = gdk_event_new(GDK_KEY_PRESS);
  ev->key.window = g_object_ref(gtk_widget_get_window(shortcut->widget));
  ev->key.send_event = TRUE;
  ev->key.time = GDK_CURRENT_TIME;
  ev->key.state = shortcut->mods;
  ev->key.keyval = shortcut->key;
  ev->key.hardware_keycode = keycode;
  ev->key.group = 0;
  ev->key.is_modifier = FALSE;
 
  // Fire the virtual keystroke to the target widget
  gtk_widget_event(shortcut->widget, ev);
  gdk_event_free(ev);
 
  return TRUE;
}
 
 
void dt_accels_new_virtual_shortcut(dt_accels_t *accels, GtkAccelGroup *accel_group, const gchar *accel_path,
                                    GtkWidget *widget, guint key_val, GdkModifierType accel_mods)
{
  // Our own circuitery to keep track of things after user-defined shortcuts are updated
  dt_pthread_mutex_lock(&accels->lock);
  dt_shortcut_t *shortcut = (dt_shortcut_t *)g_hash_table_lookup(accels->acceleratables, accel_path);
  dt_pthread_mutex_unlock(&accels->lock);
 
  if(shortcut && shortcut->widget == widget)
  {
    _shortcut_set_widget_data(widget, shortcut);
    return;
  }
 
  if(IS_NULL_PTR(shortcut))
  {
    shortcut = malloc(sizeof(dt_shortcut_t));
    shortcut->accel_group = accel_group;
    shortcut->widget = widget;
    shortcut->closure = NULL;
    shortcut->path = g_strdup(accel_path);
    shortcut->signal = NULL;
    shortcut->key = key_val;
    shortcut->mods = accel_mods;
    shortcut->type = DT_SHORTCUT_UNSET;
    shortcut->locked = TRUE;
    shortcut->virtual_shortcut = TRUE;
    shortcut->description = _("Contextual interaction on focus");
    shortcut->accels = accels;
    dt_shortcut_set_closure(shortcut, _virtual_shortcut_callback, shortcut, widget);
    _insert_accel(accels, shortcut);
    _shortcut_set_widget_data(widget, shortcut);
  }
}
 
void dt_accels_new_virtual_instance_shortcut(dt_accels_t *accels,
                                             gboolean (*action_callback)(GtkAccelGroup *group,
                                                                         GObject *acceleratable, guint keyval,
                                                                         GdkModifierType mods, gpointer user_data),
                                             gpointer data, GtkAccelGroup *accel_group, const gchar *action_scope,
                                             const gchar *action_name)
{
  gchar *accel_path = dt_accels_build_path(action_scope, action_name);
 
  // Our own circuitery to keep track of things after user-defined shortcuts are updated
  dt_pthread_mutex_lock(&accels->lock);
  dt_shortcut_t *shortcut = (dt_shortcut_t *)g_hash_table_lookup(accels->acceleratables, accel_path);
  dt_pthread_mutex_unlock(&accels->lock);
 
  if(IS_NULL_PTR(shortcut))
  {
    shortcut = malloc(sizeof(dt_shortcut_t));
    shortcut->accel_group = accel_group;
    shortcut->widget = NULL;
    shortcut->closure = NULL;
    shortcut->path = g_strdup(accel_path);
    shortcut->signal = NULL;
    shortcut->key = 0;
    shortcut->mods = 0;
    shortcut->type = DT_SHORTCUT_DEFAULT;
    shortcut->locked = TRUE;
    shortcut->virtual_shortcut = TRUE;
    shortcut->description = _("Focuses the instance");
    shortcut->accels = accels;
    dt_shortcut_set_closure(shortcut, action_callback, data, NULL);
 
    dt_pthread_mutex_lock(&accels->lock);
    g_hash_table_insert(accels->acceleratables, shortcut->path, shortcut);
    dt_pthread_mutex_unlock(&accels->lock);
  }
 
  dt_free(accel_path);
}
 
 
void dt_accels_new_widget_shortcut(dt_accels_t *accels, GtkWidget *widget, const gchar *signal,
                                   GtkAccelGroup *accel_group, const gchar *accel_path, guint key_val,
                                   GdkModifierType accel_mods, const gboolean lock)
{
  // Our own circuitery to keep track of things after user-defined shortcuts are updated
  dt_pthread_mutex_lock(&accels->lock);
  dt_shortcut_t *shortcut = (dt_shortcut_t *)g_hash_table_lookup(accels->acceleratables, accel_path);
  dt_pthread_mutex_unlock(&accels->lock);
 
  if(shortcut && shortcut->widget == widget)
  {
    // reference is still up-to-date. Nothing to do.
    _shortcut_set_widget_data(widget, shortcut);
    return;
  }
  else if(shortcut && shortcut->type != DT_SHORTCUT_UNSET)
  {
    // If we already have a shortcut object wired to Gtk for this accel path, just update it
    GtkAccelKey key = { .accel_key = shortcut->key, .accel_mods = shortcut->mods, .accel_flags = 0 };
    if(shortcut->key > 0) _remove_widget_accel(shortcut, &key);
    shortcut->widget = widget;
    if(shortcut->key > 0) _add_widget_accel(shortcut, accels->flags);
    _shortcut_set_widget_data(widget, shortcut);
  }
  // else if shortcut && shortcut->type == DT_SHORTCUT_UNSET, we need to wait for the next call to dt_accels_connect_accels()
  else if(!shortcut)
  {
    shortcut = malloc(sizeof(dt_shortcut_t));
    shortcut->accel_group = accel_group;
    shortcut->widget = widget;
    shortcut->closure = NULL;
    shortcut->path = g_strdup(accel_path);
    shortcut->signal = signal;
    shortcut->key = key_val;
    shortcut->mods = accel_mods;
    shortcut->type = DT_SHORTCUT_UNSET;
    shortcut->locked = lock;
    shortcut->virtual_shortcut = FALSE;
    shortcut->description = _("Trigger the action");
    shortcut->accels = accels;
    dt_shortcut_set_closure(shortcut, _widget_shortcut_callback, shortcut, widget);
    _insert_accel(accels, shortcut);
    _shortcut_set_widget_data(widget, shortcut);
    // accel is inited with empty keys so user config may set it.
    // dt_accels_load_config needs to run next
    // then dt_accels_connect_accels will update keys and possibly wire the widgets in Gtk
  }
}
 
 
// Multiple instances of modules will have the same path for the same control
// meaning they all share the same shortcut object, which is not possible
// because they are referenced by pathes and those are unique.
// We handle this here by overriding any pre-existing closure
// with a reference to the current widget, meaning
// the last module in the order of GUI inits wins the shortcut.
void dt_accels_new_action_shortcut(dt_accels_t *accels,
                                   gboolean (*action_callback)(GtkAccelGroup *group, GObject *acceleratable,
                                                               guint keyval, GdkModifierType mods,
                                                               gpointer user_data),
                                   gpointer data, GtkWidget *target_widget, GtkAccelGroup *accel_group,
                                   const gchar *action_scope, const gchar *action_name, guint key_val,
                                   GdkModifierType accel_mods, const gboolean lock, const char *description)
{
  // Our own circuitery to keep track of things after user-defined shortcuts are updated
  gchar *accel_path = dt_accels_build_path(action_scope, action_name);
 
  dt_pthread_mutex_lock(&accels->lock);
  dt_shortcut_t *shortcut = (dt_shortcut_t *)g_hash_table_lookup(accels->acceleratables, accel_path);
  dt_pthread_mutex_unlock(&accels->lock);
 
  GClosure *closure = shortcut ? dt_shortcut_get_closure(shortcut) : NULL;
 
  if(closure && closure->data == data)
  {
    // reference is still up-to-date: nothing to do.
    dt_free(accel_path);
    return;
  }
  else if(shortcut && shortcut->type != DT_SHORTCUT_UNSET)
  {
    // If we already have a shortcut object wired to Gtk for this accel path, just update it
    if(shortcut->key > 0 && closure) _remove_generic_accel(shortcut);
    dt_shortcut_set_closure(shortcut, action_callback, data, target_widget);
    if(shortcut->key > 0) _add_generic_accel(shortcut, accels->flags);
  }
  // else if shortcut && shortcut->type == DT_SHORTCUT_UNSET, we need to wait for the next call to dt_accels_connect_accels()
  else if(!shortcut)
  {
    // Create a new object.
    shortcut = malloc(sizeof(dt_shortcut_t));
    shortcut->accel_group = accel_group;
    shortcut->widget = NULL;
    shortcut->closure = NULL;
    shortcut->path = g_strdup(accel_path);
    shortcut->signal = "";
    shortcut->key = key_val;
    shortcut->mods = accel_mods;
    shortcut->type = DT_SHORTCUT_UNSET;
    shortcut->locked = lock;
    shortcut->virtual_shortcut = FALSE;
    shortcut->description = description;
    shortcut->accels = accels;
    dt_shortcut_set_closure(shortcut, action_callback, data, target_widget);
    _insert_accel(accels, shortcut);
    // accel is inited with empty keys so user config may set it.
    // dt_accels_load_config needs to run next
    // then dt_accels_connect_accels will update keys and possibly wire the widgets in Gtk
  }
 
  dt_free(accel_path);
}
 
 
void dt_accels_load_user_config(dt_accels_t *accels)
{
  gtk_accel_map_load(accels->config_file);
}
 
// Resync the GtkAccelMap with our shortcut, meaning key changes should happen in GtkAccelMap before
static void _connect_accel(dt_shortcut_t *shortcut)
{
  GtkAccelKey key = { 0 };
 
  // All shortcuts should be known, they are added to accel_map at init time.
  const gboolean is_known = gtk_accel_map_lookup_entry(shortcut->path, &key);
  if(!is_known) return;
 
  // Remember previous values
  const GtkAccelKey oldkey = { .accel_key = shortcut->key, .accel_mods = shortcut->mods, .accel_flags = 0 };
  const dt_shortcut_type_t oldtype = shortcut->type;
 
  // Resync our shortcut object key/mods with what is currently defined in the GtkAccelMap
  const gboolean changed = _update_shortcut_state(shortcut, &key, shortcut->accels->init);
 
  // if old_key was non zero, we already had an accel on the stack.
  // then, if the new shortcut is different, that means we need to remove the old accel.
  const gboolean needs_cleanup = changed && oldkey.accel_key > 0 && oldtype != DT_SHORTCUT_UNSET;
 
  // if key is non zero and new, or updated, we need to add a new accel
  const gboolean needs_init = changed && key.accel_key > 0;
 
  if(dt_shortcut_get_closure(shortcut))
  {
    if(needs_cleanup) _remove_generic_accel(shortcut);
    if(needs_init) _add_generic_accel(shortcut, shortcut->accels->flags);
    // closures can be connected only at one accel at a time, so we don't handle keypad duplicates
  }
  else if(shortcut->widget)
  {
    if(needs_cleanup) _remove_widget_accel(shortcut, &oldkey);
    if(needs_init) _add_widget_accel(shortcut, shortcut->accels->flags);
  }
  else
  {
    // Nothing
  }
}
 
static void _connect_accel_hashtable(gpointer _key, gpointer value, gpointer user_data)
{
  dt_shortcut_t *shortcut = (dt_shortcut_t *)value;
  _connect_accel(shortcut);
}
 
 
void dt_accels_connect_accels(dt_accels_t *accels)
{
  dt_pthread_mutex_lock(&accels->lock);
  g_hash_table_foreach(accels->acceleratables, _connect_accel_hashtable, NULL);
  dt_pthread_mutex_unlock(&accels->lock);
}
 
static void
_remove_accel_hashtable(gpointer _key, gpointer value, gpointer user_data)
{
  dt_shortcut_t *shortcut = (dt_shortcut_t *)value;
  _accel_removal_t *params = (_accel_removal_t *)user_data;
  if(g_strrstr(shortcut->path, params->path) != NULL)
  {
    //fprintf(stdout, "removing %s\n", shortcut->path);
    if(dt_shortcut_get_closure(shortcut))
    {
      // Detach the accel from the accel group
      if(shortcut->key > 0) _remove_generic_accel(shortcut);
 
      // Remove the closure matching user_data, or the last one
      dt_shortcut_remove_closure(shortcut, params->data);
 
      // Reattach the accel to the accel group using the last closure in the list
      if(shortcut->key > 0) _add_generic_accel(shortcut, shortcut->accels->flags);
    }
    /* Should we handle that too ?
    else if(shortcut->widget)
    {
      GtkAccelKey key = { 0 };
      if(gtk_accel_map_lookup_entry(shortcut->path, &key))
        _remove_widget_accel(shortcut, &key);
    }
    */
  }
}
 
// For all shortcuts matching path (fully or partially), remove the closure instance referencing data
void dt_accels_remove_accel(dt_accels_t *accels, const char *path, gpointer data)
{
  if(IS_NULL_PTR(accels) || IS_NULL_PTR(accels->acceleratables)) return;
 
  _accel_removal_t *params = malloc(sizeof(_accel_removal_t));
  params->path = path;
  params->data = data;
 
  dt_pthread_mutex_lock(&accels->lock);
  g_hash_table_foreach(accels->acceleratables, _remove_accel_hashtable, (gpointer)params);
  dt_pthread_mutex_unlock(&accels->lock);
 
  dt_free(params);
}
 
void dt_accels_remove_shortcut(dt_accels_t *accels, const char *path)
{
  dt_pthread_mutex_lock(&accels->lock);
  g_hash_table_remove(accels->acceleratables, path);
  dt_pthread_mutex_unlock(&accels->lock);
}
 
 
gchar *dt_accels_build_path(const gchar *scope, const gchar *feature)
{
  // The preferences tree, the parent lookup and the search all split the path on "/",
  // so a "/" from a label would make it one level deeper than its caller meant.
  gchar *level = g_strdelimit(g_strdup(feature), "/", '-');
  gchar *path = (strncmp(scope, "<Ansel>/", strlen("<Ansel>/")) == 0)
                    ? g_strdup_printf("%s/%s", scope, level)
                    : g_strdup_printf("<Ansel>/%s/%s", scope, level);
  dt_free(level);
  return path;
}
 
static void _accels_keys_decode(dt_accels_t *accels, GdkEvent *event, guint *keyval, GdkModifierType *mods)
{
  if(IS_NULL_PTR(accels)) return;
 
  // Get modifiers
  gdk_event_get_state(event, mods);
 
  // Remove all modifiers that are irrelevant to key strokes
  *mods &= accels->default_mod_mask;
 
#ifdef GDK_WINDOWING_QUARTZ
  // On the Quartz GDK backend, a single physical Cmd key press can end up reported
  // through GDK_MOD2_MASK and GDK_META_MASK at once, depending on which code path
  // read it (NSEvent-derived key events vs a live device/CGEvent state poll -- see
  // _shortcut_edited(), which merges both). There is only one physical Command key.
  // Every shortcut is registered and matched against GDK_MOD2_MASK (DT_PRIMARY_MASK's
  // Quartz value, and what dt_modifier_primary_mask() remaps GDK_CONTROL_MASK to), so
  // that is the bit to KEEP -- clearing it instead would make a real Cmd press stop
  // matching any never-rebound default shortcut whenever both bits are set together.
  if((*mods & GDK_MOD2_MASK) && (*mods & GDK_META_MASK))
    *mods &= ~GDK_META_MASK;
#endif
 
  // Get the canonical key code, that is without the modifiers
  GdkModifierType consumed;
  gdk_keymap_translate_keyboard_state(accels->keymap, event->key.hardware_keycode, event->key.state,
                                      event->key.group, // this ensures that numlock or shift are properly decoded
                                      keyval, NULL, NULL, &consumed);
 
  if(dt_widget_log_enabled())
  {
    gchar *accel_name = gtk_accelerator_name(*keyval, *mods);
    dt_widget_log("[shortcuts] %s : %s\n",
             (event->type == GDK_KEY_PRESS) ? "Key pressed" : "Key released", accel_name);
    dt_free(accel_name);
  }
 
  // Remove the consumed Shift modifier for numbers.
  // For French keyboards, numbers are accessed through Shift, e.g Shift + & = 1.
  // Keeping Shift here would be meaningless and gets in the way.
  if(gdk_keyval_to_lower(*keyval) == gdk_keyval_to_upper(*keyval))
  {
    *mods &= ~consumed;
  }
 
  // Shift + Tab gets decoded as ISO_Left_Tab and shift is consumed,
  // so it gets absorbed by the previous correction.
  // We need Ctrl+Shift+Tab to work as expected, so correct it.
  if(*keyval == GDK_KEY_ISO_Left_Tab)
  {
    *keyval = GDK_KEY_Tab;
    *mods |= GDK_SHIFT_MASK;
  }
 
  // Convert numpad keys to usual ones, because we care about WHAT is typed,
  // not WHERE it is typed.
  *keyval = dt_keys_mainpad_alternatives(*keyval);
 
  // Hopefully no more heuristics required...
}
 
typedef struct _accel_lookup_t
{
  GList *results;
  guint key;
  GdkModifierType modifier;
  GtkAccelGroup *group;
} _accel_lookup_t;
 
static inline guint _normalize_keyval(const guint keyval)
{
  return gdk_keyval_to_lower(keyval);
}
 
 
static inline void _for_each_accel(gpointer key, gpointer value, gpointer user_data)
{
  dt_shortcut_t *shortcut = (dt_shortcut_t *)value;
  const gchar *path = (const gchar *)key;
  _accel_lookup_t *results = (_accel_lookup_t *)user_data;
 
  // gtk_accel_group_activate() maps uppercase and lowercase to the same key,
  // for compatibility we need to do the same.
  const guint shortcut_key = _normalize_keyval(shortcut->key);
  const guint result_key = _normalize_keyval(results->key);
 
  if(shortcut->accel_group == results->group
     && shortcut_key == result_key
     && shortcut->mods == results->modifier)
  {
    if(!g_strcmp0(path, shortcut->path))
    {
      results->results = g_list_prepend(results->results, shortcut->path);
      dt_widget_log("[shortcuts] Found accel %s for typed keys\n", path);
    }
    else
    {
      fprintf(stderr, "[shortcuts] ERROR: the shortcut path '%s' is known under the key '%s' in hashtable\n", shortcut->path, path);
    }
  }
}
 
 
// Find the accel path for the matching key & modifier within the specified accel group.
// Return the path of the first accel found
static const char * _find_path_for_keys(dt_accels_t *accels, guint key, GdkModifierType modifier, GtkAccelGroup *group)
{
  _accel_lookup_t result = { .results = NULL, .key = key, .modifier = modifier, .group = group };
 
  dt_pthread_mutex_lock(&accels->lock);
  g_hash_table_foreach(accels->acceleratables, _for_each_accel, &result);
  dt_pthread_mutex_unlock(&accels->lock);
 
  char *path = NULL;
  GList *item = g_list_first(result.results);
  if(item) path = (char *)item->data;
 
  g_list_free(result.results);
  result.results = NULL;
  return path;
}
 
static inline void _for_each_non_virtual_accel(gpointer key, gpointer value, gpointer user_data)
{
  dt_shortcut_t *shortcut = (dt_shortcut_t *)value;
  const gchar *path = (const gchar *)key;
  _accel_lookup_t *results = (_accel_lookup_t *)user_data;
 
  // gtk_accel_group_activate() maps uppercase and lowercase to the same key,
  // for compatibility we need to do the same.
  const guint shortcut_key = _normalize_keyval(shortcut->key);
  const guint result_key = _normalize_keyval(results->key);
 
  if(shortcut->accel_group == results->group
     && shortcut_key == result_key
     && shortcut->mods == results->modifier
     && !shortcut->virtual_shortcut)
  {
    if(!g_strcmp0(path, shortcut->path))
    {
      results->results = g_list_prepend(results->results, shortcut);
      dt_widget_log("[shortcuts] Found accel %s for typed keys\n", path);
    }
    else
    {
      fprintf(stderr, "[shortcuts] ERROR: the shortcut path '%s' is known under the key '%s' in hashtable\n", shortcut->path, path);
    }
  }
}
 
static dt_shortcut_t *_find_non_virtual_shortcut(dt_accels_t *accels, GtkAccelGroup *group, guint keyval,
                                                 GdkModifierType mods)
{
  _accel_lookup_t result = { .results = NULL, .key = keyval, .modifier = mods, .group = group };
 
  dt_pthread_mutex_lock(&accels->lock);
  g_hash_table_foreach(accels->acceleratables, _for_each_non_virtual_accel, &result);
  dt_pthread_mutex_unlock(&accels->lock);
 
  dt_shortcut_t *shortcut = NULL;
  GList *item = g_list_first(result.results);
  if(!IS_NULL_PTR(item)) shortcut = (dt_shortcut_t *)item->data;
 
  g_list_free(result.results);
  result.results = NULL;
  return shortcut;
}
 
static gboolean _call_shortcut_cclosure(dt_shortcut_t *shortcut, GtkWindow *main_window, GClosure *closure);
 
static gboolean _key_pressed(GtkWidget *w, GdkEvent *event, dt_accels_t *accels, guint keyval, GdkModifierType mods)
{
  // Get the accelerator entry from the accel group
  gchar *accel_name = gtk_accelerator_name(keyval, mods);
  dt_widget_log("[shortcuts] Combination of keys decoded: %s\n", accel_name);
  dt_free(accel_name);
 
  // Look into the active group first, aka darkroom, lighttable, etc.
  dt_shortcut_t *shortcut = _find_non_virtual_shortcut(accels, accels->active_group, keyval, mods);
  if(!IS_NULL_PTR(shortcut) && _call_shortcut_cclosure(shortcut, GTK_WINDOW(w), NULL))
  {
    dt_widget_log("[shortcuts] Active group action executed\n");
    return TRUE;
  }
 
  // If nothing found, try again with global accels.
  shortcut = _find_non_virtual_shortcut(accels, accels->global_accels, keyval, mods);
  if(!IS_NULL_PTR(shortcut) && _call_shortcut_cclosure(shortcut, GTK_WINDOW(w), NULL))
  {
    dt_widget_log("[shortcuts] Global group action executed\n");
    return TRUE;
  }
 
  return FALSE;
}
 
 
gboolean dt_accels_dispatch(GtkWidget *w, GdkEvent *event, gpointer user_data)
{
  dt_accels_t *accels = (dt_accels_t *)user_data;
 
  // A shortcut that opens a window (import, export) moves the focus there while its key is
  // still down, so the release never comes back here. The held key is therefore only known
  // within one stretch of focus: forget it when the focus comes or goes, or the next press of
  // the same shortcut reads as auto-repeat and does nothing.
  if(event->type == GDK_FOCUS_CHANGE)
  {
    dt_widget_log("[shortcuts] Focus %s, held key forgotten\n", event->focus_change.in ? "in" : "out");
    accels->active_key.accel_key = 0;
    accels->active_key.accel_mods = 0;
    return FALSE;
  }
 
  // Ditch everything that is not a key stroke or key strokes that are modifiers alone
  // Abort early for performance.
  if(event->key.is_modifier || IS_NULL_PTR(accels->active_group) || accels->reset > 0 || !gtk_window_is_active(GTK_WINDOW(w)))
    return FALSE;
 
  if(!(event->type == GDK_KEY_PRESS || event->type == GDK_KEY_RELEASE || event->type == GDK_SCROLL))
    return FALSE;
 
  // Scroll event: dispatch and return
  if(event->type == GDK_SCROLL)
  {
    if(accels->scroll.callback)
      return accels->scroll.callback(event->scroll, accels->scroll.data);
    else
      return FALSE;
  }
 
  // Key events: decode and dispatch
  GdkModifierType mods;
  guint keyval;
  _accels_keys_decode(accels, event, &keyval, &mods);
 
  // Ugly design : global shortcuts are supposed to have a key modifier.
  // To allow single-key shortcuts, we have to work around that and impose our own shortcut handler.
  // But then, that breaks regular text input on GtkEntry, GtkSearchEntry, etc. 
  // because letters are then captured as shortcuts.
  // Which was the whole purpose of forcing global shortcuts to use modifiers.
  // So, to avoid that, when text entries get focused, we manually set accels->disable_accels,
  // and unset it when they loose focus.
  // When "disabled", we reset typical Gtk behaviour : capture global shortcuts only if there is a modifier.
  // NOTE: this nasty workaround should not be taken as an incentive to extend it further.
  // It's bad design, it should not be turned into a rule.
  if(accels->disable_accels && !mods) return FALSE;
 
  // When a text editor has keyboard focus, bypass accelerators so typing keeps
  // native widget behavior (letters, spaces, modifiers and editing keys).
  if(event->type == GDK_KEY_PRESS || event->type == GDK_KEY_RELEASE)
  {
    GtkWidget *focused = gtk_window_get_focus(GTK_WINDOW(w));
    if(!IS_NULL_PTR(focused) && (GTK_IS_EDITABLE(focused) || GTK_IS_TEXT_VIEW(focused)))
    {
      accels->active_key.accel_key = 0;
      accels->active_key.accel_mods = 0;
      return FALSE;
    }
  }
 
  if(event->type == GDK_KEY_PRESS && 
    !(keyval == accels->active_key.accel_key && mods == accels->active_key.accel_mods))
  {
    // Store active keys until release
    accels->active_key.accel_key = keyval;
    accels->active_key.accel_mods = mods;
    return _key_pressed(w, event, accels, keyval, mods);
  }
  else if(event->type == GDK_KEY_RELEASE)
  {
    // Reset active keys
    accels->active_key.accel_key = 0;
    accels->active_key.accel_mods = 0;
    return FALSE;
  }
 
  return FALSE;
}
 
 
void dt_accels_attach_scroll_handler(dt_accels_t *accels, gboolean (*callback)(GdkEventScroll event, void *data), void *data)
{
  accels->scroll.callback = callback;
  accels->scroll.data = data;
}
 
void dt_accels_detach_scroll_handler(dt_accels_t *accels)
{
  accels->scroll.callback = NULL;
  accels->scroll.data = NULL;
}
 
// Ugly. Use that only for callbacks of the shortcuts GUI popup
// when the user_data pointer is already used for something else.
// This will be inited when opening the popup, so there is only
// one place/thread accessing it and the reference is up to date
// within the scope where it's used.
static dt_accels_t *accels_global_ref = NULL;
 
enum
{
  COL_NAME,
  COL_KEYS,
  COL_CLEAR,
  COL_DESCRIPTION,
  COL_PATH,
  COL_SHORTCUT,
  COL_KEYVAL,
  COL_MODS,
  // Same modifiers as COL_MODS, but swapped for display (GDK_MOD2_MASK -> GDK_META_MASK on
  // Quartz, via dt_accels_display_mods()) so the "Keys" column's GtkCellRendererAccel renders
  // the "⌘" glyph. Never read for matching/search: COL_MODS stays the real value for that
  // (see filter_callback()'s gtk_accelerator_parse()-based search, and _shortcut_edited()).
  COL_DISPLAY_MODS,
  NUM_COLUMNS
};
 
typedef struct _accel_treeview_t
{
  GtkTreeStore *store;
  GHashTable *node_cache;
} _accel_treeview_t;
 
 
static void _make_column_editable(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
                                  GtkTreeIter *iter, gpointer data)
{
  dt_shortcut_t *shortcut;
  gtk_tree_model_get(model, iter, COL_SHORTCUT, &shortcut, -1);
  g_object_set(renderer,
               "visible", (!IS_NULL_PTR(shortcut)),
               "editable", (!IS_NULL_PTR(shortcut) && !shortcut->locked),
               "accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
               NULL);
}
 
static void _make_column_clearable(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
                                   GtkTreeIter *iter, gpointer data)
{
  dt_shortcut_t *shortcut;
  gtk_tree_model_get(model, iter, COL_SHORTCUT, &shortcut, -1);
  // "changes-prevent-symbolic" is Adwaita's padlock. A plain "lock" exists in neither Adwaita
  // nor hicolor and renders as GTK's "image-missing" placeholder.
  g_object_set (renderer,
                "icon-name", (!IS_NULL_PTR(shortcut) && !shortcut->locked) ? "edit-delete-symbolic"
                                                                         : "changes-prevent-symbolic",
                "visible",   (!IS_NULL_PTR(shortcut)),
                "sensitive", (!IS_NULL_PTR(shortcut) && !shortcut->locked && shortcut->key),
                NULL);
}
 
 
static int guess_key_group(dt_accels_t *accels, guint keyval, guint hardware_keycode)
{
  GdkKeymapKey *keys;
  guint *keyvals;
  gint n_keys;
 
  if(!gdk_keymap_get_entries_for_keycode(accels->keymap, hardware_keycode, &keys, &keyvals, &n_keys))
    return 0;
 
  for(int i = 0; i < n_keys; ++i)
  {
    if(keyvals[i] == keyval)
    {
      int group = keys[i].group;
      dt_free(keys);
      dt_free(keyvals);
      return group; // found matching group
    }
  }
 
  dt_free(keys);
  dt_free(keyvals);
  return 0; // not found, default
}
 
static void _shortcut_edited(GtkCellRenderer *cell, const gchar *path_string, guint key, GdkModifierType mods,
                             guint hardware_key, gpointer user_data)
{
  // The tree model passed as arg is the filtered proxy.
  // We will need to access its underlying store (full, unfiltered)
  GtkTreeModel *filter = GTK_TREE_MODEL(user_data);
  GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(filter));
  if(IS_NULL_PTR(store)) return;
 
  GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
  dt_shortcut_t *shortcut = NULL;
 
  // f_iter is the row coordinates relative to the filtered model
  // That's what we need to READ data
  GtkTreeIter f_iter;
  if(gtk_tree_model_get_iter(GTK_TREE_MODEL(filter), &f_iter, path))
    gtk_tree_model_get(GTK_TREE_MODEL(filter), &f_iter, COL_SHORTCUT, &shortcut, -1);
 
  const char *shortcut_path = NULL;
  guint keyval = dt_keys_mainpad_alternatives(key);
 
  // In GTK "OTHER" accel mode, clearing from the editor may come through either as
  // VoidSymbol or as an unmodified Delete/BackSpace key press. Normalize all those
  // cases to an empty shortcut so the model and the GtkAccelMap stay in sync.
  if(keyval == GDK_KEY_VoidSymbol
     || (mods == 0 && (keyval == GDK_KEY_Delete || keyval == GDK_KEY_BackSpace)))
  {
    keyval = 0;
    mods = 0;
    hardware_key = 0;
  }
 
  // mods input arg doesn't record states (numlock, capslock), so we need to fetch it
  // directly before decoding full key combinations
  if(keyval != 0 || mods != 0)
  {
    GdkDisplay *display = gdk_display_get_default();
    GdkSeat *seat = gdk_display_get_default_seat(display);
    GdkDevice *pointer = gdk_seat_get_pointer(seat);
    GdkModifierType state;
    gdk_device_get_state(pointer, gdk_get_default_root_window(), NULL, &state);
 
    // We only decode actual key strokes here. Clearing shortcuts bypasses this path
    // because there is no hardware key or modifier state to preserve.
    GdkEventKey event = { 0 };
    event.type = GDK_KEY_PRESS;
    event.state = mods | state;
    event.keyval = keyval;
    event.hardware_keycode = hardware_key;
    event.group = guess_key_group(accels_global_ref, keyval, hardware_key);
    _accels_keys_decode(accels_global_ref, (GdkEvent *)&event, &keyval, &mods);
  }
 
  if(shortcut)
  {
    // Lookup this keys combination in the current accel_group (only if key is not empty)
    if(!(keyval == 0 && mods == 0))
      shortcut_path = _find_path_for_keys(shortcut->accels, keyval, mods, shortcut->accel_group);
 
    // Try to update the GtkAccelMap with new keys
    if(IS_NULL_PTR(shortcut_path) && gtk_accel_map_change_entry(shortcut->path, keyval, mods, FALSE))
    {
      // Success:
      // Resync our internal shortcut object and its GtkAccelGroup to GtkAccelMap
      _connect_accel(shortcut);
 
      // s_iter is the row coordinates relative to the child/source model (unfiltered)
      // That's what we need to WRITE data
      // And write new keys into the source model
      GtkTreeIter s_iter;
      gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(filter), &s_iter, &f_iter);
      gtk_tree_store_set(GTK_TREE_STORE(store), &s_iter, COL_KEYVAL, keyval, COL_MODS, mods,
                        COL_DISPLAY_MODS, dt_accels_display_mods(mods), -1);
    }
  }
 
  if(shortcut_path)
  {
    // The GtkAccelMap could not be updated because another accel uses the same keys
    // That also happens if we try to unset a shortcut more than once, but then it's no issue.
    // A human-readable label ("⌘C"), not the machine accelerator-string spelling ("<Primary>c"
    // -- see gtk_accelerator_name() elsewhere in this file for that, used only for debug logs).
    char *new_text = gtk_accelerator_get_label(keyval, dt_accels_display_mods(mods));
    GtkWidget *dlg
        = gtk_message_dialog_new_with_markup(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s <tt>%s</tt>\n%s <tt>%s</tt>.\n%s",
                                              _("The shortcut for"), shortcut_path,
                                              _("is already using the key combination"), new_text,
                                              _("Delete it first."));
    gtk_dialog_run(GTK_DIALOG(dlg));
    gtk_widget_destroy(dlg);
    dt_free(new_text);
  }
 
  gtk_tree_path_free(path);
}
 
static void _shortcut_cleared(GtkCellRendererAccel *renderer, const gchar *path_string, gpointer user_data)
{
  _shortcut_edited(GTK_CELL_RENDERER(renderer), path_string, 0, 0, 0, user_data);
}
 
 
static gboolean _icon_activate(GtkCellRenderer *cell, GdkEvent *event, GtkWidget *treeview, const gchar *path_str,
                               GdkRectangle *background, GdkRectangle *cell_area, GtkCellRendererState flags,
                               gpointer user_data)
{
  // Reset accel at current path
  _shortcut_edited(cell, path_str, 0, 0, 0, user_data);
  return TRUE;
}
 
 
static void _create_main_row(GtkTreeStore *store, GtkTreeIter *iter, const char *label, const char *path,
                             dt_shortcut_t *shortcut)
{
  gtk_tree_store_set(store, iter,
                     COL_NAME, label,
                     COL_DESCRIPTION, shortcut->description,
                     COL_PATH, path,
                     COL_KEYVAL, shortcut->key,
                     COL_MODS, shortcut->mods,
                     COL_DISPLAY_MODS, dt_accels_display_mods(shortcut->mods),
                     COL_SHORTCUT, shortcut, -1);
}
 
void _for_each_accel_create_treeview_row(gpointer key, gpointer value, gpointer user_data)
{
  // Extract HashTable key/value
  dt_shortcut_t *shortcut = (dt_shortcut_t *)value;
  if(IS_NULL_PTR(shortcut)) return;
  const gchar *path = (const gchar *)key;
 
  // Extract user_data
  _accel_treeview_t *_data = (_accel_treeview_t *)user_data;
  GHashTable *node_cache = _data->node_cache;
  GtkTreeStore *store = _data->store;
 
  GtkTreeIter *parent = NULL;
  GtkTreeIter *iter = NULL;
 
  // Split the shortcut accel path on /.
  // Then we reconstruct it piece by piece and add a tree node fore each piece,
  // which lets us manage parents/children.
  // Note 1: parts[0] is always "<Ansel>"
  // Note 2: that fails if widget labels contain /
  gchar **parts = g_strsplit(path, "/", -1);
  gchar *accum = g_strdup("<Ansel>");
 
  // We will copy pathes after <Ansel> string because that makes
  // treeview markup parsers fail since it looks like markup
  const size_t len_ansel = strlen(accum);
  for(int i = 1; parts[i]; ++i)
  {
    // Build the partial path so far
    gchar *tmp = g_strconcat(accum, "/", parts[i], NULL);
    dt_free(accum);
    accum = tmp;
 
    // Find out if current node exists.
    // If it does, it will be our parent for the next step.
    iter = g_hash_table_lookup(node_cache, accum);
 
    // If current node is not already in tree, add it.
    if(IS_NULL_PTR(iter))
    {
      // We need a heap-allocated iter to pass it along to the hashtable.
      // This will be freed when cleaning up the hashtable.
      GtkTreeIter new_iter;
      gtk_tree_store_append(store, &new_iter, parent);
 
      // heap‑copy the struct to pass it along to the HashTable
      iter = g_new(GtkTreeIter, 1);
      *iter = new_iter;
      g_hash_table_insert(node_cache, g_strdup(accum), iter);
    }
 
    // Capitalize first letter for GUI purposes
    gchar *label = g_strdup(parts[i]);
    dt_capitalize_label(label);
 
    // Write the shortcut only if we are at the terminating point of the path
    if(!g_strcmp0(accum, path))
      _create_main_row(store, iter, label, path + len_ansel, shortcut);
    else
      gtk_tree_store_set(store, iter, COL_NAME, parts[i], COL_KEYS, "", COL_PATH, accum + len_ansel, -1);
 
    dt_free(label);
 
    parent = iter;
  }
 
  dt_free(accum);
  g_strfreev(parts);
}
 
static gchar *_shortcut_search_trim_display_path(const gchar *path)
{
  if(IS_NULL_PTR(path)) return g_strdup("");
 
  gchar **parts = g_strsplit(path, "/", -1);
  const gint len = g_strv_length(parts);
  gchar *tail = NULL;
  if(len >= 3)
    tail = g_strjoinv("/", parts + 2);
  else if(len == 2)
    tail = g_strdup(parts[1]);
  else
    tail = g_strdup(parts[0]);
  g_strfreev(parts);
  return tail;
}
 
void _for_each_path_create_treeview_row(gpointer key, gpointer value, gpointer user_data)
{
  // Extract HashTable key/value
  dt_shortcut_t *shortcut = (dt_shortcut_t *)value;
  if(IS_NULL_PTR(shortcut)) return;
  const gchar *path = (const gchar *)key;
 
  GtkListStore *store = (GtkListStore *)user_data;
  if(IS_NULL_PTR(store)) return;
 
  dt_accels_t *accels = shortcut->accels;
  //g_print("My object is a <%s>\n", G_OBJECT_TYPE_NAME(store));
 
  // Append the shortcut path, minus initial <Ansel> root, to a flat list
  // only if the shortcut belongs to one currently-active accel group
  if(shortcut->accel_group == accels->global_accels ||
     shortcut->accel_group == accels->active_group)
  {
    gchar *tail = _shortcut_search_trim_display_path(path);
    gchar **tail_parts = g_strsplit(tail, "/", -1);
    const gint tail_len = g_strv_length(tail_parts);
    const gchar *leaf = tail;
    if(tail_len > 0 && !IS_NULL_PTR(tail_parts[tail_len - 1]) && tail_parts[tail_len - 1][0] != '\0')
      leaf = tail_parts[tail_len - 1];
 
    GtkTreeIter iter;
    gtk_list_store_append(store, &iter);
    gtk_list_store_set(store, &iter,
                       0, tail, // shortcut path
                       1, shortcut, // shortcut object
                       2, 0, // init relevance
                       3, shortcut->description, // description
                       4, leaf, // leaf label used for inline completion
                       5, shortcut->key,
                       6, dt_accels_display_mods(shortcut->mods), // display-only, see COL_DISPLAY_MODS
                       -1);
    g_strfreev(tail_parts);
    dt_free(tail);
  }
}
 
// Relevance coeff stored in column index 2
static gint _sort_model_by_relevance_func(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer data)
{
  int ka, kb;
  gchar *pa = NULL, *pb = NULL;
  gtk_tree_model_get(model, a, 2, &ka, 0, &pa, -1);
  gtk_tree_model_get(model, b, 2, &kb, 0, &pb, -1);
 
  if(ka != kb)
  {
    dt_free(pa);
    dt_free(pb);
    return ka - kb;
  }
 
  gint ret = 0;
  if(!IS_NULL_PTR(pa) && !IS_NULL_PTR(pb))
  {
    gchar *pa_ci = g_utf8_casefold(pa, -1);
    gchar *pb_ci = g_utf8_casefold(pb, -1);
    gchar **pa_parts = g_strsplit(pa_ci, "/", -1);
    gchar **pb_parts = g_strsplit(pb_ci, "/", -1);
 
    for(gint i = 0;; i++)
    {
      const gchar *pa_part = pa_parts[i];
      const gchar *pb_part = pb_parts[i];
      if(IS_NULL_PTR(pa_part) && IS_NULL_PTR(pb_part))
      {
        ret = 0;
        break;
      }
      if(IS_NULL_PTR(pa_part))
      {
        ret = -1;
        break;
      }
      if(IS_NULL_PTR(pb_part))
      {
        ret = 1;
        break;
      }
 
      ret = g_utf8_collate(pa_part, pb_part);
      if(ret != 0) break;
    }
 
    g_strfreev(pb_parts);
    g_strfreev(pa_parts);
    dt_free(pb_ci);
    dt_free(pa_ci);
  }
 
  dt_free(pa);
  dt_free(pb);
  return ret;
}
 
static gint _sort_model_func(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer data)
{
  gchar *ka, *kb;
  gtk_tree_model_get(model, a, GPOINTER_TO_INT(data), &ka, -1);
  gtk_tree_model_get(model, b, GPOINTER_TO_INT(data), &kb, -1);
 
  gint res = 0;
  if(ka && kb)
  {
    // Make strings case-insensitive
    gchar *ka_ci = g_utf8_casefold(ka, -1);
    gchar *kb_ci = g_utf8_casefold(kb, -1);
 
    // Compare strings
    res = g_utf8_collate(ka_ci, kb_ci);
 
    dt_free(ka_ci);
    dt_free(kb_ci);
  }
 
  dt_free(ka);
  dt_free(kb);
  return res;
}
 
typedef struct _accel_window_params_t
{
  GtkWidget *path_search;
  GtkWidget *keys_search;
  GtkWidget *tree_view;
} _accel_window_params_t;
 
 
static gboolean filter_callback(GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
{
  _accel_window_params_t *params = (_accel_window_params_t *)user_data;
 
  // Everything visible if needle is empty or NULL, aka no active search
  const gchar *needle_path = gtk_entry_get_text(GTK_ENTRY(params->path_search));
  const gchar *needle_keys = gtk_entry_get_text(GTK_ENTRY(params->keys_search));
 
  if((IS_NULL_PTR(needle_path) || needle_path[0] == '\0') &&
     (IS_NULL_PTR(needle_keys) || needle_keys[0] == '\0'))
    return TRUE;
 
  gboolean show = TRUE;
 
  // Check if path matches
  gchar *path = NULL;
  gtk_tree_model_get(model, iter, COL_PATH, &path, -1);
  if(needle_path && needle_path[0])
  {
    if(path && path[0] != '\0')
    {
      gchar *needle_ci = g_utf8_casefold(needle_path, -1);
      gchar *haystack_ci = g_utf8_casefold(path, -1);
      show &= (g_strrstr(haystack_ci, needle_ci) != NULL);
      dt_free(needle_ci);
      dt_free(haystack_ci);
      dt_free(path);
    }
    else
    {
      show &= FALSE;
    }
  }
 
  // Check if keys match
  if(needle_keys && needle_keys[0] != '\0')
  {
    guint search_keyval = 0;
    GdkModifierType search_mods = 0;
    gtk_accelerator_parse(needle_keys, &search_keyval, &search_mods);
    if(search_keyval || search_mods)
    {
      guint keyval = 0;
      GdkModifierType mods = 0;
      gtk_tree_model_get(model, iter, COL_KEYVAL, &keyval, COL_MODS, &mods, -1);
      keyval = _normalize_keyval(keyval);
      search_keyval = _normalize_keyval(search_keyval);
 
      // If both keyval and mods are searched, use strict mode.
      // Else use fuzzy mode
      if(search_keyval && search_mods)
        show &= (keyval == search_keyval && mods == search_mods);
      else
        show &= ((keyval && keyval == search_keyval) || (mods && mods == search_mods));
    }
    else
    {
      // Parsing failed, keys/modifiers syntax is wrong: let user know
      show &= FALSE;
    }
  }
 
  if(show) return TRUE;
 
  // Check again recursively if any of the current item's children has an accel path matching
  if(gtk_tree_model_iter_has_child(model, iter))
  {
    GtkTreeIter child;
    if(gtk_tree_model_iter_children(model, &child, iter))
    {
      do
      {
        if(filter_callback(model, &child, user_data))
          return TRUE;
      } while(gtk_tree_model_iter_next(model, &child));
    }
  }
 
  return FALSE;
}
 
static void search_changed(GtkEntry *entry, gpointer user_data)
{
  _accel_window_params_t *params = (_accel_window_params_t *)user_data;
  GtkTreeView *tree_view = GTK_TREE_VIEW(params->tree_view);
  gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(gtk_tree_view_get_model(tree_view)));
 
  // Everything visible if needle is empty or NULL, aka no active search
  const gchar *needle_path = gtk_entry_get_text(GTK_ENTRY(params->path_search));
  const gchar *needle_keys = gtk_entry_get_text(GTK_ENTRY(params->keys_search));
 
  if((IS_NULL_PTR(needle_path) || needle_path[0] == '\0') &&
      (IS_NULL_PTR(needle_keys) || needle_keys[0] == '\0'))
    gtk_tree_view_collapse_all(GTK_TREE_VIEW(params->tree_view));
  else
    gtk_tree_view_expand_all(GTK_TREE_VIEW(params->tree_view));
}
 
 
void dt_accels_window(dt_accels_t *accels, GtkWindow *main_window)
{
  // Update the ugly global variable referencing accels
  accels_global_ref = accels;
 
  _accel_window_params_t *params = malloc(sizeof(_accel_window_params_t));
  params->keys_search = gtk_search_entry_new();
  params->path_search = gtk_search_entry_new();
  GtkWidget *tree_view = params->tree_view = gtk_tree_view_new();
 
  // Setup auto-completion on key modifiers because they are annoying
  // Note: omit the initial < character in modifier names as it is used to trigger matching
  // and won't be appended
  static dt_gtkentry_completion_spec default_path_compl_list[]
      = { { "Primary>", N_("<Primary> - Decoded as <Control> on Windows/Linux or <Meta> on Mac OS") },
          { "Control>", N_("<Control>") },
          { "Shift>", N_("<Shift>") },
          { "Alt>", N_("<Alt>") },
          { "Super>", N_("<Super> - The Windows key on PC") },
          { "Hyper>", N_("<Hyper>") },
          { "Meta>", N_("<Meta> - Decoded as <Command> on Mac OS") },
          { NULL, NULL } };
  dt_gtkentry_setup_completion(GTK_ENTRY(params->keys_search), default_path_compl_list, "<");
  gtk_widget_set_tooltip_text(params->keys_search, _("Look for keys and modifiers codes, as `<Modifier>Key`.\n"
                                                     "Type `<` to start the auto-completion"));
 
  gtk_widget_set_tooltip_text(params->path_search, _("Case-insensitive search for keywords of full pathes.\n"
                                                     "Ex: `darkroom/controls/sliders`"));
 
  // Set dialog window properties
  GtkWidget *dialog = gtk_dialog_new();
  gtk_window_set_title(GTK_WINDOW(dialog), _("Ansel - Keyboard shortcuts"));
 
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
  gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
#endif
 
  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
  gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
  gtk_window_set_transient_for(GTK_WINDOW(dialog), main_window);
  gtk_window_set_default_size(GTK_WINDOW(dialog), 1100, 900);
 
  // Create the full (non-filtered) tree view model
  GtkTreeStore *store = gtk_tree_store_new(NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING,
                                           G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
 
  // Add a tree view row for each accel
  GHashTable *node_cache = g_hash_table_new_full(g_str_hash, g_str_equal, dt_free_gpointer, dt_free_gpointer);
  _accel_treeview_t _data = { .store = store , .node_cache = node_cache};
  g_hash_table_foreach(accels->acceleratables, _for_each_accel_create_treeview_row, &_data);
  g_hash_table_destroy(node_cache);
 
  // Sort rows alphabetically by path
  for(int i = COL_NAME; i < COL_KEYS; i++)
  {
    gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), i, (GtkTreeIterCompareFunc)_sort_model_func,
                                    GINT_TO_POINTER(i), NULL);
    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), i, GTK_SORT_ASCENDING);
  }
 
  // Set the search feature, aka wire the Gtk search entry to a GtkTreeModelFilter
  GtkTreeModel *filter_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL);
  gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model), filter_callback, params, NULL);
 
  // So the content of the treeview is NOT the original (full) model, but the filtered one
  gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view), filter_model);
  gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(tree_view), COL_PATH);
  gtk_widget_set_hexpand(tree_view, TRUE);
  gtk_widget_set_vexpand(tree_view, TRUE);
  gtk_widget_set_halign(tree_view, GTK_ALIGN_FILL);
  gtk_widget_set_valign(tree_view, GTK_ALIGN_FILL);
 
  g_signal_connect(G_OBJECT(params->path_search), "changed", G_CALLBACK(search_changed), params);
  g_signal_connect(G_OBJECT(params->keys_search), "changed", G_CALLBACK(search_changed), params);
 
  // Add tree view columns
  GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes(_("View / Scope / Feature / Control"), gtk_cell_renderer_text_new(), "text", COL_NAME, NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 
  GtkCellRenderer *renderer = gtk_cell_renderer_accel_new();
  column = gtk_tree_view_column_new_with_attributes(_("Keys"), renderer, "accel-key", COL_KEYVAL, "accel-mods",
                                                    COL_DISPLAY_MODS, NULL);
  gtk_tree_view_column_set_cell_data_func(column, renderer, _make_column_editable, NULL, NULL);
  g_signal_connect(renderer, "accel-edited", G_CALLBACK(_shortcut_edited), filter_model);
  g_signal_connect(renderer, "accel-cleared", G_CALLBACK(_shortcut_cleared), filter_model);
  gtk_tree_view_column_set_min_width(column, 100);
  gtk_tree_view_column_set_resizable(column, TRUE);
  gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 
  renderer = dtgtk_cell_renderer_button_new();
  g_object_set(renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
  column = gtk_tree_view_column_new_with_attributes(_("Clear"), renderer, "pixbuf", COL_CLEAR, NULL);
  gtk_tree_view_column_set_cell_data_func(column, renderer, _make_column_clearable, NULL, NULL);
  g_signal_connect(renderer, "activate", G_CALLBACK(_icon_activate), filter_model);
  gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 
  column = gtk_tree_view_column_new_with_attributes(_("Description"), gtk_cell_renderer_text_new(), "text", COL_DESCRIPTION, NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 
  // Pack and show widgets
  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), box, TRUE, TRUE, 0);
 
  GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Search by feature : ")), FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(hbox), params->path_search, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(_("Search by keys : ")), FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(hbox), params->keys_search, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
 
  GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  dt_gui_add_class(scrolled_window, "dt_recessed_scroll");
  gtk_container_add(GTK_CONTAINER(scrolled_window), tree_view);
  gtk_box_pack_start(GTK_BOX(box), scrolled_window, TRUE, TRUE, 0);
 
  gtk_widget_set_visible(tree_view, TRUE);
  gtk_widget_show_all(dialog);
 
  gtk_dialog_run(GTK_DIALOG(dialog));
  gtk_widget_destroy(dialog);
  g_object_unref(filter_model);
  g_object_unref(store);
  dt_free(params);
}
 
// Case-insensitive partial matching
// Return:
// - 0: perfect match
// - > 0: matches increasingly worse (rank)
// - -1: no match
static int _match_text(GtkTreeModel *model, GtkTreeIter *iter, const char *needle)
{
  int ret = -1;
  if(IS_NULL_PTR(needle) || needle[0] == '\0') return 0;
 
  // Get row entry
  gchar *label;
  gtk_tree_model_get(model, iter, 0, &label, -1);
  if(IS_NULL_PTR(label) || label[0] == '\0')
  {
    dt_free(label);
    return -1;
  }
 
  // Convert to lowercase
  gchar *label_ci = g_utf8_casefold(label, -1);
 
  gchar **parts = g_strsplit(label_ci, "/", -1);
  gchar *needle_copy = g_strdup(needle);
  gchar **tokens = g_strsplit_set(needle_copy, " \t\r\n", -1);
  int rank_sum = 0;
  gboolean has_token = FALSE;
  gboolean all_matched = TRUE;
  for(gint t = 0; !IS_NULL_PTR(tokens[t]); t++)
  {
    if(tokens[t][0] == '\0') continue;
    has_token = TRUE;
    int best_token_rank = INT_MAX;
    for(gint i = 0; !IS_NULL_PTR(parts[i]); i++)
    {
      // Rank by path cell index first (left cells first), then by position inside the cell.
      // This keeps generic scopes before deeper scopes for each search token.
      const char *match = g_strstr_len(parts[i], -1, tokens[t]);
      if(IS_NULL_PTR(match)) continue;
 
      const int cell_rank = i * 10000;
      const int in_cell_rank = match - parts[i];
      const int token_rank = cell_rank + in_cell_rank;
      if(token_rank < best_token_rank) best_token_rank = token_rank;
    }
 
    if(best_token_rank == INT_MAX)
    {
      all_matched = FALSE;
      break;
    }
    rank_sum += best_token_rank;
  }
 
  if(all_matched) ret = has_token ? rank_sum : 0;
 
  g_strfreev(tokens);
  dt_free(needle_copy);
  g_strfreev(parts);
 
  dt_free(label);
  dt_free(label_ci);
 
  return ret;
}
 
static void _find_and_rank_matches(GtkTreeModel *model, GtkWidget *search_entry)
{
  const gchar *needle = gtk_entry_get_text(GTK_ENTRY(search_entry));
  gchar *needle_query = g_strdup(!IS_NULL_PTR(needle) ? needle : "");
  gchar *needle_sep = g_strstr_len(needle_query, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
  if(!IS_NULL_PTR(needle_sep)) *needle_sep = '\0';
  g_strstrip(needle_query);
  gchar *needle_ci = g_utf8_casefold(needle_query, -1);
 
  // Block sorting while we update the content of the column used to sort rows
  // otherwise that makes updating iterations recurse and ultimately fail
  gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
                                       GTK_SORT_ASCENDING);
 
  GtkTreeIter iter;
  if(gtk_tree_model_get_iter_first(model, &iter))
  {
    do
    {
      int rank = _match_text(model, &iter, needle_ci);
      gtk_list_store_set(GTK_LIST_STORE(model), &iter, 2, rank, -1);
 
    } while(gtk_tree_model_iter_next(model, &iter));
  }
 
  dt_free(needle_ci);
  dt_free(needle_query);
 
  // Restore sorting
  gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), 2, GTK_SORT_ASCENDING);
  gtk_tree_sortable_sort_column_changed(GTK_TREE_SORTABLE(model));
}
 
typedef struct dt_accels_search_state_t
{
  GtkListStore *store;
  GtkTreeModel *filter_model;
  GtkListStore *recent_entries;
  GtkWindow *main_window;
  GtkWidget *search_entry;
  GtkWidget *tree_view;
  GtkWidget *window;
  GMainLoop *loop;
  gint response;
  dt_shortcut_t *selected;
  gchar *preferred_command;
  gboolean suppress_inline_once;
  gchar *pending_space_query;
  guint pending_space_idle_id;
} dt_accels_search_state_t;
 
#define DT_ACCEL_SEARCH_RECENT_KEY "plugins/accel_search/recent_entries"
#define DT_ACCEL_SEARCH_RECENT_MAX 20
 
static void _shortcut_search_load_recent_entries(GtkListStore *store)
{
  if(IS_NULL_PTR(store)) return;
  gtk_list_store_clear(store);
 
  for(gint i = 0; i < DT_ACCEL_SEARCH_RECENT_MAX; i++)
  {
    gchar *entry = _recent_get ? _recent_get(i) : NULL;
    if(IS_NULL_PTR(entry) || entry[0] == '\0')
    {
      dt_free(entry);
      continue;
    }
    g_strstrip(entry);
    if(entry[0] == '\0')
    {
      dt_free(entry);
      continue;
    }
 
    // Keep split limit to 3 for backward compatibility with older persisted
    // values using "query<TAB>command<TAB>description".
    gchar **parts = g_strsplit(entry, "\t", 3);
    if(IS_NULL_PTR(parts[0]) || IS_NULL_PTR(parts[1])
       || parts[0][0] == '\0' || parts[1][0] == '\0')
    {
      g_strfreev(parts);
      dt_free(entry);
      continue;
    }
 
    const gchar *query = parts[0];
    const gchar *command = parts[1];
    gchar *display_command = _shortcut_search_trim_display_path(command);
    gchar *display = g_strdup_printf("%s%s%s", query, DT_ACCEL_SEARCH_INLINE_SEPARATOR, display_command);
 
    GtkTreeIter iter;
    gtk_list_store_append(store, &iter);
    gtk_list_store_set(store, &iter,
                       0, query,
                       1, command,
                       2, "",
                       3, display,
                       4, i,
                       -1);
    dt_free(display_command);
    dt_free(display);
    g_strfreev(parts);
    dt_free(entry);
  }
}
 
static gint _shortcut_search_recent_sort_func(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data)
{
  const dt_accels_search_state_t *state = (const dt_accels_search_state_t *)user_data;
  const gchar *search_text = "";
  if(!IS_NULL_PTR(state) && !IS_NULL_PTR(state->search_entry))
  {
    const gchar *entry_text = gtk_entry_get_text(GTK_ENTRY(state->search_entry));
    if(!IS_NULL_PTR(entry_text)) search_text = entry_text;
  }
 
  gchar *query_text = g_strdup(search_text);
  gchar *query_sep = g_strstr_len(query_text, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
  if(!IS_NULL_PTR(query_sep)) *query_sep = '\0';
  g_strstrip(query_text);
  gchar *query_ci = g_utf8_casefold(query_text, -1);
  const gboolean has_query = query_ci[0] != '\0';
 
  gchar *a_query = NULL, *a_command = NULL;
  gchar *b_query = NULL, *b_command = NULL;
  gint a_recent = G_MAXINT, b_recent = G_MAXINT;
  gtk_tree_model_get(model, a, 0, &a_query, 1, &a_command, 4, &a_recent, -1);
  gtk_tree_model_get(model, b, 0, &b_query, 1, &b_command, 4, &b_recent, -1);
 
  gchar *a_query_ci = g_utf8_casefold(!IS_NULL_PTR(a_query) ? a_query : "", -1);
  gchar *a_command_ci = g_utf8_casefold(!IS_NULL_PTR(a_command) ? a_command : "", -1);
  gchar *b_query_ci = g_utf8_casefold(!IS_NULL_PTR(b_query) ? b_query : "", -1);
  gchar *b_command_ci = g_utf8_casefold(!IS_NULL_PTR(b_command) ? b_command : "", -1);
 
  gint a_rank = 400000, b_rank = 400000;
  if(has_query)
  {
    if(g_str_has_prefix(a_query_ci, query_ci))
      a_rank = 0;
    else if(g_str_has_prefix(a_command_ci, query_ci))
      a_rank = 100000;
    else
    {
      const gchar *a_match_query = g_strstr_len(a_query_ci, -1, query_ci);
      if(!IS_NULL_PTR(a_match_query))
        a_rank = 200000 + (a_match_query - a_query_ci);
      else
      {
        const gchar *a_match_command = g_strstr_len(a_command_ci, -1, query_ci);
        if(!IS_NULL_PTR(a_match_command))
          a_rank = 300000 + (a_match_command - a_command_ci);
      }
    }
 
    if(g_str_has_prefix(b_query_ci, query_ci))
      b_rank = 0;
    else if(g_str_has_prefix(b_command_ci, query_ci))
      b_rank = 100000;
    else
    {
      const gchar *b_match_query = g_strstr_len(b_query_ci, -1, query_ci);
      if(!IS_NULL_PTR(b_match_query))
        b_rank = 200000 + (b_match_query - b_query_ci);
      else
      {
        const gchar *b_match_command = g_strstr_len(b_command_ci, -1, query_ci);
        if(!IS_NULL_PTR(b_match_command))
          b_rank = 300000 + (b_match_command - b_command_ci);
      }
    }
  }
 
  gint ret = a_rank - b_rank;
  if(ret == 0) ret = a_recent - b_recent;
  if(ret == 0) ret = g_utf8_collate(a_query_ci, b_query_ci);
  if(ret == 0) ret = g_utf8_collate(a_command_ci, b_command_ci);
 
  dt_free(b_command_ci);
  dt_free(b_query_ci);
  dt_free(a_command_ci);
  dt_free(a_query_ci);
  dt_free(b_command);
  dt_free(b_query);
  dt_free(a_command);
  dt_free(a_query);
  dt_free(query_ci);
  dt_free(query_text);
  return ret;
}
 
static void _shortcut_search_save_recent_entry(const char *query, const dt_shortcut_t *shortcut)
{
  if(IS_NULL_PTR(query)) return;
  if(IS_NULL_PTR(shortcut) || IS_NULL_PTR(shortcut->path) || shortcut->path[0] == '\0') return;
 
  gchar *trimmed = g_strdup(query);
  g_strstrip(trimmed);
  if(trimmed[0] == '\0')
  {
    dt_free(trimmed);
    return;
  }
 
  gchar *command = g_strdup(shortcut->path);
  g_strdelimit(trimmed, "\t\r\n", ' ');
  g_strdelimit(command, "\t\r\n", ' ');
 
  GPtrArray *entries = g_ptr_array_new_with_free_func(g_free);
  GPtrArray *entries_ci = g_ptr_array_new_with_free_func(g_free);
  g_ptr_array_add(entries, g_strdup_printf("%s\t%s", trimmed, command));
  g_ptr_array_add(entries_ci, g_utf8_casefold(trimmed, -1));
 
  for(gint i = 0; i < DT_ACCEL_SEARCH_RECENT_MAX && entries->len < DT_ACCEL_SEARCH_RECENT_MAX; i++)
  {
    gchar *candidate = _recent_get ? _recent_get(i) : NULL;
    if(IS_NULL_PTR(candidate) || candidate[0] == '\0')
    {
      dt_free(candidate);
      continue;
    }
    g_strstrip(candidate);
    if(candidate[0] == '\0')
    {
      dt_free(candidate);
      continue;
    }
 
    gchar **parts = g_strsplit(candidate, "\t", 3);
    if(IS_NULL_PTR(parts[0]) || IS_NULL_PTR(parts[1])
       || parts[0][0] == '\0' || parts[1][0] == '\0')
    {
      g_strfreev(parts);
      dt_free(candidate);
      continue;
    }
 
    const gchar *candidate_query = parts[0];
    const gchar *candidate_command = parts[1];
 
    gchar *candidate_ci = g_utf8_casefold(candidate_query, -1);
    gboolean found = FALSE;
    for(guint k = 0; k < entries_ci->len; k++)
    {
      const char *kept_ci = g_ptr_array_index(entries_ci, k);
      if(!g_strcmp0(kept_ci, candidate_ci))
      {
        found = TRUE;
        break;
      }
    }
    if(found)
    {
      dt_free(candidate_ci);
      g_strfreev(parts);
      dt_free(candidate);
      continue;
    }
    g_ptr_array_add(entries, g_strdup_printf("%s\t%s", candidate_query, candidate_command));
    g_ptr_array_add(entries_ci, candidate_ci);
    g_strfreev(parts);
    dt_free(candidate);
  }
 
  for(gint i = 0; i < DT_ACCEL_SEARCH_RECENT_MAX; i++)
  {
    const gchar *entry_value = (i < entries->len) ? (const gchar *)g_ptr_array_index(entries, i) : "";
    if(_recent_set) _recent_set(i, entry_value);
  }
 
  g_ptr_array_free(entries_ci, TRUE);
  g_ptr_array_free(entries, TRUE);
  dt_free(command);
  dt_free(trimmed);
}
 
typedef struct dt_accels_dispatch_state_t
{
  // Identify the shortcut by path + owning table rather than by raw pointer:
  // dispatch is deferred (idle/timeout) and the dt_shortcut_t may be freed and
  // rebuilt in between (view/module switches), so we re-resolve it when we fire.
  gchar *path;          // owned copy of the selected shortcut's path
  dt_accels_t *accels;  // table to re-resolve the shortcut from
  GtkWindow *main_window;
  guint retries;
} dt_accels_dispatch_state_t;
 
static gboolean _dispatch_selected_shortcut_idle(gpointer data);
 
// redo the suggestion list on each entry change
static void _search_entry_changed(GtkWidget *widget, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  state->selected = NULL;
  if(!IS_NULL_PTR(state->recent_entries))
    gtk_tree_sortable_sort_column_changed(GTK_TREE_SORTABLE(state->recent_entries));
  _find_and_rank_matches(GTK_TREE_MODEL(state->store), widget);
  gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(state->filter_model));
 
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(state->tree_view));
  gtk_tree_selection_unselect_all(selection);
 
  GtkTreeIter iter;
  gboolean has_iter = gtk_tree_model_get_iter_first(state->filter_model, &iter);
  GtkTreeIter fallback_iter = iter;
  GtkTreeIter selected_iter = iter;
  gboolean found_preferred = FALSE;
  if(has_iter && !IS_NULL_PTR(state->preferred_command) && state->preferred_command[0] != '\0')
  {
    do
    {
      dt_shortcut_t *shortcut = NULL;
      gtk_tree_model_get(state->filter_model, &iter, 1, &shortcut, -1);
      if(!IS_NULL_PTR(shortcut) && !IS_NULL_PTR(shortcut->path)
         && !g_strcmp0(shortcut->path, state->preferred_command))
      {
        selected_iter = iter;
        found_preferred = TRUE;
        break;
      }
    } while(gtk_tree_model_iter_next(state->filter_model, &iter));
  }
 
  if(has_iter)
  {
    GtkTreeIter *target_iter = found_preferred ? &selected_iter : &fallback_iter;
    GtkTreePath *path = gtk_tree_model_get_path(state->filter_model, target_iter);
    if(IS_NULL_PTR(path)) return;
    gtk_tree_selection_select_iter(selection, target_iter);
    gtk_tree_view_set_cursor(GTK_TREE_VIEW(state->tree_view), path, NULL, FALSE);
    gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(state->tree_view), path, NULL, FALSE, 0.f, 0.f);
    gtk_tree_path_free(path);
 
    gtk_tree_model_get(state->filter_model, target_iter, 1, &state->selected, -1);
  }
}
 
static gboolean _shortcut_search_recent_match_selected(GtkEntryCompletion *completion, GtkTreeModel *model,
                                                       GtkTreeIter *iter, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  gchar *query = NULL;
  gchar *command = NULL;
  gtk_tree_model_get(model, iter, 0, &query, 1, &command, -1);
 
  if(!IS_NULL_PTR(state->preferred_command))
  {
    dt_free(state->preferred_command);
    state->preferred_command = NULL;
  }
  if(!IS_NULL_PTR(command) && command[0] != '\0')
    state->preferred_command = g_strdup(command);
 
  if(!IS_NULL_PTR(query))
  {
    gtk_entry_set_text(GTK_ENTRY(state->search_entry), query);
    gtk_editable_set_position(GTK_EDITABLE(state->search_entry), -1);
  }
 
  dt_free(command);
  dt_free(query);
  return TRUE;
}
 
static gboolean _shortcut_search_recent_insert_prefix(GtkEntryCompletion *completion, gchar *prefix, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  if(IS_NULL_PTR(state) || IS_NULL_PTR(state->search_entry)) return FALSE;
  const gchar *entry_text = gtk_entry_get_text(GTK_ENTRY(state->search_entry));
  if(state->suppress_inline_once)
  {
    state->suppress_inline_once = FALSE;
    return TRUE;
  }
 
  GtkTreeModel *model = gtk_entry_completion_get_model(completion);
  if(IS_NULL_PTR(model)) return FALSE;
  if(!IS_NULL_PTR(entry_text) && entry_text[0] != '\0')
  {
    const gchar *last = g_utf8_find_prev_char(entry_text, entry_text + strlen(entry_text));
    const gunichar last_char = !IS_NULL_PTR(last) ? g_utf8_get_char(last) : 0;
    if(last_char != 0 && !g_unichar_isalnum(last_char))
      return TRUE;
  }
  gchar *query = g_strdup(!IS_NULL_PTR(entry_text) ? entry_text : "");
  gchar *sep = g_strstr_len(query, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
  if(!IS_NULL_PTR(sep)) *sep = '\0';
  g_strstrip(query);
  if(query[0] == '\0')
  {
    dt_free(query);
    return TRUE;
  }
 
  gchar *query_ci = g_utf8_casefold(query, -1);
  if(query_ci[0] == '\0')
  {
    dt_free(query_ci);
    dt_free(query);
    return TRUE;
  }
 
  gint best_rank = G_MAXINT;
  gint best_recent = G_MAXINT;
  gchar *best_command = NULL;
  gchar *best_display = NULL;
  gchar *best_query_ci = NULL;
  gchar *best_command_ci = NULL;
  const glong query_len = g_utf8_strlen(query_ci, -1);
 
  GtkTreeIter iter;
  if(gtk_tree_model_get_iter_first(model, &iter))
  {
    do
    {
      gchar *row_query = NULL;
      gchar *row_command = NULL;
      gchar *row_display = NULL;
      gint row_recent = G_MAXINT;
      gtk_tree_model_get(model, &iter, 0, &row_query, 1, &row_command, 3, &row_display, 4, &row_recent, -1);
      if(IS_NULL_PTR(row_query))
      {
        dt_free(row_display);
        dt_free(row_command);
        dt_free(row_query);
        continue;
      }
 
      gchar *row_query_ci = g_utf8_casefold(row_query, -1);
      gchar *row_command_ci = g_utf8_casefold(!IS_NULL_PTR(row_command) ? row_command : "", -1);
      gint row_rank = G_MAXINT;
      if(g_str_has_prefix(row_query_ci, query_ci))
      {
        // Prefer the shortest matching query for inline completion (ex: "exp" before "expo" for "ex").
        const glong row_query_len = g_utf8_strlen(row_query_ci, -1);
        row_rank = MAX((gint)(row_query_len - query_len), 0);
      }
      else if(g_str_has_prefix(row_command_ci, query_ci))
      {
        const glong row_command_len = g_utf8_strlen(row_command_ci, -1);
        row_rank = 100000 + MAX((gint)(row_command_len - query_len), 0);
      }
      else
      {
        const gchar *match_query = g_strstr_len(row_query_ci, -1, query_ci);
        if(!IS_NULL_PTR(match_query))
          row_rank = 200000 + (match_query - row_query_ci);
        else
        {
          const gchar *match_command = g_strstr_len(row_command_ci, -1, query_ci);
          if(!IS_NULL_PTR(match_command))
            row_rank = 300000 + (match_command - row_command_ci);
        }
      }
 
      if(row_rank < best_rank
         || (row_rank == best_rank && row_recent < best_recent)
         || (row_rank == best_rank && row_recent == best_recent
             && (!IS_NULL_PTR(best_query_ci) && g_utf8_collate(row_query_ci, best_query_ci) < 0))
         || (row_rank == best_rank && row_recent == best_recent
             && !IS_NULL_PTR(best_query_ci) && g_utf8_collate(row_query_ci, best_query_ci) == 0
             && (!IS_NULL_PTR(best_command_ci) && g_utf8_collate(row_command_ci, best_command_ci) < 0)))
      {
        best_rank = row_rank;
        best_recent = row_recent;
        if(!IS_NULL_PTR(best_command)) dt_free(best_command);
        if(!IS_NULL_PTR(best_display)) dt_free(best_display);
        if(!IS_NULL_PTR(best_query_ci)) dt_free(best_query_ci);
        if(!IS_NULL_PTR(best_command_ci)) dt_free(best_command_ci);
        best_command = g_strdup(!IS_NULL_PTR(row_command) ? row_command : "");
        best_display = g_strdup(!IS_NULL_PTR(row_display) ? row_display : row_query);
        best_query_ci = g_strdup(row_query_ci);
        best_command_ci = g_strdup(row_command_ci);
      }
 
      dt_free(row_command_ci);
      dt_free(row_query_ci);
      dt_free(row_display);
      dt_free(row_command);
      dt_free(row_query);
    } while(gtk_tree_model_iter_next(model, &iter));
  }
 
  if(!IS_NULL_PTR(best_command) && best_command[0] != '\0' && best_rank < G_MAXINT)
  {
    if(!IS_NULL_PTR(state->preferred_command))
    {
      dt_free(state->preferred_command);
      state->preferred_command = NULL;
    }
    state->preferred_command = g_strdup(best_command);
 
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(state->tree_view));
    GtkTreeIter filter_iter;
    if(gtk_tree_model_get_iter_first(state->filter_model, &filter_iter))
    {
      do
      {
        dt_shortcut_t *shortcut = NULL;
        gchar *shortcut_path_display = NULL;
        gtk_tree_model_get(state->filter_model, &filter_iter, 1, &shortcut, 0, &shortcut_path_display, -1);
        gchar *shortcut_trimmed = NULL;
        if(!IS_NULL_PTR(shortcut) && !IS_NULL_PTR(shortcut->path))
          shortcut_trimmed = _shortcut_search_trim_display_path(shortcut->path);
        if(!IS_NULL_PTR(shortcut) && !IS_NULL_PTR(shortcut->path)
           && (!g_strcmp0(shortcut->path, best_command)
               || (!IS_NULL_PTR(shortcut_trimmed) && !g_strcmp0(shortcut_trimmed, best_command))
               || (!IS_NULL_PTR(shortcut_path_display) && !g_strcmp0(shortcut_path_display, best_command))))
        {
          GtkTreePath *path = gtk_tree_model_get_path(state->filter_model, &filter_iter);
          if(IS_NULL_PTR(path))
          {
            dt_free(shortcut_trimmed);
            dt_free(shortcut_path_display);
            break;
          }
          gtk_tree_selection_select_iter(selection, &filter_iter);
          gtk_tree_view_set_cursor(GTK_TREE_VIEW(state->tree_view), path, NULL, FALSE);
          gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(state->tree_view), path, NULL, FALSE, 0.f, 0.f);
          gtk_tree_path_free(path);
          gtk_tree_model_get(state->filter_model, &filter_iter, 1, &state->selected, -1);
          dt_free(shortcut_trimmed);
          dt_free(shortcut_path_display);
          break;
        }
        dt_free(shortcut_trimmed);
        dt_free(shortcut_path_display);
      } while(gtk_tree_model_iter_next(state->filter_model, &filter_iter));
    }
 
    if(!IS_NULL_PTR(best_display) && best_display[0] != '\0')
    {
      const gchar *current = gtk_entry_get_text(GTK_ENTRY(state->search_entry));
      if(g_strcmp0(current, best_display))
      {
        gtk_entry_set_text(GTK_ENTRY(state->search_entry), best_display);
      }
      gtk_editable_set_position(GTK_EDITABLE(state->search_entry), g_utf8_strlen(query, -1));
      gtk_editable_select_region(GTK_EDITABLE(state->search_entry), g_utf8_strlen(query, -1), -1);
      dt_free(best_display);
      dt_free(best_command);
      dt_free(best_command_ci);
      dt_free(best_query_ci);
      dt_free(query_ci);
      dt_free(query);
      return TRUE;
    }
  }
 
  dt_free(best_display);
  dt_free(best_command);
  dt_free(best_command_ci);
  dt_free(best_query_ci);
  dt_free(query_ci);
  dt_free(query);
  return FALSE;
}
 
// fire action callbacks even when they don't have a keyboard shortcut defined
static gboolean _call_shortcut_cclosure(dt_shortcut_t *shortcut, GtkWindow *main_window, GClosure *closure)
{
  /*
    Accel callback signature is:
    `GtkAccelGroup *group, GObject *acceleratable, guint keyval, GdkModifierType mods, gpointer user_data`
    but `user_data` is handled in the closure already
  */
  GValue params[4] = { G_VALUE_INIT };
 
  g_value_init(&params[0], G_TYPE_POINTER);
  g_value_set_pointer(&params[0], shortcut->accel_group);
 
  g_value_init(&params[1], G_TYPE_POINTER);
  g_value_set_pointer(&params[1], G_OBJECT(main_window));
 
  g_value_init(&params[2], G_TYPE_UINT);
  g_value_set_uint(&params[2], shortcut->key);
 
  g_value_init(&params[3], G_TYPE_UINT);
  g_value_set_uint(&params[3], shortcut->mods);
 
  GValue ret = G_VALUE_INIT;
  g_value_init (&ret, G_TYPE_BOOLEAN);
 
  GClosure *active_closure = !IS_NULL_PTR(closure) ? closure : dt_shortcut_get_closure(shortcut);
  if(IS_NULL_PTR(active_closure))
  {
    for(int k = 0; k < 4; k++) g_value_unset(&params[k]);
    g_value_unset(&ret);
    return FALSE;
  }
 
  g_closure_invoke(active_closure, &ret, 4, params, NULL);
  const gboolean handled = g_value_get_boolean(&ret);
 
  for(int k = 0; k < 4; k++) g_value_unset(&params[k]);
  g_value_unset(&ret);
 
  return handled;
}
 
static void _dispatch_selected_shortcut(dt_accels_dispatch_state_t *state)
{
  // Re-resolve the shortcut from the live hashtable by path. The dispatch was
  // deferred, and between selection and now the shortcut may have been rebuilt or
  // freed (e.g. switching darkroom modules/views rebuilds the accel table). Using
  // a stored raw pointer here caused a use-after-free crash (reading a freed
  // GClosure while walking shortcut->closure).
  dt_shortcut_t *shortcut = NULL;
  if(!IS_NULL_PTR(state->accels) && !IS_NULL_PTR(state->accels->acceleratables) && !IS_NULL_PTR(state->path))
    shortcut = (dt_shortcut_t *)g_hash_table_lookup(state->accels->acceleratables, state->path);
 
  if(IS_NULL_PTR(shortcut))
  {
    dt_widget_log("[accel_search] dispatch skipped: shortcut '%s' no longer exists\n",
             !IS_NULL_PTR(state->path) ? state->path : "<null>");
    return;
  }
 
  PayloadClosure *payload = NULL;
  PayloadClosure *payload_in_main_window = NULL;
  if(!IS_NULL_PTR(shortcut->closure))
  {
    for(GList *item = g_list_last(shortcut->closure); item; item = g_list_previous(item))
    {
      PayloadClosure *candidate = (PayloadClosure *)item->data;
      if(IS_NULL_PTR(candidate) || IS_NULL_PTR(candidate->base)) continue;
      /* `candidate->widget` is what the registering caller declared, and the weak pointer has already
       * cleared it if that widget has since been destroyed. Never re-derive it from
       * `candidate->base->data`, which is an opaque payload of unknown type. */
      if(!IS_NULL_PTR(candidate->widget))
      {
        GtkWidget *candidate_widget = candidate->widget;
        const gboolean in_main_window = IS_NULL_PTR(state->main_window)
                                        || gtk_widget_is_ancestor(candidate_widget, GTK_WIDGET(state->main_window));
        if(in_main_window && IS_NULL_PTR(payload_in_main_window))
          payload_in_main_window = candidate;
        if(in_main_window && gtk_widget_get_visible(candidate_widget) && gtk_widget_get_mapped(candidate_widget))
        {
          payload = candidate;
          break;
        }
      }
    }
  }
  if(IS_NULL_PTR(payload)) payload = payload_in_main_window;
  if(IS_NULL_PTR(payload)) payload = dt_shortcut_get_payload_closure(shortcut);
 
  GtkWidget *target_widget = NULL;
  if(!IS_NULL_PTR(payload) && !IS_NULL_PTR(payload->widget))
    target_widget = payload->widget;
  else if(!IS_NULL_PTR(shortcut->widget))
    target_widget = shortcut->widget;
 
  // Keep module/control focus actions in their UI context.
  // Refocusing center here would move focus to the main view (thumbtable/center)
  // and can race with deferred control focus in action callbacks.
  if(IS_NULL_PTR(target_widget) && _refocus_handler)
    _refocus_handler();
 
  // The action we are about to invoke can destroy modules and free this very
  // shortcut and/or its target widget. Capture everything we still need afterwards
  // BEFORE invoking: a stable path (state->path is owned by the dispatch state and
  // outlives this call) and description for logging, plus weak pointers so a
  // destroyed widget reads back as NULL. After the invoke `shortcut` must be
  // treated as potentially dangling and never dereferenced again.
  const char *path = !IS_NULL_PTR(state->path) ? state->path : "<null>";
  gchar *desc = g_strdup(!IS_NULL_PTR(shortcut->description) ? shortcut->description : "<null>");
  GtkWidget *shortcut_widget = shortcut->widget;
  if(!IS_NULL_PTR(target_widget))
    g_object_add_weak_pointer(G_OBJECT(target_widget), (gpointer *)&target_widget);
  if(!IS_NULL_PTR(shortcut_widget))
    g_object_add_weak_pointer(G_OBJECT(shortcut_widget), (gpointer *)&shortcut_widget);
 
  GClosure *closure = !IS_NULL_PTR(payload) ? payload->base : dt_shortcut_get_closure(shortcut);
  if(!IS_NULL_PTR(closure))
  {
    const gboolean handled = _call_shortcut_cclosure(shortcut, state->main_window, closure);
    dt_widget_log("[accel_search] dispatch closure target='%s' description='%s' handled=%d\n",
             path, desc, handled);
  }
  else if(!IS_NULL_PTR(shortcut_widget))
  {
    const gboolean activated = gtk_widget_activate(shortcut_widget);
    dt_widget_log("[accel_search] dispatch widget target='%s' description='%s' activated=%d widget=%s\n",
             path, desc, activated,
             !IS_NULL_PTR(shortcut_widget) ? gtk_widget_get_name(shortcut_widget) : "<destroyed>");
  }
  else
  {
    dt_widget_log("[accel_search] dispatch failed: no callable target for '%s' description='%s'\n",
             path, desc);
  }
 
  // From here on, do not dereference `shortcut`: it may have been freed by the
  // action above. target_widget / shortcut_widget are NULL if they were destroyed.
 
  GtkWidget *focused_widget = NULL;
  if(!IS_NULL_PTR(state->main_window))
    focused_widget = gtk_window_get_focus(state->main_window);
  // no GUI-global test needed: the accessor owns the register, it does not dereference darktable.gui
  GtkWidget *scroll_focused_widget = dt_widget_scroll_focus();
 
  gboolean target_focused_gtk = FALSE;
  gboolean target_focused_scroll = FALSE;
  if(!IS_NULL_PTR(target_widget))
  {
    if(!IS_NULL_PTR(focused_widget))
    {
      target_focused_gtk = focused_widget == target_widget
                           || gtk_widget_is_ancestor(focused_widget, target_widget)
                           || gtk_widget_is_ancestor(target_widget, focused_widget);
    }
    if(!IS_NULL_PTR(scroll_focused_widget))
    {
      target_focused_scroll = scroll_focused_widget == target_widget
                              || gtk_widget_is_ancestor(scroll_focused_widget, target_widget)
                              || gtk_widget_is_ancestor(target_widget, scroll_focused_widget);
    }
  }
  const gboolean target_focused = target_focused_gtk || target_focused_scroll;
 
  dt_widget_log("[accel_search] focus check (pre-idle) target='%s' target_widget=%s(%p) gtk_focus=%s(%p)"
           " scroll_focus=%s(%p) target_focused_gtk=%d target_focused_scroll=%d target_focused=%d\n",
           path,
           !IS_NULL_PTR(target_widget) ? gtk_widget_get_name(target_widget) : "<null>",
           (void *)target_widget,
           !IS_NULL_PTR(focused_widget) ? gtk_widget_get_name(focused_widget) : "<null>",
           (void *)focused_widget,
           !IS_NULL_PTR(scroll_focused_widget) ? gtk_widget_get_name(scroll_focused_widget) : "<null>",
           (void *)scroll_focused_widget,
           target_focused_gtk, target_focused_scroll, target_focused);
 
  // First dispatch can still hit an outdated control instance while module tabs
  // are being switched/rebuilt. Retry once shortly after for Bauhaus controls.
  if(!target_focused && !IS_NULL_PTR(target_widget) && state->retries < 1
     && !g_strcmp0(G_OBJECT_TYPE_NAME(target_widget), "DtBauhausWidget"))
  {
    dt_accels_dispatch_state_t *retry = g_malloc0(sizeof(*retry));
    retry->path = g_strdup(path);
    retry->accels = state->accels;
    retry->main_window = state->main_window;
    retry->retries = state->retries + 1;
    dt_widget_log("[accel_search] dispatch retry scheduled target='%s' retry=%u\n",
             path, retry->retries);
    g_timeout_add_full(G_PRIORITY_DEFAULT, DT_ACCEL_SEARCH_DISPATCH_RETRY_DELAY_MS,
                       _dispatch_selected_shortcut_idle, retry, NULL);
  }
 
  // Release the weak pointers (no-op if the widget was already destroyed and the
  // pointer NULLed) and the captured description.
  if(!IS_NULL_PTR(target_widget))
    g_object_remove_weak_pointer(G_OBJECT(target_widget), (gpointer *)&target_widget);
  if(!IS_NULL_PTR(shortcut_widget))
    g_object_remove_weak_pointer(G_OBJECT(shortcut_widget), (gpointer *)&shortcut_widget);
  g_free(desc);
}
 
static gboolean _dispatch_selected_shortcut_idle(gpointer data)
{
  dt_accels_dispatch_state_t *state = (dt_accels_dispatch_state_t *)data;
  _dispatch_selected_shortcut(state);
  g_free(state->path);
  dt_free(state);
  return G_SOURCE_REMOVE;
}
 
static gboolean _shortcut_search_visible(GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
{
  int rank = -1;
  gtk_tree_model_get(model, iter, 2, &rank, -1);
  return rank >= 0;
}
 
static gboolean _shortcut_search_recent_completion_match(GtkEntryCompletion *completion, const gchar *key,
                                                         GtkTreeIter *iter, gpointer user_data)
{
  if(IS_NULL_PTR(key) || key[0] == '\0') return FALSE;
 
  gchar *key_query = g_strdup(key);
  gchar *key_sep = g_strstr_len(key_query, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
  if(!IS_NULL_PTR(key_sep)) *key_sep = '\0';
  g_strstrip(key_query);
  if(key_query[0] == '\0')
  {
    dt_free(key_query);
    return FALSE;
  }
 
  GtkTreeModel *model = gtk_entry_completion_get_model(completion);
  if(IS_NULL_PTR(model))
  {
    dt_free(key_query);
    return FALSE;
  }
 
  gchar *query = NULL;
  gtk_tree_model_get(model, iter, 0, &query, -1);
  if(IS_NULL_PTR(query))
  {
    dt_free(key_query);
    return FALSE;
  }
 
  gchar *key_ci = g_utf8_casefold(key_query, -1);
  gchar *query_ci = g_utf8_casefold(query, -1);
  const gboolean match = !IS_NULL_PTR(g_strrstr(query_ci, key_ci));
 
  dt_free(query_ci);
  dt_free(key_ci);
  dt_free(key_query);
  dt_free(query);
  return match;
}
 
static gboolean _queue_action_from_shortcut(dt_shortcut_t *shortcut, GtkWidget *window,
                                            dt_accels_search_state_t *state)
{
  const gchar *query_text = gtk_entry_get_text(GTK_ENTRY(state->search_entry));
  gchar *query = g_strdup(!IS_NULL_PTR(query_text) ? query_text : "");
  gchar *query_sep = g_strstr_len(query, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
  if(!IS_NULL_PTR(query_sep)) *query_sep = '\0';
  g_strstrip(query);
  dt_widget_log("[accel_search] validate query='%s' shortcut='%s' description='%s'\n",
           query,
           !IS_NULL_PTR(shortcut) && !IS_NULL_PTR(shortcut->path) ? shortcut->path : "<null>",
           !IS_NULL_PTR(shortcut) && !IS_NULL_PTR(shortcut->description) ? shortcut->description : "<null>");
  _shortcut_search_save_recent_entry(query, shortcut);
  dt_free(query);
  state->selected = shortcut;
  state->response = GTK_RESPONSE_ACCEPT;
  gtk_widget_destroy(window);
  return TRUE;
}
 
static void _shortcut_search_selection_changed(GtkTreeSelection *selection, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  GtkTreeIter iter;
  if(gtk_tree_selection_get_selected(selection, NULL, &iter))
  {
    gtk_tree_model_get(state->filter_model, &iter, 1, &state->selected, -1);
  }
  else
  {
    state->selected = NULL;
  }
}
 
static gboolean _shortcut_search_row_activated(GtkTreeView *tree_view, GtkTreePath *path,
                                               GtkTreeViewColumn *column, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  GtkTreeIter iter;
  if(!gtk_tree_model_get_iter(state->filter_model, &iter, path)) return FALSE;
 
  dt_shortcut_t *shortcut = NULL;
  gtk_tree_model_get(state->filter_model, &iter, 1, &shortcut, -1);
  return _queue_action_from_shortcut(shortcut, state->window, state);
}
 
static gboolean _shortcut_search_move_selection(dt_accels_search_state_t *state, const gboolean forward)
{
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(state->tree_view));
  GtkTreeIter iter;
  if(!gtk_tree_selection_get_selected(selection, NULL, &iter))
  {
    if(!gtk_tree_model_get_iter_first(state->filter_model, &iter)) return TRUE;
  }
  else if(forward)
  {
    if(!gtk_tree_model_iter_next(state->filter_model, &iter)) return TRUE;
  }
  else
  {
    GtkTreePath *path = gtk_tree_model_get_path(state->filter_model, &iter);
    if(IS_NULL_PTR(path)) return TRUE;
    if(!gtk_tree_path_prev(path))
    {
      gtk_tree_path_free(path);
      return TRUE;
    }
 
    if(!gtk_tree_model_get_iter(state->filter_model, &iter, path))
    {
      gtk_tree_path_free(path);
      return TRUE;
    }
    gtk_tree_path_free(path);
  }
 
  GtkTreePath *path = gtk_tree_model_get_path(state->filter_model, &iter);
  if(IS_NULL_PTR(path)) return TRUE;
  gtk_tree_selection_select_iter(selection, &iter);
  gtk_tree_view_set_cursor(GTK_TREE_VIEW(state->tree_view), path, NULL, FALSE);
  gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(state->tree_view), path, NULL, FALSE, 0.f, 0.f);
  gtk_tree_path_free(path);
  gtk_tree_model_get(state->filter_model, &iter, 1, &state->selected, -1);
  return TRUE;
}
 
static gboolean _search_entry_restore_space_idle(gpointer user_data)
{
  // Run after GTK key processing/completion so we can enforce "<typed query> + space".
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  state->pending_space_idle_id = 0;
  if(IS_NULL_PTR(state->search_entry) || IS_NULL_PTR(state->pending_space_query))
    return G_SOURCE_REMOVE;
 
  gchar *with_space = g_strconcat(state->pending_space_query, " ", NULL);
  gtk_entry_set_text(GTK_ENTRY(state->search_entry), with_space);
  gtk_editable_set_position(GTK_EDITABLE(state->search_entry), -1);
  dt_free(with_space);
  dt_free(state->pending_space_query);
  state->pending_space_query = NULL;
  return G_SOURCE_REMOVE;
}
 
static gboolean _search_entry_key_pressed(GtkWidget *widget __attribute__((unused)),
                                          GdkEventKey *event, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  guint key = dt_keys_mainpad_alternatives(event->keyval);
 
  if(key == GDK_KEY_Escape)
  {
    state->response = GTK_RESPONSE_CANCEL;
    gtk_widget_destroy(state->window);
    return TRUE;
  }
 
  if(key == GDK_KEY_Down)
    return _shortcut_search_move_selection(state, TRUE);
  if(key == GDK_KEY_Up)
    return _shortcut_search_move_selection(state, FALSE);
  if(key == GDK_KEY_Return)
  {
    dt_shortcut_t *shortcut = state->selected;
    gchar *command = NULL;
    if(IS_NULL_PTR(shortcut))
    {
      const gchar *entry_text = gtk_entry_get_text(GTK_ENTRY(state->search_entry));
      if(!IS_NULL_PTR(entry_text) && entry_text[0] != '\0')
      {
        const gchar *sep = g_strstr_len(entry_text, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
        command = !IS_NULL_PTR(sep)
                    ? g_strdup(sep + strlen(DT_ACCEL_SEARCH_INLINE_SEPARATOR))
                    : g_strdup(entry_text);
      }
 
      if(!IS_NULL_PTR(command))
      {
        g_strstrip(command);
        if(command[0] != '\0')
        {
          GtkTreeIter iter;
          if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(state->store), &iter))
          {
            do
            {
              dt_shortcut_t *candidate = NULL;
              gchar *candidate_path = NULL;
              gtk_tree_model_get(GTK_TREE_MODEL(state->store), &iter, 1, &candidate, 0, &candidate_path, -1);
              gchar *candidate_display_path = NULL;
              if(!IS_NULL_PTR(candidate) && !IS_NULL_PTR(candidate->path))
                candidate_display_path = _shortcut_search_trim_display_path(candidate->path);
              if(!IS_NULL_PTR(candidate) && !IS_NULL_PTR(candidate->path)
                 && (!g_strcmp0(command, candidate->path)
                     || !g_strcmp0(command, candidate_path)
                     || (!IS_NULL_PTR(candidate_display_path)
                         && !g_strcmp0(command, candidate_display_path))))
              {
                shortcut = candidate;
                dt_free(candidate_path);
                dt_free(candidate_display_path);
                break;
              }
              dt_free(candidate_path);
              dt_free(candidate_display_path);
            } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(state->store), &iter));
          }
        }
        dt_free(command);
      }
    }
 
    if(!IS_NULL_PTR(shortcut))
      return _queue_action_from_shortcut(shortcut, state->window, state);
    return TRUE;
  }
 
  if(key == GDK_KEY_space)
  {
    // Hack: GTK entry completion can be too aggressive here and may treat Space as
    // suggestion acceptance. Restore "<typed query> + space" in idle to preserve
    // user input semantics for multi-term search.
 
    const gchar *entry_text = gtk_entry_get_text(GTK_ENTRY(state->search_entry));
    if(!IS_NULL_PTR(entry_text))
    {
      gchar *query_only = NULL;
      gint sel_start = 0, sel_end = 0;
      const gboolean has_selection = gtk_editable_get_selection_bounds(GTK_EDITABLE(state->search_entry),
                                                                       &sel_start, &sel_end);
      const gint cursor_chars = has_selection ? sel_start
                                              : gtk_editable_get_position(GTK_EDITABLE(state->search_entry));
      const gint text_chars = g_utf8_strlen(entry_text, -1);
      if(cursor_chars >= 0 && cursor_chars <= text_chars)
        query_only = g_utf8_substring(entry_text, 0, cursor_chars);
      else
        query_only = g_strdup(entry_text);
 
      const gchar *sep = g_strstr_len(query_only, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
      if(!IS_NULL_PTR(sep))
        *((gchar *)sep) = '\0';
 
      if(!IS_NULL_PTR(state->pending_space_query)) dt_free(state->pending_space_query);
      state->pending_space_query = query_only;
    }
 
    if(state->pending_space_idle_id != 0) g_source_remove(state->pending_space_idle_id);
    state->pending_space_idle_id = g_idle_add(_search_entry_restore_space_idle, state);
    return TRUE;
  }
 
  gunichar key_char = gdk_keyval_to_unicode(event->keyval);
  const gboolean is_alnum = key_char != 0 && g_unichar_isalnum(key_char);
  if(!is_alnum)
  {
    // Non-alphanumeric keys (space, punctuation, etc.) should not trigger inline completion insertion.
    // Mark one completion cycle as suppressed so GTK inserts the typed key in the entry instead.
    state->suppress_inline_once = TRUE;
 
    const gchar *entry_text = gtk_entry_get_text(GTK_ENTRY(state->search_entry));
    if(!IS_NULL_PTR(entry_text))
    {
      const gchar *sep = g_strstr_len(entry_text, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
      if(!IS_NULL_PTR(sep))
      {
        const gint position = gtk_editable_get_position(GTK_EDITABLE(state->search_entry));
        const gsize query_len = sep - entry_text;
        gchar *query_only = g_strndup(entry_text, query_len);
 
        gtk_entry_set_text(GTK_ENTRY(state->search_entry), query_only);
        gtk_editable_set_position(GTK_EDITABLE(state->search_entry), MIN(position, (gint)query_len));
        dt_free(query_only);
        return FALSE;
      }
    }
  }
  return FALSE;
}
 
static gboolean _search_entry_button_pressed(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  if(event->button != 1) return FALSE;
  if(IS_NULL_PTR(state) || IS_NULL_PTR(state->search_entry)) return FALSE;
 
  const gchar *entry_text = gtk_entry_get_text(GTK_ENTRY(state->search_entry));
  if(IS_NULL_PTR(entry_text)) return FALSE;
 
  const gchar *sep = g_strstr_len(entry_text, -1, DT_ACCEL_SEARCH_INLINE_SEPARATOR);
  if(IS_NULL_PTR(sep)) return FALSE;
 
  const gsize query_len = sep - entry_text;
  gchar *query = g_strndup(entry_text, query_len);
  state->suppress_inline_once = TRUE;
  gtk_entry_set_text(GTK_ENTRY(state->search_entry), query);
  gtk_editable_set_position(GTK_EDITABLE(state->search_entry), -1);
  dt_free(query);
  return FALSE;
}
 
static gboolean _shortcut_search_window_key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
{
  return _search_entry_key_pressed(widget, event, user_data);
}
 
static gboolean _shortcut_search_button_press(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  GtkAllocation allocation = { 0 };
  gtk_widget_get_allocation(widget, &allocation);
 
  gboolean click_inside = FALSE;
  GdkWindow *win = gtk_widget_get_window(widget);
  if(!IS_NULL_PTR(win))
  {
    gint wx = 0, wy = 0;
    gdk_window_get_origin(win, &wx, &wy);
    const gdouble x0 = (gdouble)wx;
    const gdouble y0 = (gdouble)wy;
    const gdouble x1 = x0 + (gdouble)allocation.width;
    const gdouble y1 = y0 + (gdouble)allocation.height;
    click_inside = (event->x_root >= x0 && event->x_root < x1
                    && event->y_root >= y0 && event->y_root < y1);
  }
  else
  {
    click_inside = (event->x >= 0.0 && event->x < allocation.width
                    && event->y >= 0.0 && event->y < allocation.height);
  }
 
  if(click_inside) return FALSE;
 
  state->response = GTK_RESPONSE_CANCEL;
  gtk_widget_destroy(widget);
  return TRUE;
}
 
static void _shortcut_search_destroy(GtkWidget *widget, gpointer user_data)
{
  dt_accels_search_state_t *state = (dt_accels_search_state_t *)user_data;
  if(state->pending_space_idle_id != 0)
  {
    g_source_remove(state->pending_space_idle_id);
    state->pending_space_idle_id = 0;
  }
  if(!IS_NULL_PTR(state->pending_space_query))
  {
    dt_free(state->pending_space_query);
    state->pending_space_query = NULL;
  }
  gtk_grab_remove(widget);
  if(state->window == widget) state->window = NULL;
  if(!IS_NULL_PTR(state->loop)) g_main_loop_quit(state->loop);
}
 
void dt_accels_search(dt_accels_t *accels, GtkWindow *main_window, GtkWidget *anchor)
{
  GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), _("Ansel - Search accelerators"));
 
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(window);
#endif
 
  const int dialog_width = 800;
  const int dialog_height = 0;
 
  gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
  gtk_window_set_modal(GTK_WINDOW(window), FALSE);
  gtk_window_set_transient_for(GTK_WINDOW(window), main_window);
  gtk_window_set_attached_to(GTK_WINDOW(window), GTK_WIDGET(main_window));
  gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
  gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
  gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
  gtk_window_set_accept_focus(GTK_WINDOW(window), TRUE);
  gtk_window_set_focus_on_map(GTK_WINDOW(window), TRUE);
  gtk_window_set_default_size(GTK_WINDOW(window), dialog_width, dialog_height);
  gtk_widget_set_name(window, "shortcut-search-dialog");
  gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
 
  // Build the list of currently-relevant shortcut pathes
  GtkListStore *store = gtk_list_store_new(7, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT);
  g_hash_table_foreach(accels->acceleratables, _for_each_path_create_treeview_row, store);
 
  GMainLoop *loop = g_main_loop_new(NULL, FALSE);
  dt_accels_search_state_t state = {
    .store = store,
    .filter_model = NULL,
    .recent_entries = NULL,
    .main_window = main_window,
    .search_entry = NULL,
    .tree_view = NULL,
    .window = window,
    .loop = loop,
    .response = GTK_RESPONSE_CANCEL,
    .selected = NULL,
    .preferred_command = NULL,
    .suppress_inline_once = FALSE,
    .pending_space_query = NULL,
    .pending_space_idle_id = 0
  };
 
  // Sort the filtered model by relevance
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), 2,
                                  (GtkTreeIterCompareFunc)_sort_model_by_relevance_func, NULL, NULL);
  gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 2, GTK_SORT_ASCENDING);
 
  // Build the search entry
  GtkWidget *search_entry = gtk_search_entry_new();
  state.search_entry = search_entry;
  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  gtk_container_add(GTK_CONTAINER(window), box);
  GtkWidget *search_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_box_pack_start(GTK_BOX(box), search_row, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(search_row), search_entry, TRUE, TRUE, 0);
 
  GtkTreeModel *filter_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL);
  state.filter_model = filter_model;
  gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model),
                                         _shortcut_search_visible, NULL, NULL);
 
  GtkEntryCompletion *completion = gtk_entry_completion_new();
  GtkListStore *recent_entries = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
                                                    G_TYPE_INT);
  state.recent_entries = recent_entries;
  _shortcut_search_load_recent_entries(recent_entries);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(recent_entries), 4,
                                  (GtkTreeIterCompareFunc)_shortcut_search_recent_sort_func, &state, NULL);
  gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(recent_entries), 4, GTK_SORT_ASCENDING);
  gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(recent_entries));
  gtk_entry_completion_set_text_column(completion, 3);
  gtk_entry_completion_set_inline_completion(completion, TRUE);
  gtk_entry_completion_set_inline_selection(completion, TRUE);
  gtk_entry_completion_set_popup_completion(completion, FALSE);
  gtk_entry_completion_set_match_func(completion, _shortcut_search_recent_completion_match, NULL, NULL);
  gtk_entry_set_completion(GTK_ENTRY(search_entry), completion);
  g_object_unref(completion);
 
  GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
                                 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
  gtk_widget_set_size_request(scrolled, dialog_width, 320);
  dt_gui_add_class(scrolled, "dt_recessed_scroll");
  gtk_box_pack_start(GTK_BOX(box), scrolled, TRUE, TRUE, 0);
 
  GtkWidget *tree_view = gtk_tree_view_new_with_model(filter_model);
  state.tree_view = tree_view;
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_view), FALSE);
  gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree_view), FALSE);
  gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(tree_view), FALSE);
  gtk_tree_view_set_activate_on_single_click(GTK_TREE_VIEW(tree_view), TRUE);
  gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(tree_view), 0);
  gtk_widget_set_hexpand(tree_view, TRUE);
  gtk_widget_set_vexpand(tree_view, TRUE);
  gtk_container_add(GTK_CONTAINER(scrolled), tree_view);
 
  GtkCellRenderer *txt = gtk_cell_renderer_text_new();
  g_object_set(txt, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, "max-width-chars", 70, NULL);
  GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes(NULL, txt, "text", 0, NULL);
  gtk_tree_view_column_set_expand(column, FALSE);
  gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
  gtk_tree_view_column_set_min_width(column, 360);
  gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 
  GtkCellRenderer *accel = gtk_cell_renderer_accel_new();
  g_object_set(accel, "editable", FALSE, "accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER, NULL);
  column = gtk_tree_view_column_new_with_attributes(NULL, accel, "accel-key", 5, "accel-mods", 6, NULL);
  gtk_tree_view_column_set_min_width(column, 140);
  gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 
  GtkCellRenderer *description = gtk_cell_renderer_text_new();
  g_object_set(description, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL);
  column = gtk_tree_view_column_new_with_attributes(NULL, description, "text", 3, NULL);
  gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
  gtk_tree_view_column_set_min_width(column, 280);
  gtk_tree_view_column_set_expand(column, TRUE);
  gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
 
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
  gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
 
  // Wire callbacks
  g_signal_connect(G_OBJECT(search_entry), "changed", G_CALLBACK(_search_entry_changed), &state);
  g_signal_connect(G_OBJECT(completion), "match-selected", G_CALLBACK(_shortcut_search_recent_match_selected), &state);
  g_signal_connect(G_OBJECT(completion), "insert-prefix", G_CALLBACK(_shortcut_search_recent_insert_prefix), &state);
  g_signal_connect(G_OBJECT(search_entry), "button-press-event", G_CALLBACK(_search_entry_button_pressed), &state);
  g_signal_connect(G_OBJECT(search_entry), "key-press-event", G_CALLBACK(_search_entry_key_pressed), &state);
  g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(_shortcut_search_selection_changed), &state);
  g_signal_connect(G_OBJECT(tree_view), "row-activated", G_CALLBACK(_shortcut_search_row_activated), &state);
  g_signal_connect(G_OBJECT(window), "key-press-event", G_CALLBACK(_shortcut_search_window_key_pressed), &state);
  g_signal_connect(G_OBJECT(window), "button-press-event", G_CALLBACK(_shortcut_search_button_press), &state);
  g_signal_connect(G_OBJECT(window), "button-release-event", G_CALLBACK(_shortcut_search_button_press), &state);
  g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(_shortcut_search_destroy), &state);
 
  _search_entry_changed(search_entry, &state);
 
  // Center horizontally against the current Ansel window position.
  GtkAllocation main_alloc = { 0 };
  gtk_widget_get_allocation(GTK_WIDGET(main_window), &main_alloc);
  gint main_x = 0, main_y = 0;
  GdkWindow *main_gdk_window = gtk_widget_get_window(GTK_WIDGET(main_window));
  if(!IS_NULL_PTR(main_gdk_window))
    gdk_window_get_origin(main_gdk_window, &main_x, &main_y);
  else
    gtk_window_get_position(main_window, &main_x, &main_y);
 
  // How far down the host wants this window is the host's business.
  const gint top_panel_height = _top_offset_handler ? _top_offset_handler() : 0;
 
  const gint window_x = main_x + MAX((main_alloc.width - dialog_width) / 2, 0);
  const gint window_y = main_y + MAX(top_panel_height, 0);
  gtk_window_move(GTK_WINDOW(window), window_x, window_y);
 
  gtk_widget_realize(window);
  gtk_widget_show_all(window);
  gtk_grab_add(window);
  gdk_window_focus(gtk_widget_get_window(window), GDK_CURRENT_TIME);
  gtk_window_set_focus(GTK_WINDOW(window), search_entry);
  gtk_widget_grab_focus(search_entry);
 
  g_main_loop_run(loop);
  g_main_loop_unref(loop);
  if(state.response == GTK_RESPONSE_ACCEPT && !IS_NULL_PTR(state.selected))
  {
    dt_accels_dispatch_state_t *dispatch = g_malloc0(sizeof(*dispatch));
    dispatch->path = g_strdup(state.selected->path);
    dispatch->accels = !IS_NULL_PTR(state.selected->accels)
                       ? state.selected->accels
                       : dt_accels_get_global();
    dispatch->main_window = main_window;
    g_idle_add(_dispatch_selected_shortcut_idle, dispatch);
  }
  if(!IS_NULL_PTR(state.window)) gtk_widget_destroy(state.window);
  if(!IS_NULL_PTR(state.preferred_command)) dt_free(state.preferred_command);
  if(!IS_NULL_PTR(state.recent_entries)) g_object_unref(state.recent_entries);
  g_object_unref(store);
}
 
 
static gboolean _text_entry_focus_in_event(GtkWidget *self, GdkEventFocus event, gpointer user_data)
{
  dt_accels_disable(dt_accels_get_global(), TRUE);
  return FALSE;
}
 
static gboolean _text_entry_focus_out_event(GtkWidget *self, GdkEventFocus event, gpointer user_data)
{
  dt_accels_disable(dt_accels_get_global(), FALSE);
  return FALSE;
}
 
static gboolean _text_entry_key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
{
  if(event->keyval == GDK_KEY_Escape)
  {
    dt_widget_refocus();
    return TRUE;
  }
  return FALSE;
}
 
void dt_accels_disconnect_on_text_input(GtkWidget *widget)
{
  gtk_widget_add_events(widget, GDK_FOCUS_CHANGE_MASK);
  g_signal_connect(G_OBJECT(widget), "focus-in-event", G_CALLBACK(_text_entry_focus_in_event), NULL);
  g_signal_connect(G_OBJECT(widget), "focus-out-event", G_CALLBACK(_text_entry_focus_out_event), NULL);
  g_signal_connect(G_OBJECT(widget), "key-press-event", G_CALLBACK(_text_entry_key_pressed), NULL);
}