griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
da62529ca98db0f8e378cd7753aa2a8515e4dffa
test2/source/blender/windowmanager/intern/wm_keymap.cc
Damien Picard 49b45a95db I18n: Disambiguate "Space" 
- "Space" can be the spacebar key. This uses the UIEvents context
  already. One instance is the event type enum item, where "Spacebar"
  is the label and "Space" is the description. Since there is no way
  to use contexts for descriptions since they are supposed to be more
  verbose, the label was renamed to "Space Bar" (acceptable according
  to Wikipedia), and the description to "Spacebar".
- In the context of the Grease Pencil, "Space" is a method of spacing
  brush strokes.

Issue reported by Hoang Duy Tran.
2025-01-13 12:40:45 +01:00

2119 lines
66 KiB
C++
Raw Blame History

/* SPDX-FileCopyrightText: 2007 Blender Authors
*
* SPDX-License-Identifier: GPL-2.0-or-later */
/** \file
* \ingroup wm
*
* Configurable key-maps - add/remove/find/compare/patch...
*/
#include <cstring>
#include <fmt/format.h>
#include "DNA_screen_types.h"
#include "DNA_space_types.h"
#include "DNA_userdef_types.h"
#include "DNA_windowmanager_types.h"
#include "DNA_workspace_types.h"
#include "CLG_log.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BLI_utildefines.h"
#include "BLF_api.hh"
#include "UI_interface.hh"
#include "BKE_context.hh"
#include "BKE_global.hh"
#include "BKE_idprop.hh"
#include "BKE_main.hh"
#include "BKE_screen.hh"
#include "BKE_workspace.hh"
#include "BLT_translation.hh"
#include "RNA_access.hh"
#include "RNA_enum_types.hh"
#include "WM_api.hh"
#include "WM_types.hh"
#include "wm_event_system.hh"
#include "wm_event_types.hh"
#include "ED_screen.hh"
struct wmKeyMapItemFind_Params {
bool (*filter_fn)(const wmKeyMap *km, const wmKeyMapItem *kmi, void *user_data);
void *user_data;
};
/* -------------------------------------------------------------------- */
/** \name Keymap Item
*
* Item in a keymap, that maps from an event to an operator or modal map item.
* \{ */
static wmKeyMapItem *wm_keymap_item_copy(wmKeyMapItem *kmi)
{
wmKeyMapItem *kmin = static_cast<wmKeyMapItem *>(MEM_dupallocN(kmi));
kmin->prev = kmin->next = nullptr;
kmin->flag &= ~KMI_UPDATE;
if (kmin->properties) {
kmin->ptr = MEM_new<PointerRNA>("UserKeyMapItemPtr");
WM_operator_properties_create(kmin->ptr, kmin->idname);
/* Signal for no context, see #STRUCT_NO_CONTEXT_WITHOUT_OWNER_ID. */
kmin->ptr->owner_id = nullptr;
kmin->properties = IDP_CopyProperty(kmin->properties);
kmin->ptr->data = kmin->properties;
}
else {
kmin->properties = nullptr;
kmin->ptr = nullptr;
}
return kmin;
}
static void wm_keymap_item_free_data(wmKeyMapItem *kmi)
{
/* Not the `kmi` itself. */
if (kmi->ptr) {
WM_operator_properties_free(kmi->ptr);
MEM_delete(kmi->ptr);
kmi->ptr = nullptr;
kmi->properties = nullptr;
}
else if (kmi->properties) {
IDP_FreeProperty(kmi->properties);
kmi->properties = nullptr;
}
}
static void wm_keymap_item_clear_runtime(wmKeyMapItem *kmi)
{
IDProperty *properties = kmi->properties;
kmi->properties = nullptr;
if (kmi->ptr) {
kmi->ptr->data = nullptr;
}
wm_keymap_item_free_data(kmi);
kmi->properties = properties;
}
static void wm_keymap_item_properties_set(wmKeyMapItem *kmi)
{
WM_operator_properties_alloc(&(kmi->ptr), &(kmi->properties), kmi->idname);
WM_operator_properties_sanitize(kmi->ptr, true);
/* Signal for no context, see #STRUCT_NO_CONTEXT_WITHOUT_OWNER_ID. */
kmi->ptr->owner_id = nullptr;
}
/**
* Similar to #wm_keymap_item_properties_set
* but checks for the #wmOperatorType having changed, see #38042.
*/
static void wm_keymap_item_properties_update_ot(wmKeyMapItem *kmi, const bool keep_properties)
{
if (kmi->idname[0] == 0) {
BLI_assert(kmi->ptr == nullptr);
return;
}
if (kmi->ptr == nullptr) {
wm_keymap_item_properties_set(kmi);
}
else {
wmOperatorType *ot = WM_operatortype_find(kmi->idname, false);
if (ot) {
if (ot->srna != kmi->ptr->type) {
/* Matches #wm_keymap_item_properties_set but doesn't alloc new ptr. */
WM_operator_properties_create_ptr(kmi->ptr, ot);
/* 'kmi->ptr->data' nullptr'd above, keep using existing properties.
* NOTE: the operators property types may have changed,
* we will need a more comprehensive sanitize function to support this properly.
*/
if (kmi->properties) {
kmi->ptr->data = kmi->properties;
}
WM_operator_properties_sanitize(kmi->ptr, true);
/* Signal for no context, see #STRUCT_NO_CONTEXT_WITHOUT_OWNER_ID. */
kmi->ptr->owner_id = nullptr;
}
}
else {
/* Zombie key-map item. */
if (keep_properties) {
wm_keymap_item_clear_runtime(kmi);
}
else {
wm_keymap_item_free_data(kmi);
}
}
}
}
static void wm_keymap_item_properties_update_ot_from_list(ListBase *km_lb,
const bool keep_properties)
{
LISTBASE_FOREACH (wmKeyMap *, km, km_lb) {
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &km->items) {
wm_keymap_item_properties_update_ot(kmi, keep_properties);
}
LISTBASE_FOREACH (wmKeyMapDiffItem *, kmdi, &km->diff_items) {
if (kmdi->add_item) {
wm_keymap_item_properties_update_ot(kmdi->add_item, keep_properties);
}
if (kmdi->remove_item) {
wm_keymap_item_properties_update_ot(kmdi->remove_item, keep_properties);
}
}
}
}
static bool wm_keymap_item_equals_result(wmKeyMapItem *a, wmKeyMapItem *b)
{
return (STREQ(a->idname, b->idname) &&
/* We do not really care about which Main we pass here, TBH. */
RNA_struct_equals(G_MAIN, a->ptr, b->ptr, RNA_EQ_UNSET_MATCH_NONE) &&
(a->flag & KMI_INACTIVE) == (b->flag & KMI_INACTIVE) && a->propvalue == b->propvalue);
}
static bool wm_keymap_item_equals(wmKeyMapItem *a, wmKeyMapItem *b)
{
return (wm_keymap_item_equals_result(a, b) && a->type == b->type && a->val == b->val &&
a->shift == b->shift && a->ctrl == b->ctrl && a->alt == b->alt && a->oskey == b->oskey &&
a->keymodifier == b->keymodifier && a->maptype == b->maptype &&
((a->val != KM_CLICK_DRAG) || (a->direction == b->direction)) &&
((ISKEYBOARD(a->type) == 0) ||
(a->flag & KMI_REPEAT_IGNORE) == (b->flag & KMI_REPEAT_IGNORE)));
}
void WM_keymap_item_properties_reset(wmKeyMapItem *kmi, IDProperty *properties)
{
if (LIKELY(kmi->ptr)) {
WM_operator_properties_free(kmi->ptr);
MEM_delete(kmi->ptr);
kmi->ptr = nullptr;
}
else if (kmi->properties) {
IDP_FreeProperty(kmi->properties);
}
kmi->properties = properties;
wm_keymap_item_properties_set(kmi);
}
int WM_keymap_item_map_type_get(const wmKeyMapItem *kmi)
{
if (ISTIMER(kmi->type)) {
return KMI_TYPE_TIMER;
}
if (ISKEYBOARD(kmi->type)) {
return KMI_TYPE_KEYBOARD;
}
if (ISMOUSE(kmi->type)) {
return KMI_TYPE_MOUSE;
}
if (ISNDOF(kmi->type)) {
return KMI_TYPE_NDOF;
}
if (kmi->type == KM_TEXTINPUT) {
return KMI_TYPE_TEXTINPUT;
}
if (ELEM(kmi->type, TABLET_STYLUS, TABLET_ERASER)) {
return KMI_TYPE_MOUSE;
}
return KMI_TYPE_KEYBOARD;
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Keymap Diff Item
*
* Item in a diff keymap, used for saving diff of keymaps in user preferences.
* \{ */
static wmKeyMapDiffItem *wm_keymap_diff_item_copy(wmKeyMapDiffItem *kmdi)
{
wmKeyMapDiffItem *kmdin = static_cast<wmKeyMapDiffItem *>(MEM_dupallocN(kmdi));
kmdin->next = kmdin->prev = nullptr;
if (kmdi->add_item) {
kmdin->add_item = wm_keymap_item_copy(kmdi->add_item);
}
if (kmdi->remove_item) {
kmdin->remove_item = wm_keymap_item_copy(kmdi->remove_item);
}
return kmdin;
}
static void wm_keymap_diff_item_free(wmKeyMapDiffItem *kmdi)
{
if (kmdi->remove_item) {
wm_keymap_item_free_data(kmdi->remove_item);
MEM_freeN(kmdi->remove_item);
}
if (kmdi->add_item) {
wm_keymap_item_free_data(kmdi->add_item);
MEM_freeN(kmdi->add_item);
}
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Key Configuration
*
* List of keymaps for all editors, modes, etc.
* There is a builtin default key configuration,
* a user key configuration, and other preset configurations.
* \{ */
wmKeyConfig *WM_keyconfig_new(wmWindowManager *wm, const char *idname, bool user_defined)
{
BLI_assert(!BLI_findstring(&wm->keyconfigs, idname, offsetof(wmKeyConfig, idname)));
/* Create new configuration. */
wmKeyConfig *keyconf = static_cast<wmKeyConfig *>(
MEM_callocN(sizeof(wmKeyConfig), "wmKeyConfig"));
STRNCPY_UTF8(keyconf->idname, idname);
BLI_addtail(&wm->keyconfigs, keyconf);
if (user_defined) {
keyconf->flag |= KEYCONF_USER;
}
return keyconf;
}
wmKeyConfig *WM_keyconfig_ensure(wmWindowManager *wm, const char *idname, bool user_defined)
{
wmKeyConfig *keyconf = static_cast<wmKeyConfig *>(
BLI_findstring(&wm->keyconfigs, idname, offsetof(wmKeyConfig, idname)));
if (keyconf) {
if (keyconf == wm->defaultconf) {
/* For default configuration, we need to keep keymap
* modal items and poll functions intact. */
LISTBASE_FOREACH (wmKeyMap *, km, &keyconf->keymaps) {
WM_keymap_clear(km);
}
}
else {
/* For user defined key configuration, clear all keymaps. */
WM_keyconfig_clear(keyconf);
}
return keyconf;
}
return WM_keyconfig_new(wm, idname, user_defined);
}
void WM_keyconfig_remove(wmWindowManager *wm, wmKeyConfig *keyconf)
{
BLI_assert(BLI_findindex(&wm->keyconfigs, keyconf) != -1);
if (STREQLEN(U.keyconfigstr, keyconf->idname, sizeof(U.keyconfigstr))) {
STRNCPY(U.keyconfigstr, wm->defaultconf->idname);
U.runtime.is_dirty = true;
WM_keyconfig_update_tag(nullptr, nullptr);
}
BLI_remlink(&wm->keyconfigs, keyconf);
WM_keyconfig_free(keyconf);
/* Clear pointers. */
wmKeyConfig **keyconf_arr_p[] = {WM_KEYCONFIG_ARRAY_P(wm)};
for (int i = 0; i < ARRAY_SIZE(keyconf_arr_p); i++) {
wmKeyConfig **kc_p = keyconf_arr_p[i];
if (*kc_p == keyconf) {
*kc_p = nullptr;
}
}
}
void WM_keyconfig_clear(wmKeyConfig *keyconf)
{
LISTBASE_FOREACH_MUTABLE (wmKeyMap *, km, &keyconf->keymaps) {
WM_keymap_clear(km);
MEM_freeN(km);
}
BLI_listbase_clear(&keyconf->keymaps);
}
void WM_keyconfig_free(wmKeyConfig *keyconf)
{
WM_keyconfig_clear(keyconf);
MEM_freeN(keyconf);
}
static wmKeyConfig *WM_keyconfig_active(wmWindowManager *wm)
{
wmKeyConfig *keyconf;
/* First try from preset. */
keyconf = static_cast<wmKeyConfig *>(
BLI_findstring(&wm->keyconfigs, U.keyconfigstr, offsetof(wmKeyConfig, idname)));
if (keyconf) {
return keyconf;
}
/* Otherwise use default. */
return wm->defaultconf;
}
void WM_keyconfig_set_active(wmWindowManager *wm, const char *idname)
{
/* Setting a different key configuration as active:
* we ensure all is updated properly before and after making the change. */
WM_keyconfig_update(wm);
STRNCPY(U.keyconfigstr, idname);
if (wm->init_flag & WM_INIT_FLAG_KEYCONFIG) {
U.runtime.is_dirty = true;
}
WM_keyconfig_update_tag(nullptr, nullptr);
WM_keyconfig_update(wm);
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Keymap
*
* List of keymap items for one editor, mode, modal operator.
* \{ */
static wmKeyMap *wm_keymap_new(const char *idname, int spaceid, int regionid)
{
wmKeyMap *km = static_cast<wmKeyMap *>(MEM_callocN(sizeof(wmKeyMap), "keymap list"));
STRNCPY_UTF8(km->idname, idname);
km->spaceid = spaceid;
km->regionid = regionid;
{
const char *owner_id = RNA_struct_state_owner_get();
if (owner_id) {
STRNCPY(km->owner_id, owner_id);
}
}
return km;
}
static wmKeyMap *wm_keymap_copy(wmKeyMap *keymap)
{
wmKeyMap *keymapn = static_cast<wmKeyMap *>(MEM_dupallocN(keymap));
keymapn->modal_items = keymap->modal_items;
keymapn->poll = keymap->poll;
keymapn->poll_modal_item = keymap->poll_modal_item;
BLI_listbase_clear(&keymapn->items);
keymapn->flag &= ~(KEYMAP_UPDATE | KEYMAP_EXPANDED);
LISTBASE_FOREACH (wmKeyMapDiffItem *, kmdi, &keymap->diff_items) {
wmKeyMapDiffItem *kmdi_new = wm_keymap_diff_item_copy(kmdi);
BLI_addtail(&keymapn->items, kmdi_new);
}
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &keymap->items) {
wmKeyMapItem *kmi_new = wm_keymap_item_copy(kmi);
BLI_addtail(&keymapn->items, kmi_new);
}
return keymapn;
}
void WM_keymap_clear(wmKeyMap *keymap)
{
LISTBASE_FOREACH_MUTABLE (wmKeyMapDiffItem *, kmdi, &keymap->diff_items) {
wm_keymap_diff_item_free(kmdi);
MEM_freeN(kmdi);
}
LISTBASE_FOREACH_MUTABLE (wmKeyMapItem *, kmi, &keymap->items) {
wm_keymap_item_free_data(kmi);
MEM_freeN(kmi);
}
BLI_listbase_clear(&keymap->diff_items);
BLI_listbase_clear(&keymap->items);
}
void WM_keymap_remove(wmKeyConfig *keyconf, wmKeyMap *keymap)
{
BLI_assert(BLI_findindex(&keyconf->keymaps, keymap) != -1);
WM_keymap_clear(keymap);
BLI_remlink(&keyconf->keymaps, keymap);
MEM_freeN(keymap);
}
bool WM_keymap_poll(bContext *C, wmKeyMap *keymap)
{
/* If we're tagged, only use compatible. */
if (keymap->owner_id[0] != '\0') {
const WorkSpace *workspace = CTX_wm_workspace(C);
if (BKE_workspace_owner_id_check(workspace, keymap->owner_id) == false) {
return false;
}
}
if (UNLIKELY(BLI_listbase_is_empty(&keymap->items))) {
/* Empty key-maps may be missing more there may be a typo in the name.
* Warn early to avoid losing time investigating each case.
* When developing a customized Blender though you may want empty keymaps. */
if (!U.app_template[0] &&
/* Fallback key-maps may be intentionally empty, don't flood the output. */
!BLI_str_endswith(keymap->idname, " (fallback)") &&
/* This is an exception which may be empty.
* Longer term we might want a flag to indicate an empty key-map is intended. */
!STREQ(keymap->idname, "Node Tool: Tweak") &&
/* Another exception: Asset shelf keymap is meant for add-ons to use, it's empty by
* default. */
!STREQ(keymap->idname, "Asset Shelf"))
{
CLOG_WARN(WM_LOG_KEYMAPS, "empty keymap '%s'", keymap->idname);
}
}
if (keymap->poll != nullptr) {
return keymap->poll(C);
}
return true;
}
static void keymap_event_set(wmKeyMapItem *kmi, const KeyMapItem_Params *params)
{
kmi->type = params->type;
kmi->val = params->value;
kmi->keymodifier = params->keymodifier;
kmi->direction = params->direction;
if (params->modifier == KM_ANY) {
kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY;
}
else {
/* Only one of the flags should be set. */
BLI_assert(((params->modifier & (KM_SHIFT | KM_SHIFT_ANY)) != (KM_SHIFT | KM_SHIFT_ANY)) &&
((params->modifier & (KM_CTRL | KM_CTRL_ANY)) != (KM_CTRL | KM_CTRL_ANY)) &&
((params->modifier & (KM_ALT | KM_ALT_ANY)) != (KM_ALT | KM_ALT_ANY)) &&
((params->modifier & (KM_OSKEY | KM_OSKEY_ANY)) != (KM_OSKEY | KM_OSKEY_ANY)));
kmi->shift = ((params->modifier & KM_SHIFT) ?
KM_MOD_HELD :
((params->modifier & KM_SHIFT_ANY) ? KM_ANY : KM_NOTHING));
kmi->ctrl = ((params->modifier & KM_CTRL) ?
KM_MOD_HELD :
((params->modifier & KM_CTRL_ANY) ? KM_ANY : KM_NOTHING));
kmi->alt = ((params->modifier & KM_ALT) ?
KM_MOD_HELD :
((params->modifier & KM_ALT_ANY) ? KM_ANY : KM_NOTHING));
kmi->oskey = ((params->modifier & KM_OSKEY) ?
KM_MOD_HELD :
((params->modifier & KM_OSKEY_ANY) ? KM_ANY : KM_NOTHING));
}
}
static void keymap_item_set_id(wmKeyMap *keymap, wmKeyMapItem *kmi)
{
keymap->kmi_id++;
if ((keymap->flag & KEYMAP_USER) == 0) {
kmi->id = keymap->kmi_id;
}
else {
kmi->id = -keymap->kmi_id; /* User defined keymap entries have negative ids. */
}
}
wmKeyMapItem *WM_keymap_add_item(wmKeyMap *keymap,
const char *idname,
const KeyMapItem_Params *params)
{
wmKeyMapItem *kmi = static_cast<wmKeyMapItem *>(
MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"));
BLI_addtail(&keymap->items, kmi);
STRNCPY(kmi->idname, idname);
keymap_event_set(kmi, params);
wm_keymap_item_properties_set(kmi);
keymap_item_set_id(keymap, kmi);
WM_keyconfig_update_tag(keymap, kmi);
return kmi;
}
wmKeyMapItem *WM_keymap_add_item_copy(wmKeyMap *keymap, wmKeyMapItem *kmi_src)
{
wmKeyMapItem *kmi_dst = wm_keymap_item_copy(kmi_src);
BLI_addtail(&keymap->items, kmi_dst);
keymap_item_set_id(keymap, kmi_dst);
WM_keyconfig_update_tag(keymap, kmi_dst);
return kmi_dst;
}
void WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi)
{
BLI_assert(BLI_findindex(&keymap->items, kmi) != -1);
if (kmi->ptr) {
WM_operator_properties_free(kmi->ptr);
MEM_delete(kmi->ptr);
}
else if (kmi->properties) {
IDP_FreeProperty(kmi->properties);
}
BLI_freelinkN(&keymap->items, kmi);
WM_keyconfig_update_tag(keymap, nullptr);
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Keymap Diff and Patch
*
* Rather than saving the entire keymap for user preferences, we only save a
* diff so that changes in the defaults get synced. This system is not perfect
* but works better than overriding the keymap entirely when only few items
* are changed.
* \{ */
static void wm_keymap_addon_add(wmKeyMap *keymap, wmKeyMap *addonmap)
{
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &addonmap->items) {
wmKeyMapItem *kmi_new = wm_keymap_item_copy(kmi);
keymap_item_set_id(keymap, kmi_new);
BLI_addhead(&keymap->items, kmi_new);
}
}
static wmKeyMapItem *wm_keymap_find_item_equals(wmKeyMap *km, wmKeyMapItem *needle)
{
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &km->items) {
if (wm_keymap_item_equals(kmi, needle)) {
return kmi;
}
}
return nullptr;
}
static wmKeyMapItem *wm_keymap_find_item_equals_result(wmKeyMap *km, wmKeyMapItem *needle)
{
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &km->items) {
if (wm_keymap_item_equals_result(kmi, needle)) {
return kmi;
}
}
return nullptr;
}
static void wm_keymap_diff(
wmKeyMap *diff_km, wmKeyMap *from_km, wmKeyMap *to_km, wmKeyMap *orig_km, wmKeyMap *addon_km)
{
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &from_km->items) {
wmKeyMapItem *to_kmi = WM_keymap_item_find_id(to_km, kmi->id);
if (!to_kmi) {
/* Remove item. */
wmKeyMapDiffItem *kmdi = static_cast<wmKeyMapDiffItem *>(
MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem"));
kmdi->remove_item = wm_keymap_item_copy(kmi);
BLI_addtail(&diff_km->diff_items, kmdi);
}
else if (to_kmi && !wm_keymap_item_equals(kmi, to_kmi)) {
/* Replace item. */
wmKeyMapDiffItem *kmdi = static_cast<wmKeyMapDiffItem *>(
MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem"));
kmdi->remove_item = wm_keymap_item_copy(kmi);
kmdi->add_item = wm_keymap_item_copy(to_kmi);
BLI_addtail(&diff_km->diff_items, kmdi);
}
/* Sync expanded flag back to original so we don't lose it on re-patch. */
if (to_kmi) {
wmKeyMapItem *orig_kmi = WM_keymap_item_find_id(orig_km, kmi->id);
if (!orig_kmi && addon_km) {
orig_kmi = wm_keymap_find_item_equals(addon_km, kmi);
}
if (orig_kmi) {
orig_kmi->flag &= ~KMI_EXPANDED;
orig_kmi->flag |= (to_kmi->flag & KMI_EXPANDED);
}
}
}
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &to_km->items) {
if (kmi->id < 0) {
/* Add item. */
wmKeyMapDiffItem *kmdi = static_cast<wmKeyMapDiffItem *>(
MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem"));
kmdi->add_item = wm_keymap_item_copy(kmi);
BLI_addtail(&diff_km->diff_items, kmdi);
}
}
}
static void wm_keymap_patch(wmKeyMap *km, wmKeyMap *diff_km)
{
LISTBASE_FOREACH (wmKeyMapDiffItem *, kmdi, &diff_km->diff_items) {
/* Find item to remove. */
wmKeyMapItem *kmi_remove = nullptr;
if (kmdi->remove_item) {
kmi_remove = wm_keymap_find_item_equals(km, kmdi->remove_item);
if (!kmi_remove) {
kmi_remove = wm_keymap_find_item_equals_result(km, kmdi->remove_item);
}
}
/* Add item. */
if (kmdi->add_item) {
/* Do not re-add an already existing keymap item! See #42088. */
/* We seek only for exact copy here! See #42137. */
wmKeyMapItem *kmi_add = wm_keymap_find_item_equals(km, kmdi->add_item);
/* If kmi_add is same as kmi_remove (can happen in some cases,
* typically when we got kmi_remove from #wm_keymap_find_item_equals_result()),
* no need to add or remove anything, see #45579. */
/**
* \note This typically happens when we apply user-defined keymap diff to a base one that
* was exported with that customized keymap already. In that case:
*
* - wm_keymap_find_item_equals(km, kmdi->remove_item) finds nothing
* (because actual shortcut of current base does not match kmdi->remove_item any more).
* - wm_keymap_find_item_equals_result(km, kmdi->remove_item) finds the current kmi from
* base keymap (because it does exactly the same thing).
* - wm_keymap_find_item_equals(km, kmdi->add_item) finds the same kmi,
* since base keymap was exported with that user-defined shortcut already!
*
* Maybe we should rather keep user-defined keymaps specific to a given base one? */
if (kmi_add != nullptr && kmi_add == kmi_remove) {
kmi_remove = nullptr;
}
/* Only if nothing to remove or item to remove found. */
else if (!kmi_add && (!kmdi->remove_item || kmi_remove)) {
kmi_add = wm_keymap_item_copy(kmdi->add_item);
kmi_add->flag |= KMI_USER_MODIFIED;
if (kmi_remove) {
kmi_add->flag &= ~KMI_EXPANDED;
kmi_add->flag |= (kmi_remove->flag & KMI_EXPANDED);
kmi_add->id = kmi_remove->id;
BLI_insertlinkbefore(&km->items, kmi_remove, kmi_add);
}
else {
keymap_item_set_id(km, kmi_add);
BLI_addtail(&km->items, kmi_add);
}
}
}
/* Remove item. */
if (kmi_remove) {
wm_keymap_item_free_data(kmi_remove);
BLI_freelinkN(&km->items, kmi_remove);
}
}
}
static wmKeyMap *wm_keymap_patch_update(ListBase *lb,
wmKeyMap *defaultmap,
wmKeyMap *addonmap,
wmKeyMap *usermap)
{
int expanded = 0;
/* Remove previous keymap in list, we will replace it. */
wmKeyMap *km = WM_keymap_list_find(
lb, defaultmap->idname, defaultmap->spaceid, defaultmap->regionid);
if (km) {
expanded = (km->flag & (KEYMAP_EXPANDED | KEYMAP_CHILDREN_EXPANDED));
WM_keymap_clear(km);
BLI_freelinkN(lb, km);
}
/* Copy new keymap from an existing one. */
if (usermap && !(usermap->flag & KEYMAP_DIFF)) {
/* For compatibility with old user preferences with non-diff
* keymaps we override the original entirely. */
km = wm_keymap_copy(usermap);
/* Try to find corresponding id's for items. */
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &km->items) {
wmKeyMapItem *orig_kmi = wm_keymap_find_item_equals(defaultmap, kmi);
if (!orig_kmi) {
orig_kmi = wm_keymap_find_item_equals_result(defaultmap, kmi);
}
if (orig_kmi) {
kmi->id = orig_kmi->id;
}
else {
kmi->id = -(km->kmi_id++);
}
}
km->flag |= KEYMAP_UPDATE; /* Update again to create diff. */
}
else {
km = wm_keymap_copy(defaultmap);
}
/* Add addon keymap items. */
if (addonmap) {
wm_keymap_addon_add(km, addonmap);
}
/* Tag as being user edited. */
if (usermap) {
km->flag |= KEYMAP_USER_MODIFIED;
}
km->flag |= KEYMAP_USER | expanded;
/* Apply user changes of diff keymap. */
if (usermap && (usermap->flag & KEYMAP_DIFF)) {
wm_keymap_patch(km, usermap);
}
/* Add to list. */
BLI_addtail(lb, km);
return km;
}
static void wm_keymap_diff_update(ListBase *lb,
wmKeyMap *defaultmap,
wmKeyMap *addonmap,
wmKeyMap *km)
{
/* Create temporary default + addon keymap for diff. */
wmKeyMap *origmap = defaultmap;
if (addonmap) {
defaultmap = wm_keymap_copy(defaultmap);
wm_keymap_addon_add(defaultmap, addonmap);
}
/* Remove previous diff keymap in list, we will replace it. */
wmKeyMap *prevmap = WM_keymap_list_find(lb, km->idname, km->spaceid, km->regionid);
if (prevmap) {
WM_keymap_clear(prevmap);
BLI_freelinkN(lb, prevmap);
}
/* Create diff keymap. */
wmKeyMap *diffmap = wm_keymap_new(km->idname, km->spaceid, km->regionid);
diffmap->flag |= KEYMAP_DIFF;
if (defaultmap->flag & KEYMAP_MODAL) {
diffmap->flag |= KEYMAP_MODAL;
}
wm_keymap_diff(diffmap, defaultmap, km, origmap, addonmap);
/* Add to list if not empty. */
if (diffmap->diff_items.first) {
BLI_addtail(lb, diffmap);
}
else {
WM_keymap_clear(diffmap);
MEM_freeN(diffmap);
}
/* Free temporary default map. */
if (addonmap) {
WM_keymap_clear(defaultmap);
MEM_freeN(defaultmap);
}
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Storage in WM
*
* Name id's are for storing general or multiple keymaps.
*
* - Space/region ids are same as `DNA_space_types.h`.
* - Gets freed in `wm.cc`.
* \{ */
wmKeyMap *WM_keymap_list_find(ListBase *lb, const char *idname, int spaceid, int regionid)
{
LISTBASE_FOREACH (wmKeyMap *, km, lb) {
if (km->spaceid == spaceid && km->regionid == regionid) {
if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
return km;
}
}
}
return nullptr;
}
wmKeyMap *WM_keymap_list_find_spaceid_or_empty(ListBase *lb,
const char *idname,
int spaceid,
int regionid)
{
LISTBASE_FOREACH (wmKeyMap *, km, lb) {
if (ELEM(km->spaceid, spaceid, SPACE_EMPTY) && km->regionid == regionid) {
if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
return km;
}
}
}
return nullptr;
}
wmKeyMap *WM_keymap_ensure(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
{
wmKeyMap *km = WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
if (km == nullptr) {
km = wm_keymap_new(idname, spaceid, regionid);
BLI_addtail(&keyconf->keymaps, km);
WM_keyconfig_update_tag(km, nullptr);
}
return km;
}
wmKeyMap *WM_keymap_find_all(wmWindowManager *wm, const char *idname, int spaceid, int regionid)
{
return WM_keymap_list_find(&wm->userconf->keymaps, idname, spaceid, regionid);
}
wmKeyMap *WM_keymap_find_all_spaceid_or_empty(wmWindowManager *wm,
const char *idname,
int spaceid,
int regionid)
{
return WM_keymap_list_find_spaceid_or_empty(&wm->userconf->keymaps, idname, spaceid, regionid);
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Modal Keymaps
*
* Modal key-maps get linked to a running operator,
* and filter the keys before sending to #wmOperatorType.modal callback.
* \{ */
wmKeyMap *WM_modalkeymap_ensure(wmKeyConfig *keyconf,
const char *idname,
const EnumPropertyItem *items)
{
wmKeyMap *km = WM_keymap_ensure(keyconf, idname, SPACE_EMPTY, RGN_TYPE_WINDOW);
km->flag |= KEYMAP_MODAL;
/* Initialize modal items from default configuration. */
wmWindowManager *wm = static_cast<wmWindowManager *>(G_MAIN->wm.first);
if (wm->defaultconf && wm->defaultconf != keyconf) {
wmKeyMap *defaultkm = WM_keymap_list_find(
&wm->defaultconf->keymaps, km->idname, SPACE_EMPTY, RGN_TYPE_WINDOW);
if (defaultkm) {
km->modal_items = defaultkm->modal_items;
km->poll = defaultkm->poll;
km->poll_modal_item = defaultkm->poll_modal_item;
}
}
if (items) {
km->modal_items = items;
}
return km;
}
wmKeyMap *WM_modalkeymap_find(wmKeyConfig *keyconf, const char *idname)
{
LISTBASE_FOREACH (wmKeyMap *, km, &keyconf->keymaps) {
if (km->flag & KEYMAP_MODAL) {
if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
return km;
}
}
}
return nullptr;
}
wmKeyMapItem *WM_modalkeymap_add_item(wmKeyMap *km, const KeyMapItem_Params *params, int value)
{
wmKeyMapItem *kmi = static_cast<wmKeyMapItem *>(
MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"));
BLI_addtail(&km->items, kmi);
kmi->propvalue = value;
keymap_event_set(kmi, params);
keymap_item_set_id(km, kmi);
WM_keyconfig_update_tag(km, kmi);
return kmi;
}
wmKeyMapItem *WM_modalkeymap_add_item_str(wmKeyMap *km,
const KeyMapItem_Params *params,
const char *value)
{
wmKeyMapItem *kmi = static_cast<wmKeyMapItem *>(
MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"));
BLI_addtail(&km->items, kmi);
STRNCPY(kmi->propvalue_str, value);
keymap_event_set(kmi, params);
keymap_item_set_id(km, kmi);
WM_keyconfig_update_tag(km, kmi);
return kmi;
}
static const wmKeyMapItem *wm_modalkeymap_find_propvalue_iter(const wmKeyMap *km,
const wmKeyMapItem *kmi,
const int propvalue)
{
if (km->flag & KEYMAP_MODAL) {
kmi = static_cast<const wmKeyMapItem *>(kmi ? kmi->next : km->items.first);
for (; kmi; kmi = kmi->next) {
if (kmi->propvalue == propvalue) {
return kmi;
}
}
}
else {
BLI_assert_msg(0, "called with non modal keymap");
}
return nullptr;
}
const wmKeyMapItem *WM_modalkeymap_find_propvalue(const wmKeyMap *km, const int propvalue)
{
return wm_modalkeymap_find_propvalue_iter(km, nullptr, propvalue);
}
void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
{
wmOperatorType *ot = WM_operatortype_find(opname, false);
if (ot) {
ot->modalkeymap = km;
}
else {
CLOG_ERROR(WM_LOG_KEYMAPS, "unknown operator '%s'", opname);
}
}
static void wm_user_modal_keymap_set_items(wmWindowManager *wm, wmKeyMap *km)
{
/* Here we convert propvalue string values delayed, due to python keymaps
* being created before the actual modal keymaps, so no modal_items. */
if (km && (km->flag & KEYMAP_MODAL) && !km->modal_items) {
if (wm->defaultconf == nullptr) {
return;
}
wmKeyMap *defaultkm = WM_keymap_list_find(
&wm->defaultconf->keymaps, km->idname, SPACE_EMPTY, RGN_TYPE_WINDOW);
if (!defaultkm) {
return;
}
km->modal_items = defaultkm->modal_items;
km->poll = defaultkm->poll;
km->poll_modal_item = defaultkm->poll_modal_item;
if (km->modal_items) {
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &km->items) {
if (kmi->propvalue_str[0]) {
int propvalue;
if (RNA_enum_value_from_id(static_cast<const EnumPropertyItem *>(km->modal_items),
kmi->propvalue_str,
&propvalue))
{
kmi->propvalue = propvalue;
}
kmi->propvalue_str[0] = '\0';
}
}
}
}
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Text from Key Events
* \{ */
static const char *key_event_glyph_or_text(const int font_id,
const char *text,
const char *single_glyph)
{
BLI_assert(single_glyph == nullptr || (BLI_strlen_utf8(single_glyph) == 1));
return (single_glyph && BLF_has_glyph(font_id, BLI_str_utf8_as_unicode_or_error(single_glyph))) ?
single_glyph :
text;
}
const char *WM_key_event_string(const short type, const bool compact)
{
if (compact) {
/* String storing a single unicode character or nullptr. */
const char *single_glyph = nullptr;
int font_id = BLF_default();
const enum {
UNIX,
MACOS,
MSWIN,
} platform =
#if defined(__APPLE__)
MACOS
#elif defined(_WIN32)
MSWIN
#else
UNIX
#endif
;
switch (type) {
case EVT_LEFTSHIFTKEY:
case EVT_RIGHTSHIFTKEY: {
if (platform == MACOS) {
single_glyph = BLI_STR_UTF8_UPWARDS_WHITE_ARROW;
}
return key_event_glyph_or_text(
font_id, CTX_IFACE_(BLT_I18NCONTEXT_ID_WINDOWMANAGER, "Shift"), single_glyph);
}
case EVT_LEFTCTRLKEY:
case EVT_RIGHTCTRLKEY:
if (platform == MACOS) {
return key_event_glyph_or_text(font_id, "^", BLI_STR_UTF8_UP_ARROWHEAD);
}
return IFACE_("Ctrl");
case EVT_LEFTALTKEY:
case EVT_RIGHTALTKEY: {
if (platform == MACOS) {
/* Option symbol on Mac keyboard. */
single_glyph = BLI_STR_UTF8_OPTION_KEY;
}
return key_event_glyph_or_text(font_id, IFACE_("Alt"), single_glyph);
}
case EVT_OSKEY: {
if (platform == MACOS) {
return key_event_glyph_or_text(
font_id, IFACE_("Cmd"), BLI_STR_UTF8_PLACE_OF_INTEREST_SIGN);
}
if (platform == MSWIN) {
return key_event_glyph_or_text(
font_id, IFACE_("Win"), BLI_STR_UTF8_BLACK_DIAMOND_MINUS_WHITE_X);
}
return IFACE_("OS");
}
case EVT_TABKEY:
return key_event_glyph_or_text(
font_id, CTX_N_(BLT_I18NCONTEXT_UI_EVENTS, "Tab"), BLI_STR_UTF8_HORIZONTAL_TAB_KEY);
case EVT_BACKSPACEKEY:
return key_event_glyph_or_text(font_id, IFACE_("Bksp"), BLI_STR_UTF8_ERASE_TO_THE_LEFT);
case EVT_ESCKEY:
if (platform == MACOS) {
single_glyph = BLI_STR_UTF8_BROKEN_CIRCLE_WITH_NORTHWEST_ARROW;
}
return key_event_glyph_or_text(font_id, IFACE_("Esc"), single_glyph);
case EVT_RETKEY:
return key_event_glyph_or_text(font_id, IFACE_("Enter"), BLI_STR_UTF8_RETURN_SYMBOL);
case EVT_SPACEKEY:
return key_event_glyph_or_text(
font_id, CTX_IFACE_(BLT_I18NCONTEXT_UI_EVENTS, "Space"), BLI_STR_UTF8_OPEN_BOX);
case EVT_LEFTARROWKEY:
return key_event_glyph_or_text(font_id, IFACE_("Left"), BLI_STR_UTF8_LEFTWARDS_ARROW);
case EVT_UPARROWKEY:
return key_event_glyph_or_text(font_id, IFACE_("Up"), BLI_STR_UTF8_UPWARDS_ARROW);
case EVT_RIGHTARROWKEY:
return key_event_glyph_or_text(font_id, IFACE_("Right"), BLI_STR_UTF8_RIGHTWARDS_ARROW);
case EVT_DOWNARROWKEY:
return key_event_glyph_or_text(font_id, IFACE_("Down"), BLI_STR_UTF8_DOWNWARDS_ARROW);
}
}
const EnumPropertyItem *it;
const int i = RNA_enum_from_value(rna_enum_event_type_items, int(type));
if (i == -1) {
return "";
}
it = &rna_enum_event_type_items[i];
/* We first try enum items' description (abused as short-name here),
* and fall back to usual name if empty. */
if (compact && it->description[0]) {
/* XXX No context for enum descriptions... In practice shall not be an issue though. */
return IFACE_(it->description);
}
return CTX_IFACE_(BLT_I18NCONTEXT_UI_EVENTS, it->name);
}
std::optional<std::string> WM_keymap_item_raw_to_string(const short shift,
const short ctrl,
const short alt,
const short oskey,
const short keymodifier,
const short val,
const short type,
const bool compact)
{
/* TODO: also support (some) value, like e.g. double-click? */
blender::Vector<std::string_view, 12> result_array;
const char *space = " ";
if (shift == KM_ANY && ctrl == KM_ANY && alt == KM_ANY && oskey == KM_ANY) {
/* Don't show anything for any mapping. */
}
else {
if (shift) {
result_array.append(WM_key_event_string(EVT_LEFTSHIFTKEY, true));
result_array.append(space);
}
if (ctrl) {
result_array.append(WM_key_event_string(EVT_LEFTCTRLKEY, true));
result_array.append(space);
}
if (alt) {
result_array.append(WM_key_event_string(EVT_LEFTALTKEY, true));
result_array.append(space);
}
if (oskey) {
result_array.append(WM_key_event_string(EVT_OSKEY, true));
result_array.append(space);
}
}
if (keymodifier) {
result_array.append(WM_key_event_string(keymodifier, compact));
result_array.append(space);
}
if (type) {
if (val == KM_DBL_CLICK) {
result_array.append(IFACE_("dbl-"));
}
else if (val == KM_CLICK_DRAG) {
result_array.append(IFACE_("drag-"));
}
result_array.append(WM_key_event_string(type, compact));
}
if (!result_array.is_empty() && (result_array.last() == space)) {
result_array.remove_last();
}
return fmt::to_string(fmt::join(result_array, ""));
}
std::optional<std::string> WM_keymap_item_to_string(const wmKeyMapItem *kmi, const bool compact)
{
return WM_keymap_item_raw_to_string(
kmi->shift, kmi->ctrl, kmi->alt, kmi->oskey, kmi->keymodifier, kmi->val, kmi->type, compact);
}
std::optional<std::string> WM_modalkeymap_items_to_string(const wmKeyMap *km,
const int propvalue,
const bool compact)
{
const wmKeyMapItem *kmi;
if (km == nullptr || (kmi = WM_modalkeymap_find_propvalue(km, propvalue)) == nullptr) {
return std::nullopt;
}
std::string result;
do {
result += WM_keymap_item_to_string(kmi, compact).value_or("");
if ((kmi = wm_modalkeymap_find_propvalue_iter(km, kmi, propvalue)) == nullptr) {
break;
}
result += '/';
} while (true);
return result;
}
std::optional<std::string> WM_modalkeymap_operator_items_to_string(wmOperatorType *ot,
const int propvalue,
const bool compact)
{
wmWindowManager *wm = static_cast<wmWindowManager *>(G_MAIN->wm.first);
wmKeyMap *keymap = WM_keymap_active(wm, ot->modalkeymap);
return WM_modalkeymap_items_to_string(keymap, propvalue, compact);
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Keymap Finding Utilities
* \{ */
static wmKeyMapItem *wm_keymap_item_find_in_keymap(wmKeyMap *keymap,
const char *opname,
IDProperty *properties,
const bool is_strict,
const wmKeyMapItemFind_Params *params)
{
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &keymap->items) {
/* Skip disabled keymap items, see: #38447. */
if (kmi->flag & KMI_INACTIVE) {
continue;
}
if (!STREQ(kmi->idname, opname)) {
continue;
}
bool kmi_match = false;
if (properties) {
/* Example of debugging keymaps. */
#if 0
if (kmi->ptr) {
if (STREQ("MESH_OT_rip_move", opname)) {
printf("OPERATOR\n");
IDP_print(properties);
printf("KEYMAP\n");
IDP_print(kmi->ptr->data);
}
}
#endif
if (kmi->ptr && IDP_EqualsProperties_ex(
properties, static_cast<const IDProperty *>(kmi->ptr->data), is_strict))
{
kmi_match = true;
}
/* Debug only, helps spotting mismatches between menu entries and shortcuts! */
else if (G.debug & G_DEBUG_WM) {
if (is_strict && kmi->ptr) {
wmOperatorType *ot = WM_operatortype_find(opname, true);
if (ot) {
/* Make a copy of the properties and set unset ones to their default values. */
IDProperty *properties_default = IDP_CopyProperty(
static_cast<const IDProperty *>(kmi->ptr->data));
PointerRNA opptr = RNA_pointer_create(nullptr, ot->srna, properties_default);
WM_operator_properties_default(&opptr, true);
if (IDP_EqualsProperties_ex(properties, properties_default, is_strict)) {
std::string kmi_str = WM_keymap_item_to_string(kmi, false).value_or("");
/* NOTE: given properties could come from other things than menu entry. */
printf(
"%s: Some set values in menu entry match default op values, "
"this might not be desired!\n",
opname);
printf("\tkm: '%s', kmi: '%s'\n", keymap->idname, kmi_str.c_str());
#ifndef NDEBUG
# ifdef WITH_PYTHON
printf("OPERATOR\n");
IDP_print(properties);
printf("KEYMAP\n");
IDP_print(static_cast<IDProperty *>(kmi->ptr->data));
# endif
#endif
printf("\n");
}
IDP_FreeProperty(properties_default);
}
}
}
}
else {
kmi_match = true;
}
if (kmi_match) {
if ((params == nullptr) || params->filter_fn(keymap, kmi, params->user_data)) {
return kmi;
}
}
}
return nullptr;
}
static wmKeyMapItem *wm_keymap_item_find_handlers(const bContext *C,
wmWindowManager *wm,
wmWindow *win,
ListBase *handlers,
const char *opname,
wmOperatorCallContext /*opcontext*/,
IDProperty *properties,
const bool is_strict,
const wmKeyMapItemFind_Params *params,
wmKeyMap **r_keymap)
{
/* Find keymap item in handlers. */
LISTBASE_FOREACH (wmEventHandler *, handler_base, handlers) {
if (handler_base->type == WM_HANDLER_TYPE_KEYMAP) {
wmEventHandler_Keymap *handler = (wmEventHandler_Keymap *)handler_base;
wmEventHandler_KeymapResult km_result;
WM_event_get_keymaps_from_handler(wm, win, handler, &km_result);
for (int km_index = 0; km_index < km_result.keymaps_len; km_index++) {
wmKeyMap *keymap = km_result.keymaps[km_index];
if (WM_keymap_poll((bContext *)C, keymap)) {
wmKeyMapItem *kmi = wm_keymap_item_find_in_keymap(
keymap, opname, properties, is_strict, params);
if (kmi != nullptr) {
if (r_keymap) {
*r_keymap = keymap;
}
return kmi;
}
}
}
}
}
/* Ensure un-initialized keymap is never used. */
if (r_keymap) {
*r_keymap = nullptr;
}
return nullptr;
}
static wmKeyMapItem *wm_keymap_item_find_props(const bContext *C,
const char *opname,
wmOperatorCallContext opcontext,
IDProperty *properties,
const bool is_strict,
const wmKeyMapItemFind_Params *params,
wmKeyMap **r_keymap)
{
wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win = CTX_wm_window(C);
ScrArea *area = CTX_wm_area(C);
ARegion *region = CTX_wm_region(C);
wmKeyMapItem *found = nullptr;
/* Look into multiple handler lists to find the item. */
if (win) {
found = wm_keymap_item_find_handlers(C,
wm,
win,
&win->modalhandlers,
opname,
opcontext,
properties,
is_strict,
params,
r_keymap);
if (found == nullptr) {
found = wm_keymap_item_find_handlers(
C, wm, win, &win->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
}
}
if (area && found == nullptr) {
found = wm_keymap_item_find_handlers(
C, wm, win, &area->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
}
if (found == nullptr) {
if (ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) {
if (area) {
if (!(region && region->regiontype == RGN_TYPE_WINDOW)) {
region = BKE_area_find_region_type(area, RGN_TYPE_WINDOW);
}
if (region) {
found = wm_keymap_item_find_handlers(C,
wm,
win,
&region->runtime->handlers,
opname,
opcontext,
properties,
is_strict,
params,
r_keymap);
}
}
}
else if (ELEM(opcontext, WM_OP_EXEC_REGION_CHANNELS, WM_OP_INVOKE_REGION_CHANNELS)) {
if (!(region && region->regiontype == RGN_TYPE_CHANNELS)) {
region = BKE_area_find_region_type(area, RGN_TYPE_CHANNELS);
}
if (region) {
found = wm_keymap_item_find_handlers(C,
wm,
win,
&region->runtime->handlers,
opname,
opcontext,
properties,
is_strict,
params,
r_keymap);
}
}
else if (ELEM(opcontext, WM_OP_EXEC_REGION_PREVIEW, WM_OP_INVOKE_REGION_PREVIEW)) {
if (!(region && region->regiontype == RGN_TYPE_PREVIEW)) {
region = BKE_area_find_region_type(area, RGN_TYPE_PREVIEW);
}
if (region) {
found = wm_keymap_item_find_handlers(C,
wm,
win,
&region->runtime->handlers,
opname,
opcontext,
properties,
is_strict,
params,
r_keymap);
}
}
else {
if (region) {
found = wm_keymap_item_find_handlers(C,
wm,
win,
&region->runtime->handlers,
opname,
opcontext,
properties,
is_strict,
params,
r_keymap);
}
}
}
return found;
}
static wmKeyMapItem *wm_keymap_item_find(const bContext *C,
const char *opname,
wmOperatorCallContext opcontext,
IDProperty *properties,
bool is_strict,
const wmKeyMapItemFind_Params *params,
wmKeyMap **r_keymap)
{
/* XXX Hack! Macro operators in menu entry have their whole props defined,
* which is not the case for relevant keymap entries.
* Could be good to check and harmonize this,
* but for now always compare non-strict in this case. */
wmOperatorType *ot = WM_operatortype_find(opname, true);
if (ot) {
is_strict = is_strict && ((ot->flag & OPTYPE_MACRO) == 0);
}
wmKeyMapItem *found = wm_keymap_item_find_props(
C, opname, opcontext, properties, is_strict, params, r_keymap);
/* This block is *only* useful in one case: when op uses an enum menu in its prop member
* (then, we want to rerun a comparison with that 'prop' unset). Note this remains brittle,
* since now any enum prop may be used in UI (specified by name), ot->prop is not so much used...
* Otherwise:
* * If non-strict, unset properties always match set ones in IDP_EqualsProperties_ex.
* * If strict, unset properties never match set ones in IDP_EqualsProperties_ex,
* and we do not want that to change (else we get things like #41757)!
* ...so in either case, re-running a comparison with unset props set to default is useless.
*/
if (!found && properties) {
if (ot && ot->prop) { /* XXX Shall we also check ot->prop is actually an enum? */
/* Make a copy of the properties and unset the 'ot->prop' one if set. */
IDProperty *properties_temp = IDP_CopyProperty(properties);
PointerRNA opptr = RNA_pointer_create(nullptr, ot->srna, properties_temp);
if (RNA_property_is_set(&opptr, ot->prop)) {
/* For operator that has enum menu,
* unset it so its value does not affect comparison result. */
RNA_property_unset(&opptr, ot->prop);
found = wm_keymap_item_find_props(
C, opname, opcontext, properties_temp, is_strict, params, r_keymap);
}
IDP_FreeProperty(properties_temp);
}
}
/* Debug only, helps spotting mismatches between menu entries and shortcuts! */
if (G.debug & G_DEBUG_WM) {
if (!found && is_strict && properties) {
if (ot) {
/* Make a copy of the properties and set unset ones to their default values. */
IDProperty *properties_default = IDP_CopyProperty(properties);
PointerRNA opptr = RNA_pointer_create(nullptr, ot->srna, properties_default);
WM_operator_properties_default(&opptr, true);
wmKeyMap *km;
wmKeyMapItem *kmi = wm_keymap_item_find_props(
C, opname, opcontext, properties_default, is_strict, params, &km);
if (kmi) {
std::string kmi_str = WM_keymap_item_to_string(kmi, false).value_or("");
printf(
"%s: Some set values in keymap entry match default op values, "
"this might not be desired!\n",
opname);
printf("\tkm: '%s', kmi: '%s'\n", km->idname, kmi_str.c_str());
#ifndef NDEBUG
# ifdef WITH_PYTHON
printf("OPERATOR\n");
IDP_print(properties);
printf("KEYMAP\n");
IDP_print(static_cast<IDProperty *>(kmi->ptr->data));
# endif
#endif
printf("\n");
}
IDP_FreeProperty(properties_default);
}
}
}
return found;
}
static bool kmi_filter_is_visible(const wmKeyMap * /*km*/,
const wmKeyMapItem *kmi,
void * /*user_data*/)
{
return ((WM_key_event_string(kmi->type, false)[0] != '\0') &&
(IS_EVENT_ACTIONZONE(kmi->type) == false));
}
std::optional<std::string> WM_key_event_operator_string(const bContext *C,
const char *opname,
wmOperatorCallContext opcontext,
IDProperty *properties,
const bool is_strict)
{
wmKeyMapItemFind_Params params{};
params.filter_fn = kmi_filter_is_visible;
params.user_data = nullptr;
wmKeyMapItem *kmi = wm_keymap_item_find(
C, opname, opcontext, properties, is_strict, &params, nullptr);
if (kmi) {
return WM_keymap_item_to_string(kmi, false);
}
/* Check UI state (non key-map actions for UI regions). */
if (std::optional<std::string> result = UI_key_event_operator_string(
C, opname, properties, is_strict))
{
return result;
}
return std::nullopt;
}
static bool kmi_filter_is_visible_type_mask(const wmKeyMap *km,
const wmKeyMapItem *kmi,
void *user_data)
{
short *mask_pair = static_cast<short int *>(user_data);
return ((WM_event_type_mask_test(kmi->type, eEventType_Mask(mask_pair[0])) == true) &&
(WM_event_type_mask_test(kmi->type, eEventType_Mask(mask_pair[1])) == false) &&
kmi_filter_is_visible(km, kmi, user_data));
}
wmKeyMapItem *WM_key_event_operator(const bContext *C,
const char *opname,
wmOperatorCallContext opcontext,
IDProperty *properties,
const short include_mask,
const short exclude_mask,
wmKeyMap **r_keymap)
{
short user_data_mask[2] = {include_mask, exclude_mask};
bool use_mask = (include_mask != EVT_TYPE_MASK_ALL) || (exclude_mask != 0);
wmKeyMapItemFind_Params params{};
params.filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible;
params.user_data = use_mask ? user_data_mask : nullptr;
return wm_keymap_item_find(C, opname, opcontext, properties, true, &params, r_keymap);
}
wmKeyMapItem *WM_key_event_operator_from_keymap(wmKeyMap *keymap,
const char *opname,
IDProperty *properties,
const short include_mask,
const short exclude_mask)
{
short user_data_mask[2] = {include_mask, exclude_mask};
bool use_mask = (include_mask != EVT_TYPE_MASK_ALL) || (exclude_mask != 0);
wmKeyMapItemFind_Params params{};
params.filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible;
params.user_data = use_mask ? user_data_mask : nullptr;
return wm_keymap_item_find_in_keymap(keymap, opname, properties, true, &params);
}
bool WM_keymap_item_compare(const wmKeyMapItem *k1, const wmKeyMapItem *k2)
{
if (k1->flag & KMI_INACTIVE || k2->flag & KMI_INACTIVE) {
return false;
}
/* Take event mapping into account. */
int k1type = WM_userdef_event_map(k1->type);
int k2type = WM_userdef_event_map(k2->type);
if (k1type != KM_ANY && k2type != KM_ANY && k1type != k2type) {
return false;
}
if (k1->val != KM_ANY && k2->val != KM_ANY) {
/* Take click, press, release conflict into account. */
if (k1->val == KM_CLICK && ELEM(k2->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0) {
return false;
}
if (k2->val == KM_CLICK && ELEM(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0) {
return false;
}
if (k1->val != k2->val) {
return false;
}
if (k1->val == KM_CLICK_DRAG && (k1->direction != k2->direction)) {
return false;
}
}
if (k1->shift != KM_ANY && k2->shift != KM_ANY && k1->shift != k2->shift) {
return false;
}
if (k1->ctrl != KM_ANY && k2->ctrl != KM_ANY && k1->ctrl != k2->ctrl) {
return false;
}
if (k1->alt != KM_ANY && k2->alt != KM_ANY && k1->alt != k2->alt) {
return false;
}
if (k1->oskey != KM_ANY && k2->oskey != KM_ANY && k1->oskey != k2->oskey) {
return false;
}
if (k1->keymodifier != k2->keymodifier) {
return false;
}
return true;
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Update Final Configuration
*
* On load or other changes, the final user key configuration is rebuilt from the preset,
* add-on and user preferences keymaps. We also test if the final configuration changed and write
* the changes to the user preferences.
* \{ */
/* So operator removal can trigger update. */
enum {
WM_KEYMAP_UPDATE_RECONFIGURE = (1 << 0),
/* Ensure all wmKeyMap have their operator types validated after removing an operator. */
WM_KEYMAP_UPDATE_OPERATORTYPE = (1 << 1),
WM_KEYMAP_UPDATE_POSTPONE = (1 << 2),
};
static char wm_keymap_update_flag = 0;
static char wm_keymap_update_suppress_flag = 0;
#ifndef NDEBUG
static int8_t wm_keymap_update_suppress_count = 0;
#endif
void WM_keyconfig_update_tag(wmKeyMap *keymap, wmKeyMapItem *kmi)
{
/* Quick tag to do delayed keymap updates. */
wm_keymap_update_flag |= WM_KEYMAP_UPDATE_RECONFIGURE;
if (keymap) {
keymap->flag |= KEYMAP_UPDATE;
}
if (kmi) {
kmi->flag |= KMI_UPDATE;
}
}
void WM_keyconfig_update_operatortype()
{
wm_keymap_update_flag |= WM_KEYMAP_UPDATE_OPERATORTYPE;
}
/* NOTE(@ideasman42): regarding suppressing updates.
* If this becomes a common operation it would be better use something more general,
* a key-map flag for e.g. to signify that the key-map is stored outside of a #wmKeyConfig
* and should not receive updates on modification. At the moment this has the down-side of
* needing to be supported in quite a few places for something which isn't used much.
* Since the use case for this is limited, add functions to begin/end suppression.
* If these end up being used a lot we can consider alternatives. */
void WM_keyconfig_update_suppress_begin()
{
#ifndef NDEBUG
BLI_assert(wm_keymap_update_suppress_count == 0);
wm_keymap_update_suppress_count += 1;
#endif
wm_keymap_update_suppress_flag = wm_keymap_update_flag;
}
void WM_keyconfig_update_suppress_end()
{
#ifndef NDEBUG
BLI_assert(wm_keymap_update_suppress_count == 1);
wm_keymap_update_suppress_count -= 1;
#endif
wm_keymap_update_flag = wm_keymap_update_suppress_flag;
wm_keymap_update_suppress_flag = 0;
}
void WM_keyconfig_update_postpone_begin()
{
wm_keymap_update_flag |= WM_KEYMAP_UPDATE_POSTPONE;
}
void WM_keyconfig_update_postpone_end()
{
wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_POSTPONE;
}
static bool wm_keymap_test_and_clear_update(wmKeyMap *km)
{
int update = (km->flag & KEYMAP_UPDATE);
km->flag &= ~KEYMAP_UPDATE;
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &km->items) {
update = update || (kmi->flag & KMI_UPDATE);
kmi->flag &= ~KMI_UPDATE;
}
return (update != 0);
}
static wmKeyMap *wm_keymap_preset(wmWindowManager *wm, wmKeyMap *km)
{
wmKeyConfig *keyconf = WM_keyconfig_active(wm);
wmKeyMap *keymap = WM_keymap_list_find(&keyconf->keymaps, km->idname, km->spaceid, km->regionid);
if (!keymap && wm->defaultconf) {
keymap = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, km->spaceid, km->regionid);
}
return keymap;
}
void WM_keyconfig_update(wmWindowManager *wm)
{
WM_keyconfig_update_ex(wm, false);
}
void WM_keyconfig_update_ex(wmWindowManager *wm, bool keep_properties)
{
if (wm_keymap_update_flag == 0) {
return;
}
bool compat_update = false;
/* Update drop-boxes when the operators have been added or removed. While this isn't an ideal
* place to update drop-boxes, they share characteristics with key-map items.
* We could consider renaming this to API function so it's not only relating to keymaps. */
bool dropbox_update = false;
/* Postpone update until after the key-map has been initialized
* to ensure add-ons have been loaded, see: #113603. */
if (wm_keymap_update_flag & WM_KEYMAP_UPDATE_POSTPONE) {
return;
}
if (wm_keymap_update_flag & WM_KEYMAP_UPDATE_OPERATORTYPE) {
/* One or more operator-types have been removed, this won't happen often
* but when it does we have to check _every_ key-map item. */
wm_keymap_item_properties_update_ot_from_list(&U.user_keymaps, keep_properties);
LISTBASE_FOREACH (wmKeyConfig *, kc, &wm->keyconfigs) {
wm_keymap_item_properties_update_ot_from_list(&kc->keymaps, keep_properties);
}
/* An operator has been removed, refresh. */
dropbox_update = true;
wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_OPERATORTYPE;
}
if (wm_keymap_update_flag & WM_KEYMAP_UPDATE_RECONFIGURE) {
/* Update operator properties for non-modal user keymaps. */
LISTBASE_FOREACH (wmKeyMap *, km, &U.user_keymaps) {
if ((km->flag & KEYMAP_MODAL) == 0) {
LISTBASE_FOREACH (wmKeyMapDiffItem *, kmdi, &km->diff_items) {
if (kmdi->add_item) {
wm_keymap_item_properties_set(kmdi->add_item);
}
if (kmdi->remove_item) {
wm_keymap_item_properties_set(kmdi->remove_item);
}
}
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &km->items) {
wm_keymap_item_properties_set(kmi);
}
}
}
/* Update `U.user_keymaps` with user key configuration changes. */
LISTBASE_FOREACH (wmKeyMap *, km, &wm->userconf->keymaps) {
/* Only diff if the user keymap was modified. */
if (wm_keymap_test_and_clear_update(km)) {
/* Find keymaps. */
wmKeyMap *defaultmap = wm_keymap_preset(wm, km);
wmKeyMap *addonmap = WM_keymap_list_find(
&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
/* Diff. */
if (defaultmap) {
wm_keymap_diff_update(&U.user_keymaps, defaultmap, addonmap, km);
}
}
}
/* Create user key configuration from preset + addon + user preferences. */
LISTBASE_FOREACH (wmKeyMap *, km, &wm->defaultconf->keymaps) {
/* Find keymaps. */
wmKeyMap *defaultmap = wm_keymap_preset(wm, km);
wmKeyMap *addonmap = WM_keymap_list_find(
&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
wmKeyMap *usermap = WM_keymap_list_find(
&U.user_keymaps, km->idname, km->spaceid, km->regionid);
/* For now only the default map defines modal key-maps,
* if we support modal keymaps for 'addonmap', these will need to be enabled too. */
wm_user_modal_keymap_set_items(wm, defaultmap);
/* Add. */
wmKeyMap *kmn = wm_keymap_patch_update(
&wm->userconf->keymaps, defaultmap, addonmap, usermap);
if (kmn) {
kmn->modal_items = km->modal_items;
kmn->poll = km->poll;
kmn->poll_modal_item = km->poll_modal_item;
}
/* In case of old non-diff keymaps, force extra update to create diffs. */
compat_update = compat_update || (usermap && !(usermap->flag & KEYMAP_DIFF));
}
/* An operator may have been added, refresh. */
dropbox_update = true;
wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_RECONFIGURE;
}
BLI_assert(wm_keymap_update_flag == 0);
if (compat_update) {
WM_keyconfig_update_tag(nullptr, nullptr);
WM_keyconfig_update(wm);
}
if (dropbox_update) {
WM_dropbox_update_ot();
}
/* NOTE(@ideasman42): open preferences will contain "stale" #wmKeyMapItem data.
*
* The common case this solves is using Blender with the key-map editor open,
* an action in the view-port for e.g. may manipulate the key-map causing it to be rebuilt.
* Later interaction with the key-map editor may then attempt to access freed data.
*
* Take care, this is _not_ fool proof because it's possible:
* - Key-map options to be shown in any region (using scripts).
* - Key-map re-generation could happen while the preferences is open,
* where the data becomes stale before the UI has a chance to redraw.
*
* In practice both cases are quite unlikely though. */
if (U.space_data.section_active == USER_SECTION_KEYMAP) {
LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
bScreen *screen = WM_window_get_active_screen(win);
LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
if (area->spacetype == SPACE_USERPREF) {
ED_area_tag_redraw(area);
}
}
}
}
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Event Handling
*
* Handlers have pointers to the keymap in the default configuration.
* During event handling this function is called to get the keymap from the final configuration.
* \{ */
wmKeyMap *WM_keymap_active(const wmWindowManager *wm, wmKeyMap *keymap)
{
if (!keymap) {
return nullptr;
}
/* First user defined keymaps. */
wmKeyMap *km = WM_keymap_list_find(
&wm->userconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
if (km) {
return km;
}
return keymap;
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Keymap Editor
*
* In the keymap editor the user key configuration is edited.
* \{ */
void WM_keymap_item_restore_to_default(wmWindowManager *wm, wmKeyMap *keymap, wmKeyMapItem *kmi)
{
if (!keymap) {
return;
}
/* Construct default keymap from preset + addons. */
wmKeyMap *defaultmap = wm_keymap_preset(wm, keymap);
wmKeyMap *addonmap = WM_keymap_list_find(
&wm->addonconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
if (addonmap) {
defaultmap = wm_keymap_copy(defaultmap);
wm_keymap_addon_add(defaultmap, addonmap);
}
/* Find original item. */
wmKeyMapItem *orig = WM_keymap_item_find_id(defaultmap, kmi->id);
if (orig) {
/* Restore to original. */
if (!STREQ(orig->idname, kmi->idname)) {
STRNCPY(kmi->idname, orig->idname);
WM_keymap_item_properties_reset(kmi, nullptr);
}
if (orig->properties) {
if (kmi->properties) {
IDP_FreeProperty(kmi->properties);
kmi->properties = nullptr;
}
kmi->properties = IDP_CopyProperty(orig->properties);
if (kmi->ptr) {
kmi->ptr->data = kmi->properties;
}
}
kmi->propvalue = orig->propvalue;
kmi->type = orig->type;
kmi->val = orig->val;
kmi->shift = orig->shift;
kmi->ctrl = orig->ctrl;
kmi->alt = orig->alt;
kmi->oskey = orig->oskey;
kmi->keymodifier = orig->keymodifier;
kmi->maptype = orig->maptype;
kmi->flag = (kmi->flag & ~(KMI_REPEAT_IGNORE | KMI_INACTIVE)) |
(orig->flag & (KMI_REPEAT_IGNORE | KMI_INACTIVE));
WM_keyconfig_update_tag(keymap, kmi);
}
/* Free temporary keymap. */
if (addonmap) {
WM_keymap_clear(defaultmap);
MEM_freeN(defaultmap);
}
}
void WM_keymap_restore_to_default(wmKeyMap *keymap, wmWindowManager *wm)
{
/* Remove keymap from U.user_keymaps and update. */
wmKeyMap *usermap = WM_keymap_list_find(
&U.user_keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
if (usermap) {
WM_keymap_clear(usermap);
BLI_freelinkN(&U.user_keymaps, usermap);
WM_keyconfig_update_tag(nullptr, nullptr);
WM_keyconfig_update(wm);
}
}
wmKeyMapItem *WM_keymap_item_find_id(wmKeyMap *keymap, int id)
{
LISTBASE_FOREACH (wmKeyMapItem *, kmi, &keymap->items) {
if (kmi->id == id) {
return kmi;
}
}
return nullptr;
}
const char *WM_bool_as_string(bool test)
{
return test ? IFACE_("ON") : IFACE_("OFF");
}
/** \} */
Reference in New Issue View Git Blame Copy Permalink