diff options
author | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:17:24 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:21:24 +0300 |
commit | e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 (patch) | |
tree | 8cf3453d12edb177a218ef8009357518ec6cab6a /source/blender/windowmanager/intern/wm_keymap.c | |
parent | b3dabc200a4b0399ec6b81f2ff2730d07b44fcaa (diff) |
ClangFormat: apply to source, most of intern
Apply clang format as proposed in T53211.
For details on usage and instructions for migrating branches
without conflicts, see:
https://wiki.blender.org/wiki/Tools/ClangFormat
Diffstat (limited to 'source/blender/windowmanager/intern/wm_keymap.c')
-rw-r--r-- | source/blender/windowmanager/intern/wm_keymap.c | 2826 |
1 files changed, 1449 insertions, 1377 deletions
diff --git a/source/blender/windowmanager/intern/wm_keymap.c b/source/blender/windowmanager/intern/wm_keymap.c index ba9accb5dee..3feae3d7dfc 100644 --- a/source/blender/windowmanager/intern/wm_keymap.c +++ b/source/blender/windowmanager/intern/wm_keymap.c @@ -57,8 +57,8 @@ #include "wm_event_types.h" struct wmKeyMapItemFind_Params { - bool (*filter_fn)(const wmKeyMap *km, const wmKeyMapItem *kmi, void *user_data); - void *user_data; + bool (*filter_fn)(const wmKeyMap *km, const wmKeyMapItem *kmi, void *user_data); + void *user_data; }; /******************************* Keymap Item ********************************** @@ -66,41 +66,41 @@ struct wmKeyMapItemFind_Params { static wmKeyMapItem *wm_keymap_item_copy(wmKeyMapItem *kmi) { - wmKeyMapItem *kmin = MEM_dupallocN(kmi); + wmKeyMapItem *kmin = MEM_dupallocN(kmi); - kmin->prev = kmin->next = NULL; - kmin->flag &= ~KMI_UPDATE; + kmin->prev = kmin->next = NULL; + kmin->flag &= ~KMI_UPDATE; - if (kmin->properties) { - kmin->ptr = MEM_callocN(sizeof(PointerRNA), "UserKeyMapItemPtr"); - WM_operator_properties_create(kmin->ptr, kmin->idname); + if (kmin->properties) { + kmin->ptr = MEM_callocN(sizeof(PointerRNA), "UserKeyMapItemPtr"); + WM_operator_properties_create(kmin->ptr, kmin->idname); - kmin->properties = IDP_CopyProperty(kmin->properties); - kmin->ptr->data = kmin->properties; - } - else { - kmin->properties = NULL; - kmin->ptr = NULL; - } + kmin->properties = IDP_CopyProperty(kmin->properties); + kmin->ptr->data = kmin->properties; + } + else { + kmin->properties = NULL; + kmin->ptr = NULL; + } - return kmin; + return kmin; } static void wm_keymap_item_free(wmKeyMapItem *kmi) { - /* not kmi itself */ - if (kmi->ptr) { - WM_operator_properties_free(kmi->ptr); - MEM_freeN(kmi->ptr); - kmi->ptr = NULL; - kmi->properties = NULL; - } + /* not kmi itself */ + if (kmi->ptr) { + WM_operator_properties_free(kmi->ptr); + MEM_freeN(kmi->ptr); + kmi->ptr = NULL; + kmi->properties = NULL; + } } 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, 1); + WM_operator_properties_alloc(&(kmi->ptr), &(kmi->properties), kmi->idname); + WM_operator_properties_sanitize(kmi->ptr, 1); } /** @@ -108,152 +108,144 @@ static void wm_keymap_item_properties_set(wmKeyMapItem *kmi) */ static void wm_keymap_item_properties_update_ot(wmKeyMapItem *kmi) { - if (kmi->idname[0] == 0) { - BLI_assert(kmi->ptr == NULL); - return; - } - - if (kmi->ptr == NULL) { - wm_keymap_item_properties_set(kmi); - } - else { - wmOperatorType *ot = WM_operatortype_find(kmi->idname, 0); - 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' NULL'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, 1); - } - } - else { - /* zombie keymap item */ - wm_keymap_item_free(kmi); - } - } + if (kmi->idname[0] == 0) { + BLI_assert(kmi->ptr == NULL); + return; + } + + if (kmi->ptr == NULL) { + wm_keymap_item_properties_set(kmi); + } + else { + wmOperatorType *ot = WM_operatortype_find(kmi->idname, 0); + 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' NULL'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, 1); + } + } + else { + /* zombie keymap item */ + wm_keymap_item_free(kmi); + } + } } static void wm_keyconfig_properties_update_ot(ListBase *km_lb) { - wmKeyMap *km; - wmKeyMapItem *kmi; + wmKeyMap *km; + wmKeyMapItem *kmi; - for (km = km_lb->first; km; km = km->next) { - wmKeyMapDiffItem *kmdi; + for (km = km_lb->first; km; km = km->next) { + wmKeyMapDiffItem *kmdi; - for (kmi = km->items.first; kmi; kmi = kmi->next) { - wm_keymap_item_properties_update_ot(kmi); - } + for (kmi = km->items.first; kmi; kmi = kmi->next) { + wm_keymap_item_properties_update_ot(kmi); + } - for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) { - if (kmdi->add_item) { - wm_keymap_item_properties_update_ot(kmdi->add_item); - } - if (kmdi->remove_item) { - wm_keymap_item_properties_update_ot(kmdi->remove_item); - } - } - } + for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) { + if (kmdi->add_item) { + wm_keymap_item_properties_update_ot(kmdi->add_item); + } + if (kmdi->remove_item) { + wm_keymap_item_properties_update_ot(kmdi->remove_item); + } + } + } } 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); + 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); + 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); } /* properties can be NULL, otherwise the arg passed is used and ownership is given to the kmi */ void WM_keymap_properties_reset(wmKeyMapItem *kmi, struct IDProperty *properties) { - if (LIKELY(kmi->ptr)) { - WM_operator_properties_free(kmi->ptr); - MEM_freeN(kmi->ptr); + if (LIKELY(kmi->ptr)) { + WM_operator_properties_free(kmi->ptr); + MEM_freeN(kmi->ptr); - kmi->ptr = NULL; - } + kmi->ptr = NULL; + } - kmi->properties = properties; + kmi->properties = properties; - wm_keymap_item_properties_set(kmi); + wm_keymap_item_properties_set(kmi); } int WM_keymap_map_type_get(wmKeyMapItem *kmi) { - if (ISTIMER(kmi->type)) { - return KMI_TYPE_TIMER; - } - if (ISKEYBOARD(kmi->type)) { - return KMI_TYPE_KEYBOARD; - } - if (ISTWEAK(kmi->type)) { - return KMI_TYPE_TWEAK; - } - 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; + if (ISTIMER(kmi->type)) { + return KMI_TYPE_TIMER; + } + if (ISKEYBOARD(kmi->type)) { + return KMI_TYPE_KEYBOARD; + } + if (ISTWEAK(kmi->type)) { + return KMI_TYPE_TWEAK; + } + 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; } - /**************************** 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 = MEM_dupallocN(kmdi); + wmKeyMapDiffItem *kmdin = MEM_dupallocN(kmdi); - kmdin->next = kmdin->prev = NULL; - 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); - } + kmdin->next = kmdin->prev = NULL; + 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; + return kmdin; } static void wm_keymap_diff_item_free(wmKeyMapDiffItem *kmdi) { - if (kmdi->remove_item) { - wm_keymap_item_free(kmdi->remove_item); - MEM_freeN(kmdi->remove_item); - } - if (kmdi->add_item) { - wm_keymap_item_free(kmdi->add_item); - MEM_freeN(kmdi->add_item); - } + if (kmdi->remove_item) { + wm_keymap_item_free(kmdi->remove_item); + MEM_freeN(kmdi->remove_item); + } + if (kmdi->add_item) { + wm_keymap_item_free(kmdi->add_item); + MEM_freeN(kmdi->add_item); + } } /***************************** Key Configuration ****************************** @@ -262,98 +254,98 @@ static void wm_keymap_diff_item_free(wmKeyMapDiffItem *kmdi) wmKeyConfig *WM_keyconfig_new(wmWindowManager *wm, const char *idname, bool user_defined) { - wmKeyConfig *keyconf = 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. */ - for (wmKeyMap *km = keyconf->keymaps.first; km; km = km->next) { - WM_keymap_clear(km); - } - } - else { - /* For user defined key configuration, clear all keymaps. */ - WM_keyconfig_clear(keyconf); - } + wmKeyConfig *keyconf = 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. */ + for (wmKeyMap *km = keyconf->keymaps.first; km; km = km->next) { + WM_keymap_clear(km); + } + } + else { + /* For user defined key configuration, clear all keymaps. */ + WM_keyconfig_clear(keyconf); + } - return keyconf; - } + return keyconf; + } - /* Create new configuration. */ - keyconf = MEM_callocN(sizeof(wmKeyConfig), "wmKeyConfig"); - BLI_strncpy(keyconf->idname, idname, sizeof(keyconf->idname)); - BLI_addtail(&wm->keyconfigs, keyconf); + /* Create new configuration. */ + keyconf = MEM_callocN(sizeof(wmKeyConfig), "wmKeyConfig"); + BLI_strncpy(keyconf->idname, idname, sizeof(keyconf->idname)); + BLI_addtail(&wm->keyconfigs, keyconf); - if (user_defined) { - keyconf->flag |= KEYCONF_USER; - } + if (user_defined) { + keyconf->flag |= KEYCONF_USER; + } - return keyconf; + return keyconf; } wmKeyConfig *WM_keyconfig_new_user(wmWindowManager *wm, const char *idname) { - return WM_keyconfig_new(wm, idname, true); + return WM_keyconfig_new(wm, idname, true); } bool WM_keyconfig_remove(wmWindowManager *wm, wmKeyConfig *keyconf) { - if (BLI_findindex(&wm->keyconfigs, keyconf) != -1) { - if (STREQLEN(U.keyconfigstr, keyconf->idname, sizeof(U.keyconfigstr))) { - BLI_strncpy(U.keyconfigstr, wm->defaultconf->idname, sizeof(U.keyconfigstr)); - WM_keyconfig_update_tag(NULL, NULL); - } + if (BLI_findindex(&wm->keyconfigs, keyconf) != -1) { + if (STREQLEN(U.keyconfigstr, keyconf->idname, sizeof(U.keyconfigstr))) { + BLI_strncpy(U.keyconfigstr, wm->defaultconf->idname, sizeof(U.keyconfigstr)); + WM_keyconfig_update_tag(NULL, NULL); + } - BLI_remlink(&wm->keyconfigs, keyconf); - WM_keyconfig_free(keyconf); + BLI_remlink(&wm->keyconfigs, keyconf); + WM_keyconfig_free(keyconf); - return true; - } - else { - return false; - } + return true; + } + else { + return false; + } } void WM_keyconfig_clear(wmKeyConfig *keyconf) { - for (wmKeyMap *km = keyconf->keymaps.first; km; km = km->next) { - WM_keymap_clear(km); - } + for (wmKeyMap *km = keyconf->keymaps.first; km; km = km->next) { + WM_keymap_clear(km); + } - BLI_freelistN(&keyconf->keymaps); + BLI_freelistN(&keyconf->keymaps); } void WM_keyconfig_free(wmKeyConfig *keyconf) { - WM_keyconfig_clear(keyconf); - MEM_freeN(keyconf); + WM_keyconfig_clear(keyconf); + MEM_freeN(keyconf); } static wmKeyConfig *WM_keyconfig_active(wmWindowManager *wm) { - wmKeyConfig *keyconf; + wmKeyConfig *keyconf; - /* first try from preset */ - keyconf = BLI_findstring(&wm->keyconfigs, U.keyconfigstr, offsetof(wmKeyConfig, idname)); - if (keyconf) { - return keyconf; - } + /* first try from preset */ + keyconf = BLI_findstring(&wm->keyconfigs, U.keyconfigstr, offsetof(wmKeyConfig, idname)); + if (keyconf) { + return keyconf; + } - /* otherwise use default */ - return wm->defaultconf; + /* 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 */ + /* setting a different key configuration as active: we ensure all is + * updated properly before and after making the change */ - WM_keyconfig_update(wm); + WM_keyconfig_update(wm); - BLI_strncpy(U.keyconfigstr, idname, sizeof(U.keyconfigstr)); + BLI_strncpy(U.keyconfigstr, idname, sizeof(U.keyconfigstr)); - WM_keyconfig_update_tag(NULL, NULL); - WM_keyconfig_update(wm); + WM_keyconfig_update_tag(NULL, NULL); + WM_keyconfig_update(wm); } /********************************** Keymap ************************************* @@ -361,200 +353,204 @@ void WM_keyconfig_set_active(wmWindowManager *wm, const char *idname) static wmKeyMap *wm_keymap_new(const char *idname, int spaceid, int regionid) { - wmKeyMap *km = MEM_callocN(sizeof(struct wmKeyMap), "keymap list"); + wmKeyMap *km = MEM_callocN(sizeof(struct wmKeyMap), "keymap list"); - BLI_strncpy(km->idname, idname, KMAP_MAX_NAME); - km->spaceid = spaceid; - km->regionid = regionid; + BLI_strncpy(km->idname, idname, KMAP_MAX_NAME); + km->spaceid = spaceid; + km->regionid = regionid; - { - const char *owner_id = RNA_struct_state_owner_get(); - if (owner_id) { - BLI_strncpy(km->owner_id, owner_id, sizeof(km->owner_id)); - } - } - return km; + { + const char *owner_id = RNA_struct_state_owner_get(); + if (owner_id) { + BLI_strncpy(km->owner_id, owner_id, sizeof(km->owner_id)); + } + } + return km; } static wmKeyMap *wm_keymap_copy(wmKeyMap *keymap) { - wmKeyMap *keymapn = MEM_dupallocN(keymap); - wmKeyMapItem *kmi, *kmin; - wmKeyMapDiffItem *kmdi, *kmdin; + wmKeyMap *keymapn = MEM_dupallocN(keymap); + wmKeyMapItem *kmi, *kmin; + wmKeyMapDiffItem *kmdi, *kmdin; - 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); + 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); - for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) { - kmdin = wm_keymap_diff_item_copy(kmdi); - BLI_addtail(&keymapn->items, kmdin); - } + for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) { + kmdin = wm_keymap_diff_item_copy(kmdi); + BLI_addtail(&keymapn->items, kmdin); + } - for (kmi = keymap->items.first; kmi; kmi = kmi->next) { - kmin = wm_keymap_item_copy(kmi); - BLI_addtail(&keymapn->items, kmin); - } + for (kmi = keymap->items.first; kmi; kmi = kmi->next) { + kmin = wm_keymap_item_copy(kmi); + BLI_addtail(&keymapn->items, kmin); + } - return keymapn; + return keymapn; } void WM_keymap_clear(wmKeyMap *keymap) { - wmKeyMapItem *kmi; - wmKeyMapDiffItem *kmdi; + wmKeyMapItem *kmi; + wmKeyMapDiffItem *kmdi; - for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) { - wm_keymap_diff_item_free(kmdi); - } + for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) { + wm_keymap_diff_item_free(kmdi); + } - for (kmi = keymap->items.first; kmi; kmi = kmi->next) { - wm_keymap_item_free(kmi); - } + for (kmi = keymap->items.first; kmi; kmi = kmi->next) { + wm_keymap_item_free(kmi); + } - BLI_freelistN(&keymap->diff_items); - BLI_freelistN(&keymap->items); + BLI_freelistN(&keymap->diff_items); + BLI_freelistN(&keymap->items); } bool WM_keymap_remove(wmKeyConfig *keyconf, wmKeyMap *keymap) { - if (BLI_findindex(&keyconf->keymaps, keymap) != -1) { + if (BLI_findindex(&keyconf->keymaps, keymap) != -1) { - WM_keymap_clear(keymap); - BLI_remlink(&keyconf->keymaps, keymap); - MEM_freeN(keymap); + WM_keymap_clear(keymap); + BLI_remlink(&keyconf->keymaps, keymap); + MEM_freeN(keymap); - return true; - } - else { - return false; - } + return true; + } + else { + return false; + } } - 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 loosing time investigating each case. */ - CLOG_WARN(WM_LOG_KEYMAPS, "empty keymap '%s'", keymap->idname); - } - - if (keymap->poll != NULL) { - return keymap->poll(C); - } - return true; -} - -static void keymap_event_set(wmKeyMapItem *kmi, short type, short val, int modifier, short keymodifier) -{ - kmi->type = type; - kmi->val = val; - kmi->keymodifier = keymodifier; - - if (modifier == KM_ANY) { - kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY; - } - else { - kmi->shift = (modifier & KM_SHIFT) ? KM_MOD_FIRST : ((modifier & KM_SHIFT2) ? KM_MOD_SECOND : false); - kmi->ctrl = (modifier & KM_CTRL) ? KM_MOD_FIRST : ((modifier & KM_CTRL2) ? KM_MOD_SECOND : false); - kmi->alt = (modifier & KM_ALT) ? KM_MOD_FIRST : ((modifier & KM_ALT2) ? KM_MOD_SECOND : false); - kmi->oskey = (modifier & KM_OSKEY) ? KM_MOD_FIRST : ((modifier & KM_OSKEY2) ? KM_MOD_SECOND : false); - } + /* 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 loosing time investigating each case. */ + CLOG_WARN(WM_LOG_KEYMAPS, "empty keymap '%s'", keymap->idname); + } + + if (keymap->poll != NULL) { + return keymap->poll(C); + } + return true; +} + +static void keymap_event_set( + wmKeyMapItem *kmi, short type, short val, int modifier, short keymodifier) +{ + kmi->type = type; + kmi->val = val; + kmi->keymodifier = keymodifier; + + if (modifier == KM_ANY) { + kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY; + } + else { + kmi->shift = (modifier & KM_SHIFT) ? KM_MOD_FIRST : + ((modifier & KM_SHIFT2) ? KM_MOD_SECOND : false); + kmi->ctrl = (modifier & KM_CTRL) ? KM_MOD_FIRST : + ((modifier & KM_CTRL2) ? KM_MOD_SECOND : false); + kmi->alt = (modifier & KM_ALT) ? KM_MOD_FIRST : ((modifier & KM_ALT2) ? KM_MOD_SECOND : false); + kmi->oskey = (modifier & KM_OSKEY) ? KM_MOD_FIRST : + ((modifier & KM_OSKEY2) ? KM_MOD_SECOND : false); + } } 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 */ - } + 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 */ + } } /* if item was added, then bail out */ -wmKeyMapItem *WM_keymap_verify_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier) +wmKeyMapItem *WM_keymap_verify_item( + wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier) { - wmKeyMapItem *kmi; + wmKeyMapItem *kmi; - for (kmi = keymap->items.first; kmi; kmi = kmi->next) { - if (STREQLEN(kmi->idname, idname, OP_MAX_TYPENAME)) { - break; - } - } - if (kmi == NULL) { - kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"); + for (kmi = keymap->items.first; kmi; kmi = kmi->next) { + if (STREQLEN(kmi->idname, idname, OP_MAX_TYPENAME)) { + break; + } + } + if (kmi == NULL) { + kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"); - BLI_addtail(&keymap->items, kmi); - BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME); + BLI_addtail(&keymap->items, kmi); + BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME); - keymap_item_set_id(keymap, kmi); + keymap_item_set_id(keymap, kmi); - keymap_event_set(kmi, type, val, modifier, keymodifier); - wm_keymap_item_properties_set(kmi); - } - return kmi; + keymap_event_set(kmi, type, val, modifier, keymodifier); + wm_keymap_item_properties_set(kmi); + } + return kmi; } /* always add item */ -wmKeyMapItem *WM_keymap_add_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier) +wmKeyMapItem *WM_keymap_add_item( + wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier) { - wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"); + wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"); - BLI_addtail(&keymap->items, kmi); - BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME); + BLI_addtail(&keymap->items, kmi); + BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME); - keymap_event_set(kmi, type, val, modifier, keymodifier); - wm_keymap_item_properties_set(kmi); + keymap_event_set(kmi, type, val, modifier, keymodifier); + wm_keymap_item_properties_set(kmi); - keymap_item_set_id(keymap, kmi); + keymap_item_set_id(keymap, kmi); - WM_keyconfig_update_tag(keymap, kmi); + WM_keyconfig_update_tag(keymap, kmi); - return kmi; + return kmi; } -wmKeyMapItem *WM_keymap_add_item_copy( - struct wmKeyMap *keymap, wmKeyMapItem *kmi_src) +wmKeyMapItem *WM_keymap_add_item_copy(struct wmKeyMap *keymap, wmKeyMapItem *kmi_src) { - wmKeyMapItem *kmi_dst = wm_keymap_item_copy(kmi_src); + wmKeyMapItem *kmi_dst = wm_keymap_item_copy(kmi_src); - BLI_addtail(&keymap->items, kmi_dst); + BLI_addtail(&keymap->items, kmi_dst); - keymap_item_set_id(keymap, kmi_dst); + keymap_item_set_id(keymap, kmi_dst); - WM_keyconfig_update_tag(keymap, kmi_dst); + WM_keyconfig_update_tag(keymap, kmi_dst); - return kmi_dst; + return kmi_dst; } bool WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi) { - if (BLI_findindex(&keymap->items, kmi) != -1) { - if (kmi->ptr) { - WM_operator_properties_free(kmi->ptr); - MEM_freeN(kmi->ptr); - } - BLI_freelinkN(&keymap->items, kmi); + if (BLI_findindex(&keymap->items, kmi) != -1) { + if (kmi->ptr) { + WM_operator_properties_free(kmi->ptr); + MEM_freeN(kmi->ptr); + } + BLI_freelinkN(&keymap->items, kmi); - WM_keyconfig_update_tag(keymap, NULL); - return true; - } - else { - return false; - } + WM_keyconfig_update_tag(keymap, NULL); + return true; + } + else { + return false; + } } /************************** Keymap Diff and Patch **************************** @@ -565,254 +561,261 @@ bool WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi) static void wm_keymap_addon_add(wmKeyMap *keymap, wmKeyMap *addonmap) { - wmKeyMapItem *kmi, *kmin; + wmKeyMapItem *kmi, *kmin; - for (kmi = addonmap->items.first; kmi; kmi = kmi->next) { - kmin = wm_keymap_item_copy(kmi); - keymap_item_set_id(keymap, kmin); - BLI_addhead(&keymap->items, kmin); - } + for (kmi = addonmap->items.first; kmi; kmi = kmi->next) { + kmin = wm_keymap_item_copy(kmi); + keymap_item_set_id(keymap, kmin); + BLI_addhead(&keymap->items, kmin); + } } static wmKeyMapItem *wm_keymap_find_item_equals(wmKeyMap *km, wmKeyMapItem *needle) { - wmKeyMapItem *kmi; + wmKeyMapItem *kmi; - for (kmi = km->items.first; kmi; kmi = kmi->next) { - if (wm_keymap_item_equals(kmi, needle)) { - return kmi; - } - } + for (kmi = km->items.first; kmi; kmi = kmi->next) { + if (wm_keymap_item_equals(kmi, needle)) { + return kmi; + } + } - return NULL; + return NULL; } static wmKeyMapItem *wm_keymap_find_item_equals_result(wmKeyMap *km, wmKeyMapItem *needle) { - wmKeyMapItem *kmi; - - for (kmi = km->items.first; kmi; kmi = kmi->next) { - if (wm_keymap_item_equals_result(kmi, needle)) { - return kmi; - } - } - - return NULL; -} - -static void wm_keymap_diff(wmKeyMap *diff_km, wmKeyMap *from_km, wmKeyMap *to_km, wmKeyMap *orig_km, wmKeyMap *addon_km) -{ - wmKeyMapItem *kmi, *to_kmi, *orig_kmi; - wmKeyMapDiffItem *kmdi; - - for (kmi = from_km->items.first; kmi; kmi = kmi->next) { - to_kmi = WM_keymap_item_find_id(to_km, kmi->id); - - if (!to_kmi) { - /* remove item */ - kmdi = 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 */ - kmdi = 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 loose it on repatch */ - if (to_kmi) { - 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); - } - } - } - - for (kmi = to_km->items.first; kmi; kmi = kmi->next) { - if (kmi->id < 0) { - /* add item */ - kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem"); - kmdi->add_item = wm_keymap_item_copy(kmi); - BLI_addtail(&diff_km->diff_items, kmdi); - } - } + wmKeyMapItem *kmi; + + for (kmi = km->items.first; kmi; kmi = kmi->next) { + if (wm_keymap_item_equals_result(kmi, needle)) { + return kmi; + } + } + + return NULL; +} + +static void wm_keymap_diff( + wmKeyMap *diff_km, wmKeyMap *from_km, wmKeyMap *to_km, wmKeyMap *orig_km, wmKeyMap *addon_km) +{ + wmKeyMapItem *kmi, *to_kmi, *orig_kmi; + wmKeyMapDiffItem *kmdi; + + for (kmi = from_km->items.first; kmi; kmi = kmi->next) { + to_kmi = WM_keymap_item_find_id(to_km, kmi->id); + + if (!to_kmi) { + /* remove item */ + kmdi = 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 */ + kmdi = 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 loose it on repatch */ + if (to_kmi) { + 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); + } + } + } + + for (kmi = to_km->items.first; kmi; kmi = kmi->next) { + if (kmi->id < 0) { + /* add item */ + kmdi = 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) { - wmKeyMapDiffItem *kmdi; - wmKeyMapItem *kmi_remove, *kmi_add; - - for (kmdi = diff_km->diff_items.first; kmdi; kmdi = kmdi->next) { - /* find item to remove */ - kmi_remove = NULL; - 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 T42088. */ - /* We seek only for exact copy here! See T42137. */ - 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 T45579. */ - /* 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 != NULL && kmi_add == kmi_remove) { - kmi_remove = NULL; - } - /* 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(kmi_remove); - BLI_freelinkN(&km->items, kmi_remove); - } - } -} - -static wmKeyMap *wm_keymap_patch_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *usermap) -{ - wmKeyMap *km; - int expanded = 0; - - /* remove previous keymap in list, we will replace it */ - 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 */ - wmKeyMapItem *kmi, *orig_kmi; - - km = wm_keymap_copy(usermap); - - /* try to find corresponding id's for items */ - for (kmi = km->items.first; kmi; kmi = kmi->next) { - 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) -{ - wmKeyMap *diffmap, *prevmap, *origmap; - - /* create temporary default + addon keymap for diff */ - 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 */ - 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 */ - 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); - } + wmKeyMapDiffItem *kmdi; + wmKeyMapItem *kmi_remove, *kmi_add; + + for (kmdi = diff_km->diff_items.first; kmdi; kmdi = kmdi->next) { + /* find item to remove */ + kmi_remove = NULL; + 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 T42088. */ + /* We seek only for exact copy here! See T42137. */ + 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 T45579. */ + /* 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 != NULL && kmi_add == kmi_remove) { + kmi_remove = NULL; + } + /* 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(kmi_remove); + BLI_freelinkN(&km->items, kmi_remove); + } + } +} + +static wmKeyMap *wm_keymap_patch_update(ListBase *lb, + wmKeyMap *defaultmap, + wmKeyMap *addonmap, + wmKeyMap *usermap) +{ + wmKeyMap *km; + int expanded = 0; + + /* remove previous keymap in list, we will replace it */ + 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 */ + wmKeyMapItem *kmi, *orig_kmi; + + km = wm_keymap_copy(usermap); + + /* try to find corresponding id's for items */ + for (kmi = km->items.first; kmi; kmi = kmi->next) { + 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) +{ + wmKeyMap *diffmap, *prevmap, *origmap; + + /* create temporary default + addon keymap for diff */ + 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 */ + 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 */ + 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); + } } /* ****************** storage in WM ************ */ @@ -823,745 +826,812 @@ static void wm_keymap_diff_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap * wmKeyMap *WM_keymap_list_find(ListBase *lb, const char *idname, int spaceid, int regionid) { - wmKeyMap *km; + wmKeyMap *km; - for (km = lb->first; km; km = km->next) { - if (km->spaceid == spaceid && km->regionid == regionid) { - if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) { - return km; - } - } - } + for (km = lb->first; km; km = km->next) { + if (km->spaceid == spaceid && km->regionid == regionid) { + if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) { + return km; + } + } + } - return NULL; + return NULL; } -wmKeyMap *WM_keymap_list_find_spaceid_or_empty(ListBase *lb, const char *idname, int spaceid, int regionid) +wmKeyMap *WM_keymap_list_find_spaceid_or_empty(ListBase *lb, + const char *idname, + int spaceid, + int regionid) { - wmKeyMap *km; + wmKeyMap *km; - for (km = lb->first; km; km = km->next) { - if (ELEM(km->spaceid, spaceid, SPACE_EMPTY) && km->regionid == regionid) { - if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) { - return km; - } - } - } + for (km = lb->first; km; km = km->next) { + if (ELEM(km->spaceid, spaceid, SPACE_EMPTY) && km->regionid == regionid) { + if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) { + return km; + } + } + } - return NULL; + return NULL; } wmKeyMap *WM_keymap_ensure(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid) { - wmKeyMap *km = WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid); + wmKeyMap *km = WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid); - if (km == NULL) { - km = wm_keymap_new(idname, spaceid, regionid); - BLI_addtail(&keyconf->keymaps, km); + if (km == NULL) { + km = wm_keymap_new(idname, spaceid, regionid); + BLI_addtail(&keyconf->keymaps, km); - WM_keyconfig_update_tag(km, NULL); - } + WM_keyconfig_update_tag(km, NULL); + } - return km; + return km; } wmKeyMap *WM_keymap_find_all(const bContext *C, const char *idname, int spaceid, int regionid) { - wmWindowManager *wm = CTX_wm_manager(C); + wmWindowManager *wm = CTX_wm_manager(C); - return WM_keymap_list_find(&wm->userconf->keymaps, idname, spaceid, regionid); + return WM_keymap_list_find(&wm->userconf->keymaps, idname, spaceid, regionid); } -wmKeyMap *WM_keymap_find_all_spaceid_or_empty(const bContext *C, const char *idname, int spaceid, int regionid) +wmKeyMap *WM_keymap_find_all_spaceid_or_empty(const bContext *C, + const char *idname, + int spaceid, + int regionid) { - wmWindowManager *wm = CTX_wm_manager(C); + wmWindowManager *wm = CTX_wm_manager(C); - return WM_keymap_list_find_spaceid_or_empty(&wm->userconf->keymaps, idname, spaceid, regionid); + return WM_keymap_list_find_spaceid_or_empty(&wm->userconf->keymaps, idname, spaceid, regionid); } /* ****************** modal keymaps ************ */ /* modal maps get linked to a running operator, and filter the keys before sending to modal() callback */ -wmKeyMap *WM_modalkeymap_add(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items) +wmKeyMap *WM_modalkeymap_add(wmKeyConfig *keyconf, + const char *idname, + const EnumPropertyItem *items) { - wmKeyMap *km = WM_keymap_ensure(keyconf, idname, 0, 0); - km->flag |= KEYMAP_MODAL; + wmKeyMap *km = WM_keymap_ensure(keyconf, idname, 0, 0); + km->flag |= KEYMAP_MODAL; - /* init modal items from default config */ - wmWindowManager *wm = G_MAIN->wm.first; - if (wm->defaultconf && wm->defaultconf != keyconf) { - wmKeyMap *defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0); + /* init modal items from default config */ + wmWindowManager *wm = G_MAIN->wm.first; + if (wm->defaultconf && wm->defaultconf != keyconf) { + wmKeyMap *defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0); - if (defaultkm) { - km->modal_items = defaultkm->modal_items; - km->poll = defaultkm->poll; - km->poll_modal_item = defaultkm->poll_modal_item; - } - } + 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; - } + if (items) { + km->modal_items = items; + } - return km; + return km; } wmKeyMap *WM_modalkeymap_get(wmKeyConfig *keyconf, const char *idname) { - wmKeyMap *km; + wmKeyMap *km; - for (km = keyconf->keymaps.first; km; km = km->next) { - if (km->flag & KEYMAP_MODAL) { - if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) { - break; - } - } - } + for (km = keyconf->keymaps.first; km; km = km->next) { + if (km->flag & KEYMAP_MODAL) { + if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) { + break; + } + } + } - return km; + return km; } - -wmKeyMapItem *WM_modalkeymap_add_item(wmKeyMap *km, int type, int val, int modifier, int keymodifier, int value) +wmKeyMapItem *WM_modalkeymap_add_item( + wmKeyMap *km, int type, int val, int modifier, int keymodifier, int value) { - wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"); + wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"); - BLI_addtail(&km->items, kmi); - kmi->propvalue = value; + BLI_addtail(&km->items, kmi); + kmi->propvalue = value; - keymap_event_set(kmi, type, val, modifier, keymodifier); + keymap_event_set(kmi, type, val, modifier, keymodifier); - keymap_item_set_id(km, kmi); + keymap_item_set_id(km, kmi); - WM_keyconfig_update_tag(km, kmi); + WM_keyconfig_update_tag(km, kmi); - return kmi; + return kmi; } -wmKeyMapItem *WM_modalkeymap_add_item_str(wmKeyMap *km, int type, int val, int modifier, int keymodifier, const char *value) +wmKeyMapItem *WM_modalkeymap_add_item_str( + wmKeyMap *km, int type, int val, int modifier, int keymodifier, const char *value) { - wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"); + wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry"); - BLI_addtail(&km->items, kmi); - BLI_strncpy(kmi->propvalue_str, value, sizeof(kmi->propvalue_str)); + BLI_addtail(&km->items, kmi); + BLI_strncpy(kmi->propvalue_str, value, sizeof(kmi->propvalue_str)); - keymap_event_set(kmi, type, val, modifier, keymodifier); + keymap_event_set(kmi, type, val, modifier, keymodifier); - keymap_item_set_id(km, kmi); + keymap_item_set_id(km, kmi); - WM_keyconfig_update_tag(km, kmi); + WM_keyconfig_update_tag(km, kmi); - return kmi; + return kmi; } -static wmKeyMapItem *wm_modalkeymap_find_propvalue_iter(wmKeyMap *km, wmKeyMapItem *kmi, const int propvalue) +static wmKeyMapItem *wm_modalkeymap_find_propvalue_iter(wmKeyMap *km, + wmKeyMapItem *kmi, + const int propvalue) { - if (km->flag & KEYMAP_MODAL) { - kmi = kmi ? kmi->next : km->items.first; - for (; kmi; kmi = kmi->next) { - if (kmi->propvalue == propvalue) { - return kmi; - } - } - } - else { - BLI_assert(!"called with non modal keymap"); - } + if (km->flag & KEYMAP_MODAL) { + kmi = kmi ? kmi->next : km->items.first; + for (; kmi; kmi = kmi->next) { + if (kmi->propvalue == propvalue) { + return kmi; + } + } + } + else { + BLI_assert(!"called with non modal keymap"); + } - return NULL; + return NULL; } wmKeyMapItem *WM_modalkeymap_find_propvalue(wmKeyMap *km, const int propvalue) { - return wm_modalkeymap_find_propvalue_iter(km, NULL, propvalue); + return wm_modalkeymap_find_propvalue_iter(km, NULL, propvalue); } void WM_modalkeymap_assign(wmKeyMap *km, const char *opname) { - wmOperatorType *ot = WM_operatortype_find(opname, 0); + wmOperatorType *ot = WM_operatortype_find(opname, 0); - if (ot) { - ot->modalkeymap = km; - } - else { - CLOG_ERROR(WM_LOG_KEYMAPS, "unknown operator '%s'", opname); - } + 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 */ - wmKeyMap *defaultkm; - wmKeyMapItem *kmi; - int propvalue; + /* here we convert propvalue string values delayed, due to python keymaps + * being created before the actual modal keymaps, so no modal_items */ + wmKeyMap *defaultkm; + wmKeyMapItem *kmi; + int propvalue; - if (km && (km->flag & KEYMAP_MODAL) && !km->modal_items) { - if (wm->defaultconf == NULL) { - return; - } + if (km && (km->flag & KEYMAP_MODAL) && !km->modal_items) { + if (wm->defaultconf == NULL) { + return; + } - defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0); + defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0); - if (!defaultkm) { - return; - } + if (!defaultkm) { + return; + } - km->modal_items = defaultkm->modal_items; - km->poll = defaultkm->poll; - km->poll_modal_item = defaultkm->poll_modal_item; + km->modal_items = defaultkm->modal_items; + km->poll = defaultkm->poll; + km->poll_modal_item = defaultkm->poll_modal_item; - if (km->modal_items) { - for (kmi = km->items.first; kmi; kmi = kmi->next) { - if (kmi->propvalue_str[0]) { - if (RNA_enum_value_from_id(km->modal_items, kmi->propvalue_str, &propvalue)) { - kmi->propvalue = propvalue; - } - kmi->propvalue_str[0] = '\0'; - } - } - } - } + if (km->modal_items) { + for (kmi = km->items.first; kmi; kmi = kmi->next) { + if (kmi->propvalue_str[0]) { + if (RNA_enum_value_from_id(km->modal_items, kmi->propvalue_str, &propvalue)) { + kmi->propvalue = propvalue; + } + kmi->propvalue_str[0] = '\0'; + } + } + } + } } /* ***************** get string from key events **************** */ const char *WM_key_event_string(const short type, const bool compact) { - const EnumPropertyItem *it; - const int i = RNA_enum_from_value(rna_enum_event_type_items, (int)type); + 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]; + if (i == -1) { + return ""; + } + it = &rna_enum_event_type_items[i]; - /* We first try enum items' description (abused as shortname 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); - } + /* We first try enum items' description (abused as shortname 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); + return CTX_IFACE_(BLT_I18NCONTEXT_UI_EVENTS, it->name); } /* TODO: also support (some) value, like e.g. double-click? */ -int 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, - char *result, const int result_len) -{ -#define ADD_SEP if (p != buf) *p++ = ' '; (void)0 - - char buf[128]; - char *p = buf; - - buf[0] = '\0'; - - /* TODO: support order (KM_SHIFT vs. KM_SHIFT2) ? */ - if (shift == KM_ANY && - ctrl == KM_ANY && - alt == KM_ANY && - oskey == KM_ANY) - { - /* Don't show anything for any mapping. */ - } - else { - if (shift) { - ADD_SEP; - p += BLI_strcpy_rlen(p, IFACE_("Shift")); - } - - if (ctrl) { - ADD_SEP; - p += BLI_strcpy_rlen(p, IFACE_("Ctrl")); - } - - if (alt) { - ADD_SEP; - p += BLI_strcpy_rlen(p, IFACE_("Alt")); - } - - if (oskey) { - ADD_SEP; - p += BLI_strcpy_rlen(p, IFACE_("Cmd")); - } - } - - if (keymodifier) { - ADD_SEP; - p += BLI_strcpy_rlen(p, WM_key_event_string(keymodifier, compact)); - } - - if (type) { - ADD_SEP; - if (val == KM_DBL_CLICK) { - p += BLI_strcpy_rlen(p, IFACE_("dbl-")); - } - p += BLI_strcpy_rlen(p, WM_key_event_string(type, compact)); - } - - /* We assume size of buf is enough to always store any possible shortcut, but let's add a debug check about it! */ - BLI_assert(p - buf < sizeof(buf)); - - /* We need utf8 here, otherwise we may 'cut' some unicode chars like arrows... */ - return BLI_strncpy_utf8_rlen(result, buf, result_len); +int 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, + char *result, + const int result_len) +{ +#define ADD_SEP \ + if (p != buf) \ + *p++ = ' '; \ + (void)0 + + char buf[128]; + char *p = buf; + + buf[0] = '\0'; + + /* TODO: support order (KM_SHIFT vs. KM_SHIFT2) ? */ + if (shift == KM_ANY && ctrl == KM_ANY && alt == KM_ANY && oskey == KM_ANY) { + /* Don't show anything for any mapping. */ + } + else { + if (shift) { + ADD_SEP; + p += BLI_strcpy_rlen(p, IFACE_("Shift")); + } + + if (ctrl) { + ADD_SEP; + p += BLI_strcpy_rlen(p, IFACE_("Ctrl")); + } + + if (alt) { + ADD_SEP; + p += BLI_strcpy_rlen(p, IFACE_("Alt")); + } + + if (oskey) { + ADD_SEP; + p += BLI_strcpy_rlen(p, IFACE_("Cmd")); + } + } + + if (keymodifier) { + ADD_SEP; + p += BLI_strcpy_rlen(p, WM_key_event_string(keymodifier, compact)); + } + + if (type) { + ADD_SEP; + if (val == KM_DBL_CLICK) { + p += BLI_strcpy_rlen(p, IFACE_("dbl-")); + } + p += BLI_strcpy_rlen(p, WM_key_event_string(type, compact)); + } + + /* We assume size of buf is enough to always store any possible shortcut, but let's add a debug check about it! */ + BLI_assert(p - buf < sizeof(buf)); + + /* We need utf8 here, otherwise we may 'cut' some unicode chars like arrows... */ + return BLI_strncpy_utf8_rlen(result, buf, result_len); #undef ADD_SEP } -int WM_keymap_item_to_string( - wmKeyMapItem *kmi, const bool compact, - char *result, const int result_len) +int WM_keymap_item_to_string(wmKeyMapItem *kmi, + const bool compact, + char *result, + const int result_len) { - return WM_keymap_item_raw_to_string( - kmi->shift, kmi->ctrl, kmi->alt, kmi->oskey, kmi->keymodifier, kmi->val, kmi->type, - compact, result, result_len); + return WM_keymap_item_raw_to_string(kmi->shift, + kmi->ctrl, + kmi->alt, + kmi->oskey, + kmi->keymodifier, + kmi->val, + kmi->type, + compact, + result, + result_len); } int WM_modalkeymap_items_to_string( - wmKeyMap *km, const int propvalue, const bool compact, - char *result, const int result_len) -{ - int totlen = 0; - bool add_sep = false; - - if (km) { - wmKeyMapItem *kmi; - - /* Find all shortcuts related to that propvalue! */ - for (kmi = WM_modalkeymap_find_propvalue(km, propvalue); - kmi && totlen < (result_len - 2); - kmi = wm_modalkeymap_find_propvalue_iter(km, kmi, propvalue)) - { - if (add_sep) { - result[totlen++] = '/'; - result[totlen] = '\0'; - } - else { - add_sep = true; - } - totlen += WM_keymap_item_to_string(kmi, compact, &result[totlen], result_len - totlen); - } - } - - return totlen; -} - -int WM_modalkeymap_operator_items_to_string( - wmOperatorType *ot, const int propvalue, const bool compact, - char *result, const int result_len) -{ - return WM_modalkeymap_items_to_string(ot->modalkeymap, propvalue, compact, result, result_len); -} - -char *WM_modalkeymap_operator_items_to_string_buf( - wmOperatorType *ot, const int propvalue, const bool compact, - const int max_len, int *r_available_len, char **r_result) -{ - char *ret = *r_result; - - if (*r_available_len > 1) { - int used_len = WM_modalkeymap_operator_items_to_string( - ot, propvalue, compact, ret, min_ii(*r_available_len, max_len)) + 1; - - *r_available_len -= used_len; - *r_result += used_len; - if (*r_available_len == 0) { - (*r_result)--; /* So that *result keeps pointing on a valid char, we'll stay on it anyway. */ - } - } - else { - *ret = '\0'; - } - - return ret; -} - -static wmKeyMapItem *wm_keymap_item_find_in_keymap( - wmKeyMap *keymap, const char *opname, - IDProperty *properties, const bool is_strict, - const struct wmKeyMapItemFind_Params *params) -{ - for (wmKeyMapItem *kmi = keymap->items.first; kmi; kmi = kmi->next) { - /* skip disabled keymap items [T38447] */ - if (kmi->flag & KMI_INACTIVE) { - continue; - } - - bool kmi_match = false; - - if (STREQ(kmi->idname, opname)) { - if (properties) { - /* example of debugging keymaps */ + wmKeyMap *km, const int propvalue, const bool compact, char *result, const int result_len) +{ + int totlen = 0; + bool add_sep = false; + + if (km) { + wmKeyMapItem *kmi; + + /* Find all shortcuts related to that propvalue! */ + for (kmi = WM_modalkeymap_find_propvalue(km, propvalue); kmi && totlen < (result_len - 2); + kmi = wm_modalkeymap_find_propvalue_iter(km, kmi, propvalue)) { + if (add_sep) { + result[totlen++] = '/'; + result[totlen] = '\0'; + } + else { + add_sep = true; + } + totlen += WM_keymap_item_to_string(kmi, compact, &result[totlen], result_len - totlen); + } + } + + return totlen; +} + +int WM_modalkeymap_operator_items_to_string(wmOperatorType *ot, + const int propvalue, + const bool compact, + char *result, + const int result_len) +{ + return WM_modalkeymap_items_to_string(ot->modalkeymap, propvalue, compact, result, result_len); +} + +char *WM_modalkeymap_operator_items_to_string_buf(wmOperatorType *ot, + const int propvalue, + const bool compact, + const int max_len, + int *r_available_len, + char **r_result) +{ + char *ret = *r_result; + + if (*r_available_len > 1) { + int used_len = WM_modalkeymap_operator_items_to_string( + ot, propvalue, compact, ret, min_ii(*r_available_len, max_len)) + + 1; + + *r_available_len -= used_len; + *r_result += used_len; + if (*r_available_len == 0) { + (*r_result)--; /* So that *result keeps pointing on a valid char, we'll stay on it anyway. */ + } + } + else { + *ret = '\0'; + } + + return ret; +} + +static wmKeyMapItem *wm_keymap_item_find_in_keymap(wmKeyMap *keymap, + const char *opname, + IDProperty *properties, + const bool is_strict, + const struct wmKeyMapItemFind_Params *params) +{ + for (wmKeyMapItem *kmi = keymap->items.first; kmi; kmi = kmi->next) { + /* skip disabled keymap items [T38447] */ + if (kmi->flag & KMI_INACTIVE) { + continue; + } + + bool kmi_match = false; + + if (STREQ(kmi->idname, opname)) { + 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); - } - } + 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, 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. */ - PointerRNA opptr; - IDProperty *properties_default = IDP_CopyProperty(kmi->ptr->data); - - RNA_pointer_create(NULL, ot->srna, properties_default, &opptr); - WM_operator_properties_default(&opptr, true); - - if (IDP_EqualsProperties_ex(properties, properties_default, is_strict)) { - char kmi_str[128]; - WM_keymap_item_to_string(kmi, false, kmi_str, sizeof(kmi_str)); - /* Note gievn 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); + if (kmi->ptr && IDP_EqualsProperties_ex(properties, 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. */ + PointerRNA opptr; + IDProperty *properties_default = IDP_CopyProperty(kmi->ptr->data); + + RNA_pointer_create(NULL, ot->srna, properties_default, &opptr); + WM_operator_properties_default(&opptr, true); + + if (IDP_EqualsProperties_ex(properties, properties_default, is_strict)) { + char kmi_str[128]; + WM_keymap_item_to_string(kmi, false, kmi_str, sizeof(kmi_str)); + /* Note gievn 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); #ifndef NDEBUG -#ifdef WITH_PYTHON - printf("OPERATOR\n"); - IDP_print(properties); - printf("KEYMAP\n"); - IDP_print(kmi->ptr->data); -#endif +# ifdef WITH_PYTHON + printf("OPERATOR\n"); + IDP_print(properties); + printf("KEYMAP\n"); + IDP_print(kmi->ptr->data); +# endif #endif - printf("\n"); - } - - IDP_FreeProperty(properties_default); - MEM_freeN(properties_default); - } - } - } - } - else { - kmi_match = true; - } - - if (kmi_match) { - if ((params == NULL) || params->filter_fn(keymap, kmi, params->user_data)) { - return kmi; - } - } - } - } - return NULL; -} - -static wmKeyMapItem *wm_keymap_item_find_handlers( - const bContext *C, ListBase *handlers, const char *opname, int UNUSED(opcontext), - IDProperty *properties, const bool is_strict, - const struct wmKeyMapItemFind_Params *params, - wmKeyMap **r_keymap) -{ - wmWindowManager *wm = CTX_wm_manager(C); - - /* 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; - wmKeyMap *keymap = WM_event_get_keymap_from_handler(wm, handler); - if (keymap && WM_keymap_poll((bContext *)C, keymap)) { - wmKeyMapItem *kmi = wm_keymap_item_find_in_keymap( - keymap, opname, properties, is_strict, params); - if (kmi != NULL) { - if (r_keymap) { - *r_keymap = keymap; - } - return kmi; - } - } - } - } - /* ensure un-initialized keymap is never used */ - if (r_keymap) { - *r_keymap = NULL; - } - return NULL; -} - -static wmKeyMapItem *wm_keymap_item_find_props( - const bContext *C, const char *opname, int opcontext, - IDProperty *properties, const bool is_strict, - const struct wmKeyMapItemFind_Params *params, - wmKeyMap **r_keymap) -{ - wmWindow *win = CTX_wm_window(C); - ScrArea *sa = CTX_wm_area(C); - ARegion *ar = CTX_wm_region(C); - wmKeyMapItem *found = NULL; - - /* look into multiple handler lists to find the item */ - if (win) { - found = wm_keymap_item_find_handlers( - C, &win->modalhandlers, opname, opcontext, properties, is_strict, params, r_keymap); - if (found == NULL) { - found = wm_keymap_item_find_handlers( - C, &win->handlers, opname, opcontext, properties, is_strict, params, r_keymap); - } - } - - if (sa && found == NULL) { - found = wm_keymap_item_find_handlers(C, &sa->handlers, opname, opcontext, properties, is_strict, params, r_keymap); - } - - if (found == NULL) { - if (ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) { - if (sa) { - if (!(ar && ar->regiontype == RGN_TYPE_WINDOW)) { - ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW); - } - - if (ar) { - found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap); - } - } - } - else if (ELEM(opcontext, WM_OP_EXEC_REGION_CHANNELS, WM_OP_INVOKE_REGION_CHANNELS)) { - if (!(ar && ar->regiontype == RGN_TYPE_CHANNELS)) { - ar = BKE_area_find_region_type(sa, RGN_TYPE_CHANNELS); - } - - if (ar) { - found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap); - } - } - else if (ELEM(opcontext, WM_OP_EXEC_REGION_PREVIEW, WM_OP_INVOKE_REGION_PREVIEW)) { - if (!(ar && ar->regiontype == RGN_TYPE_PREVIEW)) { - ar = BKE_area_find_region_type(sa, RGN_TYPE_PREVIEW); - } - - if (ar) { - found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap); - } - } - else { - if (ar) { - found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap); - } - } - } - - return found; -} - -static wmKeyMapItem *wm_keymap_item_find( - const bContext *C, const char *opname, int opcontext, - IDProperty *properties, bool is_strict, - const struct wmKeyMapItemFind_Params *params, - wmKeyMap **r_keymap) -{ - wmKeyMapItem *found; - - /* 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); - } - - 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 T41757)! - * ...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. */ - PointerRNA opptr; - IDProperty *properties_temp = IDP_CopyProperty(properties); - - RNA_pointer_create(NULL, ot->srna, properties_temp, &opptr); - - 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); - MEM_freeN(properties_temp); - } - } - - /* Debug only, helps spotting mismatches between menu entries and shortcuts! */ - if (G.debug & G_DEBUG_WM) { - if (!found && is_strict && properties) { - wmKeyMap *km; - wmKeyMapItem *kmi; - if (ot) { - /* make a copy of the properties and set unset ones to their default values. */ - PointerRNA opptr; - IDProperty *properties_default = IDP_CopyProperty(properties); - - RNA_pointer_create(NULL, ot->srna, properties_default, &opptr); - WM_operator_properties_default(&opptr, true); - - kmi = wm_keymap_item_find_props(C, opname, opcontext, properties_default, is_strict, params, &km); - if (kmi) { - char kmi_str[128]; - WM_keymap_item_to_string(kmi, false, kmi_str, sizeof(kmi_str)); - 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); + printf("\n"); + } + + IDP_FreeProperty(properties_default); + MEM_freeN(properties_default); + } + } + } + } + else { + kmi_match = true; + } + + if (kmi_match) { + if ((params == NULL) || params->filter_fn(keymap, kmi, params->user_data)) { + return kmi; + } + } + } + } + return NULL; +} + +static wmKeyMapItem *wm_keymap_item_find_handlers(const bContext *C, + ListBase *handlers, + const char *opname, + int UNUSED(opcontext), + IDProperty *properties, + const bool is_strict, + const struct wmKeyMapItemFind_Params *params, + wmKeyMap **r_keymap) +{ + wmWindowManager *wm = CTX_wm_manager(C); + + /* 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; + wmKeyMap *keymap = WM_event_get_keymap_from_handler(wm, handler); + if (keymap && WM_keymap_poll((bContext *)C, keymap)) { + wmKeyMapItem *kmi = wm_keymap_item_find_in_keymap( + keymap, opname, properties, is_strict, params); + if (kmi != NULL) { + if (r_keymap) { + *r_keymap = keymap; + } + return kmi; + } + } + } + } + /* ensure un-initialized keymap is never used */ + if (r_keymap) { + *r_keymap = NULL; + } + return NULL; +} + +static wmKeyMapItem *wm_keymap_item_find_props(const bContext *C, + const char *opname, + int opcontext, + IDProperty *properties, + const bool is_strict, + const struct wmKeyMapItemFind_Params *params, + wmKeyMap **r_keymap) +{ + wmWindow *win = CTX_wm_window(C); + ScrArea *sa = CTX_wm_area(C); + ARegion *ar = CTX_wm_region(C); + wmKeyMapItem *found = NULL; + + /* look into multiple handler lists to find the item */ + if (win) { + found = wm_keymap_item_find_handlers( + C, &win->modalhandlers, opname, opcontext, properties, is_strict, params, r_keymap); + if (found == NULL) { + found = wm_keymap_item_find_handlers( + C, &win->handlers, opname, opcontext, properties, is_strict, params, r_keymap); + } + } + + if (sa && found == NULL) { + found = wm_keymap_item_find_handlers( + C, &sa->handlers, opname, opcontext, properties, is_strict, params, r_keymap); + } + + if (found == NULL) { + if (ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) { + if (sa) { + if (!(ar && ar->regiontype == RGN_TYPE_WINDOW)) { + ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW); + } + + if (ar) { + found = wm_keymap_item_find_handlers( + C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap); + } + } + } + else if (ELEM(opcontext, WM_OP_EXEC_REGION_CHANNELS, WM_OP_INVOKE_REGION_CHANNELS)) { + if (!(ar && ar->regiontype == RGN_TYPE_CHANNELS)) { + ar = BKE_area_find_region_type(sa, RGN_TYPE_CHANNELS); + } + + if (ar) { + found = wm_keymap_item_find_handlers( + C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap); + } + } + else if (ELEM(opcontext, WM_OP_EXEC_REGION_PREVIEW, WM_OP_INVOKE_REGION_PREVIEW)) { + if (!(ar && ar->regiontype == RGN_TYPE_PREVIEW)) { + ar = BKE_area_find_region_type(sa, RGN_TYPE_PREVIEW); + } + + if (ar) { + found = wm_keymap_item_find_handlers( + C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap); + } + } + else { + if (ar) { + found = wm_keymap_item_find_handlers( + C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap); + } + } + } + + return found; +} + +static wmKeyMapItem *wm_keymap_item_find(const bContext *C, + const char *opname, + int opcontext, + IDProperty *properties, + bool is_strict, + const struct wmKeyMapItemFind_Params *params, + wmKeyMap **r_keymap) +{ + wmKeyMapItem *found; + + /* 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); + } + + 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 T41757)! + * ...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. */ + PointerRNA opptr; + IDProperty *properties_temp = IDP_CopyProperty(properties); + + RNA_pointer_create(NULL, ot->srna, properties_temp, &opptr); + + 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); + MEM_freeN(properties_temp); + } + } + + /* Debug only, helps spotting mismatches between menu entries and shortcuts! */ + if (G.debug & G_DEBUG_WM) { + if (!found && is_strict && properties) { + wmKeyMap *km; + wmKeyMapItem *kmi; + if (ot) { + /* make a copy of the properties and set unset ones to their default values. */ + PointerRNA opptr; + IDProperty *properties_default = IDP_CopyProperty(properties); + + RNA_pointer_create(NULL, ot->srna, properties_default, &opptr); + WM_operator_properties_default(&opptr, true); + + kmi = wm_keymap_item_find_props( + C, opname, opcontext, properties_default, is_strict, params, &km); + if (kmi) { + char kmi_str[128]; + WM_keymap_item_to_string(kmi, false, kmi_str, sizeof(kmi_str)); + 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); #ifndef NDEBUG -#ifdef WITH_PYTHON - printf("OPERATOR\n"); - IDP_print(properties); - printf("KEYMAP\n"); - IDP_print(kmi->ptr->data); -#endif +# ifdef WITH_PYTHON + printf("OPERATOR\n"); + IDP_print(properties); + printf("KEYMAP\n"); + IDP_print(kmi->ptr->data); +# endif #endif - printf("\n"); - } + printf("\n"); + } - IDP_FreeProperty(properties_default); - MEM_freeN(properties_default); - } - } - } + IDP_FreeProperty(properties_default); + MEM_freeN(properties_default); + } + } + } - return found; + return found; } -static bool kmi_filter_is_visible(const wmKeyMap *UNUSED(km), const wmKeyMapItem *kmi, void *UNUSED(user_data)) +static bool kmi_filter_is_visible(const wmKeyMap *UNUSED(km), + const wmKeyMapItem *kmi, + void *UNUSED(user_data)) { - return ((WM_key_event_string(kmi->type, false)[0] != '\0') && - (IS_EVENT_ACTIONZONE(kmi->type) == false)); + return ((WM_key_event_string(kmi->type, false)[0] != '\0') && + (IS_EVENT_ACTIONZONE(kmi->type) == false)); } -char *WM_key_event_operator_string( - const bContext *C, const char *opname, int opcontext, - IDProperty *properties, const bool is_strict, - char *result, const int result_len) +char *WM_key_event_operator_string(const bContext *C, + const char *opname, + int opcontext, + IDProperty *properties, + const bool is_strict, + char *result, + const int result_len) { - wmKeyMapItem *kmi = wm_keymap_item_find( - C, opname, opcontext, properties, is_strict, - &(struct wmKeyMapItemFind_Params){ - .filter_fn = kmi_filter_is_visible, - .user_data = NULL, - }, - NULL); - if (kmi) { - WM_keymap_item_to_string(kmi, false, result, result_len); - return result; - } + wmKeyMapItem *kmi = wm_keymap_item_find(C, + opname, + opcontext, + properties, + is_strict, + &(struct wmKeyMapItemFind_Params){ + .filter_fn = kmi_filter_is_visible, + .user_data = NULL, + }, + NULL); + if (kmi) { + WM_keymap_item_to_string(kmi, false, result, result_len); + return result; + } - return NULL; + return NULL; } -static bool kmi_filter_is_visible_type_mask(const wmKeyMap *km, const wmKeyMapItem *kmi, void *user_data) +static bool kmi_filter_is_visible_type_mask(const wmKeyMap *km, + const wmKeyMapItem *kmi, + void *user_data) { - short *mask_pair = user_data; - return ((WM_event_type_mask_test(kmi->type, mask_pair[0]) == true) && - (WM_event_type_mask_test(kmi->type, mask_pair[1]) == false) && - kmi_filter_is_visible(km, kmi, user_data)); + short *mask_pair = user_data; + return ((WM_event_type_mask_test(kmi->type, mask_pair[0]) == true) && + (WM_event_type_mask_test(kmi->type, mask_pair[1]) == false) && + kmi_filter_is_visible(km, kmi, user_data)); } /** * \param include_mask, exclude_mask: Event types to include/exclude when looking up keys (#eEventType_Mask). */ -wmKeyMapItem *WM_key_event_operator( - const bContext *C, const char *opname, int 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); - return wm_keymap_item_find( - C, opname, opcontext, properties, true, - &(struct wmKeyMapItemFind_Params){ - .filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible, - .user_data = use_mask ? user_data_mask : NULL, - }, - r_keymap); +wmKeyMapItem *WM_key_event_operator(const bContext *C, + const char *opname, + int 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); + return wm_keymap_item_find( + C, + opname, + opcontext, + properties, + true, + &(struct wmKeyMapItemFind_Params){ + .filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible, + .user_data = use_mask ? user_data_mask : NULL, + }, + 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); + return wm_keymap_item_find_in_keymap( + keymap, + opname, + properties, + true, + &(struct wmKeyMapItemFind_Params){ + .filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible, + .user_data = use_mask ? user_data_mask : NULL, + }); } -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); - return wm_keymap_item_find_in_keymap( - keymap, opname, properties, true, - &(struct wmKeyMapItemFind_Params){ - .filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible, - .user_data = use_mask ? user_data_mask : NULL, - }); -} - - bool WM_keymap_item_compare(wmKeyMapItem *k1, wmKeyMapItem *k2) { - int k1type, k2type; + int k1type, k2type; - if (k1->flag & KMI_INACTIVE || k2->flag & KMI_INACTIVE) { - return 0; - } + if (k1->flag & KMI_INACTIVE || k2->flag & KMI_INACTIVE) { + return 0; + } - /* take event mapping into account */ - k1type = WM_userdef_event_map(k1->type); - k2type = WM_userdef_event_map(k2->type); + /* take event mapping into account */ + k1type = WM_userdef_event_map(k1->type); + k2type = WM_userdef_event_map(k2->type); - if (k1type != KM_ANY && k2type != KM_ANY && k1type != k2type) { - return 0; - } + if (k1type != KM_ANY && k2type != KM_ANY && k1type != k2type) { + return 0; + } - 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 0; - } - if (k2->val == KM_CLICK && ELEM(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0) { - return 0; - } - if (k1->val != k2->val) { - return 0; - } - } + 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 0; + } + if (k2->val == KM_CLICK && ELEM(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0) { + return 0; + } + if (k1->val != k2->val) { + return 0; + } + } - if (k1->shift != KM_ANY && k2->shift != KM_ANY && k1->shift != k2->shift) { - return 0; - } + if (k1->shift != KM_ANY && k2->shift != KM_ANY && k1->shift != k2->shift) { + return 0; + } - if (k1->ctrl != KM_ANY && k2->ctrl != KM_ANY && k1->ctrl != k2->ctrl) { - return 0; - } + if (k1->ctrl != KM_ANY && k2->ctrl != KM_ANY && k1->ctrl != k2->ctrl) { + return 0; + } - if (k1->alt != KM_ANY && k2->alt != KM_ANY && k1->alt != k2->alt) { - return 0; - } + if (k1->alt != KM_ANY && k2->alt != KM_ANY && k1->alt != k2->alt) { + return 0; + } - if (k1->oskey != KM_ANY && k2->oskey != KM_ANY && k1->oskey != k2->oskey) { - return 0; - } + if (k1->oskey != KM_ANY && k2->oskey != KM_ANY && k1->oskey != k2->oskey) { + return 0; + } - if (k1->keymodifier != k2->keymodifier) { - return 0; - } + if (k1->keymodifier != k2->keymodifier) { + return 0; + } - return 1; + return 1; } /************************* Update Final Configuration ************************* @@ -1571,171 +1641,170 @@ bool WM_keymap_item_compare(wmKeyMapItem *k1, wmKeyMapItem *k2) /* so operator removal can trigger update */ enum { - WM_KEYMAP_UPDATE_RECONFIGURE = (1 << 0), + WM_KEYMAP_UPDATE_RECONFIGURE = (1 << 0), - /* ensure all wmKeyMap have their operator types validated after removing an operator */ - WM_KEYMAP_UPDATE_OPERATORTYPE = (1 << 1), + /* ensure all wmKeyMap have their operator types validated after removing an operator */ + WM_KEYMAP_UPDATE_OPERATORTYPE = (1 << 1), }; static char wm_keymap_update_flag = 0; void WM_keyconfig_update_tag(wmKeyMap *km, wmKeyMapItem *kmi) { - /* quick tag to do delayed keymap updates */ - wm_keymap_update_flag |= WM_KEYMAP_UPDATE_RECONFIGURE; + /* quick tag to do delayed keymap updates */ + wm_keymap_update_flag |= WM_KEYMAP_UPDATE_RECONFIGURE; - if (km) { - km->flag |= KEYMAP_UPDATE; - } - if (kmi) { - kmi->flag |= KMI_UPDATE; - } + if (km) { + km->flag |= KEYMAP_UPDATE; + } + if (kmi) { + kmi->flag |= KMI_UPDATE; + } } void WM_keyconfig_update_operatortype(void) { - wm_keymap_update_flag |= WM_KEYMAP_UPDATE_OPERATORTYPE; + wm_keymap_update_flag |= WM_KEYMAP_UPDATE_OPERATORTYPE; } static bool wm_keymap_test_and_clear_update(wmKeyMap *km) { - wmKeyMapItem *kmi; - int update; + wmKeyMapItem *kmi; + int update; - update = (km->flag & KEYMAP_UPDATE); - km->flag &= ~KEYMAP_UPDATE; + update = (km->flag & KEYMAP_UPDATE); + km->flag &= ~KEYMAP_UPDATE; - for (kmi = km->items.first; kmi; kmi = kmi->next) { - update = update || (kmi->flag & KMI_UPDATE); - kmi->flag &= ~KMI_UPDATE; - } + for (kmi = km->items.first; kmi; kmi = kmi->next) { + update = update || (kmi->flag & KMI_UPDATE); + kmi->flag &= ~KMI_UPDATE; + } - return (update != 0); + return (update != 0); } static wmKeyMap *wm_keymap_preset(wmWindowManager *wm, wmKeyMap *km) { - wmKeyConfig *keyconf = WM_keyconfig_active(wm); - wmKeyMap *keymap; + wmKeyConfig *keyconf = WM_keyconfig_active(wm); + wmKeyMap *keymap; - 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); - } + 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; + return keymap; } void WM_keyconfig_update(wmWindowManager *wm) { - wmKeyMap *km, *defaultmap, *addonmap, *usermap, *kmn; - wmKeyMapItem *kmi; - wmKeyMapDiffItem *kmdi; - bool compat_update = false; - - if (G.background) { - return; - } - - if (wm_keymap_update_flag == 0) { - return; - } - - if (wm_keymap_update_flag & WM_KEYMAP_UPDATE_OPERATORTYPE) { - /* an operatortype has been removed, this wont happen often - * but when it does we have to check _every_ keymap item */ - wmKeyConfig *kc; - - ListBase *keymaps_lb[] = { - &U.user_keymaps, - &wm->userconf->keymaps, - &wm->defaultconf->keymaps, - &wm->addonconf->keymaps, - NULL, - }; - - int i; - - for (i = 0; keymaps_lb[i]; i++) { - wm_keyconfig_properties_update_ot(keymaps_lb[i]); - } - - for (kc = wm->keyconfigs.first; kc; kc = kc->next) { - wm_keyconfig_properties_update_ot(&kc->keymaps); - } - - wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_OPERATORTYPE; - } - - - if (wm_keymap_update_flag == 0) { - return; - } - - /* update operator properties for non-modal user keymaps */ - for (km = U.user_keymaps.first; km; km = km->next) { - if ((km->flag & KEYMAP_MODAL) == 0) { - for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) { - if (kmdi->add_item) { - wm_keymap_item_properties_set(kmdi->add_item); - } - if (kmdi->remove_item) { - wm_keymap_item_properties_set(kmdi->remove_item); - } - } - - for (kmi = km->items.first; kmi; kmi = kmi->next) { - wm_keymap_item_properties_set(kmi); - } - } - } - - /* update U.user_keymaps with user key configuration changes */ - for (km = wm->userconf->keymaps.first; km; km = km->next) { - /* only diff if the user keymap was modified */ - if (wm_keymap_test_and_clear_update(km)) { - /* find keymaps */ - defaultmap = wm_keymap_preset(wm, km); - 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 */ - for (km = wm->defaultconf->keymaps.first; km; km = km->next) { - /* find keymaps */ - defaultmap = wm_keymap_preset(wm, km); - addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid); - usermap = WM_keymap_list_find(&U.user_keymaps, km->idname, km->spaceid, km->regionid); - - wm_user_modal_keymap_set_items(wm, defaultmap); - - /* add */ - 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)); - - } - - wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_RECONFIGURE; - - BLI_assert(wm_keymap_update_flag == 0); - - if (compat_update) { - WM_keyconfig_update_tag(NULL, NULL); - WM_keyconfig_update(wm); - } + wmKeyMap *km, *defaultmap, *addonmap, *usermap, *kmn; + wmKeyMapItem *kmi; + wmKeyMapDiffItem *kmdi; + bool compat_update = false; + + if (G.background) { + return; + } + + if (wm_keymap_update_flag == 0) { + return; + } + + if (wm_keymap_update_flag & WM_KEYMAP_UPDATE_OPERATORTYPE) { + /* an operatortype has been removed, this wont happen often + * but when it does we have to check _every_ keymap item */ + wmKeyConfig *kc; + + ListBase *keymaps_lb[] = { + &U.user_keymaps, + &wm->userconf->keymaps, + &wm->defaultconf->keymaps, + &wm->addonconf->keymaps, + NULL, + }; + + int i; + + for (i = 0; keymaps_lb[i]; i++) { + wm_keyconfig_properties_update_ot(keymaps_lb[i]); + } + + for (kc = wm->keyconfigs.first; kc; kc = kc->next) { + wm_keyconfig_properties_update_ot(&kc->keymaps); + } + + wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_OPERATORTYPE; + } + + if (wm_keymap_update_flag == 0) { + return; + } + + /* update operator properties for non-modal user keymaps */ + for (km = U.user_keymaps.first; km; km = km->next) { + if ((km->flag & KEYMAP_MODAL) == 0) { + for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) { + if (kmdi->add_item) { + wm_keymap_item_properties_set(kmdi->add_item); + } + if (kmdi->remove_item) { + wm_keymap_item_properties_set(kmdi->remove_item); + } + } + + for (kmi = km->items.first; kmi; kmi = kmi->next) { + wm_keymap_item_properties_set(kmi); + } + } + } + + /* update U.user_keymaps with user key configuration changes */ + for (km = wm->userconf->keymaps.first; km; km = km->next) { + /* only diff if the user keymap was modified */ + if (wm_keymap_test_and_clear_update(km)) { + /* find keymaps */ + defaultmap = wm_keymap_preset(wm, km); + 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 */ + for (km = wm->defaultconf->keymaps.first; km; km = km->next) { + /* find keymaps */ + defaultmap = wm_keymap_preset(wm, km); + addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid); + usermap = WM_keymap_list_find(&U.user_keymaps, km->idname, km->spaceid, km->regionid); + + wm_user_modal_keymap_set_items(wm, defaultmap); + + /* add */ + 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)); + } + + wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_RECONFIGURE; + + BLI_assert(wm_keymap_update_flag == 0); + + if (compat_update) { + WM_keyconfig_update_tag(NULL, NULL); + WM_keyconfig_update(wm); + } } /********************************* Event Handling ***************************** @@ -1745,20 +1814,21 @@ void WM_keyconfig_update(wmWindowManager *wm) wmKeyMap *WM_keymap_active(wmWindowManager *wm, wmKeyMap *keymap) { - wmKeyMap *km; + wmKeyMap *km; - if (!keymap) { - return NULL; - } + if (!keymap) { + return NULL; + } - /* first user defined keymaps */ - km = WM_keymap_list_find(&wm->userconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid); + /* first user defined keymaps */ + km = WM_keymap_list_find( + &wm->userconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid); - if (km) { - return km; - } + if (km) { + return km; + } - return keymap; + return keymap; } /******************************* Keymap Editor ******************************** @@ -1766,95 +1836,97 @@ wmKeyMap *WM_keymap_active(wmWindowManager *wm, wmKeyMap *keymap) void WM_keymap_restore_item_to_default(bContext *C, wmKeyMap *keymap, wmKeyMapItem *kmi) { - wmWindowManager *wm = CTX_wm_manager(C); - wmKeyMap *defaultmap, *addonmap; - wmKeyMapItem *orig; - - if (!keymap) { - return; - } - - /* construct default keymap from preset + addons */ - defaultmap = wm_keymap_preset(wm, keymap); - 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 */ - orig = WM_keymap_item_find_id(defaultmap, kmi->id); - - if (orig) { - /* restore to original */ - if (!STREQ(orig->idname, kmi->idname)) { - BLI_strncpy(kmi->idname, orig->idname, sizeof(kmi->idname)); - WM_keymap_properties_reset(kmi, NULL); - } - - if (orig->properties) { - if (kmi->properties) { - IDP_FreeProperty(kmi->properties); - MEM_freeN(kmi->properties); - kmi->properties = NULL; - } - - kmi->properties = IDP_CopyProperty(orig->properties); - 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; - - WM_keyconfig_update_tag(keymap, kmi); - } - - /* free temporary keymap */ - if (addonmap) { - WM_keymap_clear(defaultmap); - MEM_freeN(defaultmap); - } + wmWindowManager *wm = CTX_wm_manager(C); + wmKeyMap *defaultmap, *addonmap; + wmKeyMapItem *orig; + + if (!keymap) { + return; + } + + /* construct default keymap from preset + addons */ + defaultmap = wm_keymap_preset(wm, keymap); + 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 */ + orig = WM_keymap_item_find_id(defaultmap, kmi->id); + + if (orig) { + /* restore to original */ + if (!STREQ(orig->idname, kmi->idname)) { + BLI_strncpy(kmi->idname, orig->idname, sizeof(kmi->idname)); + WM_keymap_properties_reset(kmi, NULL); + } + + if (orig->properties) { + if (kmi->properties) { + IDP_FreeProperty(kmi->properties); + MEM_freeN(kmi->properties); + kmi->properties = NULL; + } + + kmi->properties = IDP_CopyProperty(orig->properties); + 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; + + 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, bContext *C) { - wmWindowManager *wm = CTX_wm_manager(C); - wmKeyMap *usermap; + wmWindowManager *wm = CTX_wm_manager(C); + wmKeyMap *usermap; - /* remove keymap from U.user_keymaps and update */ - usermap = WM_keymap_list_find(&U.user_keymaps, keymap->idname, keymap->spaceid, keymap->regionid); + /* remove keymap from U.user_keymaps and update */ + 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); + if (usermap) { + WM_keymap_clear(usermap); + BLI_freelinkN(&U.user_keymaps, usermap); - WM_keyconfig_update_tag(NULL, NULL); - WM_keyconfig_update(wm); - } + WM_keyconfig_update_tag(NULL, NULL); + WM_keyconfig_update(wm); + } } wmKeyMapItem *WM_keymap_item_find_id(wmKeyMap *keymap, int id) { - wmKeyMapItem *kmi; + wmKeyMapItem *kmi; - for (kmi = keymap->items.first; kmi; kmi = kmi->next) { - if (kmi->id == id) { - return kmi; - } - } + for (kmi = keymap->items.first; kmi; kmi = kmi->next) { + if (kmi->id == id) { + return kmi; + } + } - return NULL; + return NULL; } const char *WM_bool_as_string(bool test) { - return test ? IFACE_("ON") : IFACE_("OFF"); + return test ? IFACE_("ON") : IFACE_("OFF"); } |