accelerators.h

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2011-2013 Jérémy Rosen.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012, 2014, 2016-2017 Tobias Ellinghaus.
    Copyright (C) 2016 Roman Lebedev.
    Copyright (C) 2019-2020 Aldric Renaudin.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020-2022 Diederik Ter Rahe.
    Copyright (C) 2020 Heiko Bauke.
    Copyright (C) 2020 Hubert Kowalski.
    Copyright (C) 2020-2021 Pascal Obry.
    Copyright (C) 2021 Bill Ferguson.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023, 2025 Aurélien PIERRE.
    
    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 <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#ifdef GDK_WINDOWING_WAYLAND
#include <gdk/gdkwayland.h>
#endif
 
#include "common/dtpthread.h"
 
#define DT_ACCELS_WIDGET_SHORTCUT_KEY "dt-accel-shortcut"
#define DT_ACCELS_WIDGET_TOOLTIP_DISABLED_KEY "dt-accel-tooltip-disabled"
 
#pragma once
 
typedef struct dt_accels_t
{
  char *config_file;
  GtkAccelGroup *global_accels;     // used, aka init it and free it
  GtkAccelGroup *darkroom_accels;   // darkroom-specific accels
  GtkAccelGroup *lighttable_accels; // lighttable-specific accels
 
  // reference to the above group currently loaded in the main window. don't init,
  // don't free, only update
  GtkAccelGroup *active_group;
 
  GHashTable *acceleratables;       // Key/value list of path/dt_shortcut_t
  gint reset;                       // ref counter of how many parts disconnected accels
  GdkKeymap *keymap;                // default screen keymap to decode key values
  GdkModifierType default_mod_mask; // set of modifier masks relevant only to key strokes
 
  // TRUE if we didn't find a keyboardrc config file at startup and we need to init a new one
  gboolean init;
 
  // between key_pressed and key_release events, this stores the active key strokes
  GtkAccelKey active_key;
 
  // Temporarily disable accelerators
  gboolean disable_accels;
 
  GtkAccelFlags flags;
 
  dt_pthread_mutex_t lock;
 
  // Views can register a global callback to handle scroll events
  // for example while keystrokes are on.
  struct scroll
  {
    gboolean (*callback)(GdkEventScroll event, void *data);
    void *data;
  } scroll;
} dt_accels_t;
 
typedef enum dt_shortcut_type_t
{
  DT_SHORTCUT_UNSET = 0,   // shortcut non-inited
  DT_SHORTCUT_DEFAULT = 1, // shortcut inited with compile-time defaults
  DT_SHORTCUT_USER = 2     // shortcut changed by user config
} dt_shortcut_type_t;
 
typedef struct dt_shortcut_t
{
  GtkWidget *widget;          // link to the widget being accelerated. Can be NULL.
  GList *closure;             // GList of GClosures, aka callback + data being accelerated. Has to be non-NULL if widget is NULL.
  char *path;                 // global path for that accel
  const char *signal;         // widget signal to be wired to that accel
  GtkAccelGroup *accel_group; // the accel_group to which this shortcut belongs
  guint key;                  // default key
  GdkModifierType mods;       // default modifier
  dt_shortcut_type_t type;
  gboolean locked;            // if shortcut can't be changed by user
  gboolean virtual_shortcut;  // if shortcut is mapped to a key-pressed event handler instead of a global action callback
  const char *description;    // user-legible description of the action
  dt_accels_t *accels; // back-reference for convenience
} dt_shortcut_t;
 
 
dt_accels_t *dt_accels_init(char *config_file, GtkAccelFlags flags);
void dt_accels_cleanup(dt_accels_t *accels);
 
 
gchar *dt_accels_build_path(const gchar *scope, const gchar *feature);
 
void dt_accels_load_user_config(dt_accels_t *accels);
 
 
void dt_accels_connect_accels(dt_accels_t *accels);
 
 
void dt_accels_connect_active_group(dt_accels_t *accels, const gchar *group);
 
void dt_accels_disconnect_active_group(dt_accels_t *accels);
 
 
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);
 
 
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);
 
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);
 
 
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, GtkAccelGroup *accel_group, const gchar *action_scope,
                                   const gchar *action_name, guint key_val, GdkModifierType accel_mods,
                                   const gboolean lock, const char *description);
 
 
gboolean dt_accels_dispatch(GtkWidget *w, GdkEvent *event, gpointer user_data);
 
void dt_accels_attach_scroll_handler(dt_accels_t *accels, gboolean (*callback)(GdkEventScroll event, void *data),
                                     void *data);
 
void dt_accels_detach_scroll_handler(dt_accels_t *accels);
 
 
// Temporarily enable/disable keyboard accels, for example during GtkEntry typing.
// Connect it from Gtk focus in/out event handlers
static inline void dt_accels_disable(dt_accels_t *accels, gboolean state)
{
  accels->disable_accels = state;
}
 
void dt_accels_remove_accel(dt_accels_t *accels, const char *path, gpointer data);
 
void dt_accels_remove_shortcut(dt_accels_t *accels, const char *path);
 
void dt_accels_window(dt_accels_t *accels, GtkWindow *main_window);
 
void dt_accels_search(dt_accels_t *accels, GtkWindow *main_window, GtkWidget *anchor);