2 * ***** BEGIN GPL LICENSE BLOCK *****
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * The Original Code is Copyright (C) 2007 Blender Foundation.
19 * All rights reserved.
22 * Contributor(s): Blender Foundation
24 * ***** END GPL LICENSE BLOCK *****
27 /** \file blender/windowmanager/intern/wm_keymap.c
34 #include "DNA_object_types.h"
35 #include "DNA_screen_types.h"
36 #include "DNA_space_types.h"
37 #include "DNA_userdef_types.h"
38 #include "DNA_windowmanager_types.h"
40 #include "MEM_guardedalloc.h"
42 #include "BLI_blenlib.h"
43 #include "BLI_utildefines.h"
45 #include "BKE_blender.h"
46 #include "BKE_context.h"
47 #include "BKE_idprop.h"
48 #include "BKE_global.h"
49 #include "BKE_library.h"
51 #include "BKE_screen.h"
54 #include "RNA_access.h"
55 #include "RNA_enum_types.h"
59 #include "wm_window.h"
60 #include "wm_event_system.h"
61 #include "wm_event_types.h"
63 /******************************* Keymap Item **********************************
64 * Item in a keymap, that maps from an event to an operator or modal map item */
66 static wmKeyMapItem *wm_keymap_item_copy(wmKeyMapItem *kmi)
68 wmKeyMapItem *kmin = MEM_dupallocN(kmi);
70 kmin->prev = kmin->next = NULL;
71 kmin->flag &= ~KMI_UPDATE;
73 if (kmin->properties) {
74 kmin->ptr = MEM_callocN(sizeof(PointerRNA), "UserKeyMapItemPtr");
75 WM_operator_properties_create(kmin->ptr, kmin->idname);
77 kmin->properties = IDP_CopyProperty(kmin->properties);
78 kmin->ptr->data = kmin->properties;
84 static void wm_keymap_item_free(wmKeyMapItem *kmi)
88 WM_operator_properties_free(kmi->ptr);
93 static void wm_keymap_item_properties_set(wmKeyMapItem *kmi)
95 WM_operator_properties_alloc(&(kmi->ptr), &(kmi->properties), kmi->idname);
96 WM_operator_properties_sanitize(kmi->ptr, 1);
99 static int wm_keymap_item_equals_result(wmKeyMapItem *a, wmKeyMapItem *b)
101 if (strcmp(a->idname, b->idname) != 0)
104 if (!((a->ptr == NULL && b->ptr == NULL) ||
105 (a->ptr && b->ptr && IDP_EqualsProperties(a->ptr->data, b->ptr->data))))
110 if ((a->flag & KMI_INACTIVE) != (b->flag & KMI_INACTIVE))
113 return (a->propvalue == b->propvalue);
116 static int wm_keymap_item_equals(wmKeyMapItem *a, wmKeyMapItem *b)
118 return (wm_keymap_item_equals_result(a, b) &&
119 a->type == b->type &&
121 a->shift == b->shift &&
122 a->ctrl == b->ctrl &&
124 a->oskey == b->oskey &&
125 a->keymodifier == b->keymodifier &&
126 a->maptype == b->maptype);
129 /* properties can be NULL, otherwise the arg passed is used and ownership is given to the kmi */
130 void WM_keymap_properties_reset(wmKeyMapItem *kmi, struct IDProperty *properties)
132 WM_operator_properties_free(kmi->ptr);
136 kmi->properties = properties;
138 wm_keymap_item_properties_set(kmi);
141 /**************************** Keymap Diff Item *********************************
142 * Item in a diff keymap, used for saving diff of keymaps in user preferences */
144 static wmKeyMapDiffItem *wm_keymap_diff_item_copy(wmKeyMapDiffItem *kmdi)
146 wmKeyMapDiffItem *kmdin = MEM_dupallocN(kmdi);
148 kmdin->next = kmdin->prev = NULL;
150 kmdin->add_item = wm_keymap_item_copy(kmdi->add_item);
151 if (kmdi->remove_item)
152 kmdin->remove_item = wm_keymap_item_copy(kmdi->remove_item);
157 static void wm_keymap_diff_item_free(wmKeyMapDiffItem *kmdi)
159 if (kmdi->remove_item) {
160 wm_keymap_item_free(kmdi->remove_item);
161 MEM_freeN(kmdi->remove_item);
163 if (kmdi->add_item) {
164 wm_keymap_item_free(kmdi->add_item);
165 MEM_freeN(kmdi->add_item);
169 /***************************** Key Configuration ******************************
170 * List of keymaps for all editors, modes, ... . There is a builtin default key
171 * configuration, a user key configuration, and other preset configurations. */
173 wmKeyConfig *WM_keyconfig_new(wmWindowManager *wm, const char *idname)
175 wmKeyConfig *keyconf;
177 keyconf = MEM_callocN(sizeof(wmKeyConfig), "wmKeyConfig");
178 BLI_strncpy(keyconf->idname, idname, sizeof(keyconf->idname));
179 BLI_addtail(&wm->keyconfigs, keyconf);
184 wmKeyConfig *WM_keyconfig_new_user(wmWindowManager *wm, const char *idname)
186 wmKeyConfig *keyconf = WM_keyconfig_new(wm, idname);
188 keyconf->flag |= KEYCONF_USER;
193 void WM_keyconfig_remove(wmWindowManager *wm, wmKeyConfig *keyconf)
196 if (strncmp(U.keyconfigstr, keyconf->idname, sizeof(U.keyconfigstr)) == 0) {
197 BLI_strncpy(U.keyconfigstr, wm->defaultconf->idname, sizeof(U.keyconfigstr));
198 WM_keyconfig_update_tag(NULL, NULL);
201 BLI_remlink(&wm->keyconfigs, keyconf);
202 WM_keyconfig_free(keyconf);
206 void WM_keyconfig_free(wmKeyConfig *keyconf)
210 while ((km = keyconf->keymaps.first)) {
212 BLI_freelinkN(&keyconf->keymaps, km);
218 static wmKeyConfig *wm_keyconfig_list_find(ListBase *lb, char *idname)
222 for (kc = lb->first; kc; kc = kc->next)
223 if (0 == strncmp(idname, kc->idname, KMAP_MAX_NAME))
229 static wmKeyConfig *WM_keyconfig_active(wmWindowManager *wm)
231 wmKeyConfig *keyconf;
233 /* first try from preset */
234 keyconf = wm_keyconfig_list_find(&wm->keyconfigs, U.keyconfigstr);
238 /* otherwise use default */
239 return wm->defaultconf;
242 void WM_keyconfig_set_active(wmWindowManager *wm, const char *idname)
244 /* setting a different key configuration as active: we ensure all is
245 * updated properly before and after making the change */
247 WM_keyconfig_update(wm);
249 BLI_strncpy(U.keyconfigstr, idname, sizeof(U.keyconfigstr));
251 WM_keyconfig_update_tag(NULL, NULL);
252 WM_keyconfig_update(wm);
255 /********************************** Keymap *************************************
256 * List of keymap items for one editor, mode, modal operator, ... */
258 static wmKeyMap *wm_keymap_new(const char *idname, int spaceid, int regionid)
260 wmKeyMap *km = MEM_callocN(sizeof(struct wmKeyMap), "keymap list");
262 BLI_strncpy(km->idname, idname, KMAP_MAX_NAME);
263 km->spaceid = spaceid;
264 km->regionid = regionid;
269 static wmKeyMap *wm_keymap_copy(wmKeyMap *keymap)
271 wmKeyMap *keymapn = MEM_dupallocN(keymap);
272 wmKeyMapItem *kmi, *kmin;
273 wmKeyMapDiffItem *kmdi, *kmdin;
275 keymapn->modal_items = keymap->modal_items;
276 keymapn->poll = keymap->poll;
277 keymapn->items.first = keymapn->items.last = NULL;
278 keymapn->flag &= ~(KEYMAP_UPDATE | KEYMAP_EXPANDED);
280 for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) {
281 kmdin = wm_keymap_diff_item_copy(kmdi);
282 BLI_addtail(&keymapn->items, kmdin);
285 for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
286 kmin = wm_keymap_item_copy(kmi);
287 BLI_addtail(&keymapn->items, kmin);
293 void WM_keymap_free(wmKeyMap *keymap)
296 wmKeyMapDiffItem *kmdi;
298 for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next)
299 wm_keymap_diff_item_free(kmdi);
301 for (kmi = keymap->items.first; kmi; kmi = kmi->next)
302 wm_keymap_item_free(kmi);
304 BLI_freelistN(&keymap->diff_items);
305 BLI_freelistN(&keymap->items);
308 static void keymap_event_set(wmKeyMapItem *kmi, short type, short val, int modifier, short keymodifier)
312 kmi->keymodifier = keymodifier;
314 if (modifier == KM_ANY) {
315 kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY;
318 kmi->shift = (modifier & KM_SHIFT) ? KM_MOD_FIRST : ((modifier & KM_SHIFT2) ? KM_MOD_SECOND : FALSE);
319 kmi->ctrl = (modifier & KM_CTRL) ? KM_MOD_FIRST : ((modifier & KM_CTRL2) ? KM_MOD_SECOND : FALSE);
320 kmi->alt = (modifier & KM_ALT) ? KM_MOD_FIRST : ((modifier & KM_ALT2) ? KM_MOD_SECOND : FALSE);
321 kmi->oskey = (modifier & KM_OSKEY) ? KM_MOD_FIRST : ((modifier & KM_OSKEY2) ? KM_MOD_SECOND : FALSE);
325 static void keymap_item_set_id(wmKeyMap *keymap, wmKeyMapItem *kmi)
328 if ((keymap->flag & KEYMAP_USER) == 0) {
329 kmi->id = keymap->kmi_id;
332 kmi->id = -keymap->kmi_id; // User defined keymap entries have negative ids
336 /* if item was added, then bail out */
337 wmKeyMapItem *WM_keymap_verify_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
341 for (kmi = keymap->items.first; kmi; kmi = kmi->next)
342 if (strncmp(kmi->idname, idname, OP_MAX_TYPENAME) == 0)
345 kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
347 BLI_addtail(&keymap->items, kmi);
348 BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
350 keymap_item_set_id(keymap, kmi);
352 keymap_event_set(kmi, type, val, modifier, keymodifier);
353 wm_keymap_item_properties_set(kmi);
358 /* always add item */
359 wmKeyMapItem *WM_keymap_add_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
361 wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
363 BLI_addtail(&keymap->items, kmi);
364 BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
366 keymap_event_set(kmi, type, val, modifier, keymodifier);
367 wm_keymap_item_properties_set(kmi);
369 keymap_item_set_id(keymap, kmi);
371 WM_keyconfig_update_tag(keymap, kmi);
376 /* menu wrapper for WM_keymap_add_item */
377 wmKeyMapItem *WM_keymap_add_menu(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
379 wmKeyMapItem *kmi = WM_keymap_add_item(keymap, "WM_OT_call_menu", type, val, modifier, keymodifier);
380 RNA_string_set(kmi->ptr, "name", idname);
384 void WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi)
386 if (BLI_findindex(&keymap->items, kmi) != -1) {
388 WM_operator_properties_free(kmi->ptr);
391 BLI_freelinkN(&keymap->items, kmi);
393 WM_keyconfig_update_tag(keymap, kmi);
397 /************************** Keymap Diff and Patch ****************************
398 * Rather than saving the entire keymap for user preferences, we only save a
399 * diff so that changes in the defaults get synced. This system is not perfect
400 * but works better than overriding the keymap entirely when only few items
403 static void wm_keymap_addon_add(wmKeyMap *keymap, wmKeyMap *addonmap)
405 wmKeyMapItem *kmi, *kmin;
407 for (kmi = addonmap->items.first; kmi; kmi = kmi->next) {
408 kmin = wm_keymap_item_copy(kmi);
409 keymap_item_set_id(keymap, kmin);
410 BLI_addhead(&keymap->items, kmin);
414 static wmKeyMapItem *wm_keymap_find_item_equals(wmKeyMap *km, wmKeyMapItem *needle)
418 for (kmi = km->items.first; kmi; kmi = kmi->next)
419 if (wm_keymap_item_equals(kmi, needle))
425 static wmKeyMapItem *wm_keymap_find_item_equals_result(wmKeyMap *km, wmKeyMapItem *needle)
429 for (kmi = km->items.first; kmi; kmi = kmi->next)
430 if (wm_keymap_item_equals_result(kmi, needle))
436 static void wm_keymap_diff(wmKeyMap *diff_km, wmKeyMap *from_km, wmKeyMap *to_km, wmKeyMap *orig_km, wmKeyMap *addon_km)
438 wmKeyMapItem *kmi, *to_kmi, *orig_kmi;
439 wmKeyMapDiffItem *kmdi;
441 for (kmi = from_km->items.first; kmi; kmi = kmi->next) {
442 to_kmi = WM_keymap_item_find_id(to_km, kmi->id);
446 kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
447 kmdi->remove_item = wm_keymap_item_copy(kmi);
448 BLI_addtail(&diff_km->diff_items, kmdi);
450 else if (to_kmi && !wm_keymap_item_equals(kmi, to_kmi)) {
452 kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
453 kmdi->remove_item = wm_keymap_item_copy(kmi);
454 kmdi->add_item = wm_keymap_item_copy(to_kmi);
455 BLI_addtail(&diff_km->diff_items, kmdi);
458 /* sync expanded flag back to original so we don't loose it on repatch */
460 orig_kmi = WM_keymap_item_find_id(orig_km, kmi->id);
463 orig_kmi = wm_keymap_find_item_equals(addon_km, kmi);
466 orig_kmi->flag &= ~KMI_EXPANDED;
467 orig_kmi->flag |= (to_kmi->flag & KMI_EXPANDED);
472 for (kmi = to_km->items.first; kmi; kmi = kmi->next) {
475 kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
476 kmdi->add_item = wm_keymap_item_copy(kmi);
477 BLI_addtail(&diff_km->diff_items, kmdi);
482 static void wm_keymap_patch(wmKeyMap *km, wmKeyMap *diff_km)
484 wmKeyMapDiffItem *kmdi;
485 wmKeyMapItem *kmi_remove, *kmi_add;
487 for (kmdi = diff_km->diff_items.first; kmdi; kmdi = kmdi->next) {
488 /* find item to remove */
490 if (kmdi->remove_item) {
491 kmi_remove = wm_keymap_find_item_equals(km, kmdi->remove_item);
493 kmi_remove = wm_keymap_find_item_equals_result(km, kmdi->remove_item);
497 if (kmdi->add_item) {
498 /* only if nothing to remove or item to remove found */
499 if (!kmdi->remove_item || kmi_remove) {
500 kmi_add = wm_keymap_item_copy(kmdi->add_item);
501 kmi_add->flag |= KMI_USER_MODIFIED;
504 kmi_add->flag &= ~KMI_EXPANDED;
505 kmi_add->flag |= (kmi_remove->flag & KMI_EXPANDED);
506 kmi_add->id = kmi_remove->id;
507 BLI_insertlinkbefore(&km->items, kmi_remove, kmi_add);
510 keymap_item_set_id(km, kmi_add);
511 BLI_addtail(&km->items, kmi_add);
518 wm_keymap_item_free(kmi_remove);
519 BLI_freelinkN(&km->items, kmi_remove);
524 static wmKeyMap *wm_keymap_patch_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *usermap)
529 /* remove previous keymap in list, we will replace it */
530 km = WM_keymap_list_find(lb, defaultmap->idname, defaultmap->spaceid, defaultmap->regionid);
532 expanded = (km->flag & (KEYMAP_EXPANDED | KEYMAP_CHILDREN_EXPANDED));
534 BLI_freelinkN(lb, km);
537 /* copy new keymap from an existing one */
538 if (usermap && !(usermap->flag & KEYMAP_DIFF)) {
539 /* for compatibiltiy with old user preferences with non-diff
540 * keymaps we override the original entirely */
541 wmKeyMapItem *kmi, *orig_kmi;
543 km = wm_keymap_copy(usermap);
545 /* try to find corresponding id's for items */
546 for (kmi = km->items.first; kmi; kmi = kmi->next) {
547 orig_kmi = wm_keymap_find_item_equals(defaultmap, kmi);
549 orig_kmi = wm_keymap_find_item_equals_result(defaultmap, kmi);
552 kmi->id = orig_kmi->id;
554 kmi->id = -(km->kmi_id++);
557 km->flag |= KEYMAP_UPDATE; /* update again to create diff */
560 km = wm_keymap_copy(defaultmap);
562 /* add addon keymap items */
564 wm_keymap_addon_add(km, addonmap);
566 /* tag as being user edited */
568 km->flag |= KEYMAP_USER_MODIFIED;
569 km->flag |= KEYMAP_USER | expanded;
571 /* apply user changes of diff keymap */
572 if (usermap && (usermap->flag & KEYMAP_DIFF))
573 wm_keymap_patch(km, usermap);
581 static void wm_keymap_diff_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *km)
583 wmKeyMap *diffmap, *prevmap, *origmap;
585 /* create temporary default + addon keymap for diff */
586 origmap = defaultmap;
589 defaultmap = wm_keymap_copy(defaultmap);
590 wm_keymap_addon_add(defaultmap, addonmap);
593 /* remove previous diff keymap in list, we will replace it */
594 prevmap = WM_keymap_list_find(lb, km->idname, km->spaceid, km->regionid);
596 WM_keymap_free(prevmap);
597 BLI_freelinkN(lb, prevmap);
600 /* create diff keymap */
601 diffmap = wm_keymap_new(km->idname, km->spaceid, km->regionid);
602 diffmap->flag |= KEYMAP_DIFF;
603 if (defaultmap->flag & KEYMAP_MODAL)
604 diffmap->flag |= KEYMAP_MODAL;
605 wm_keymap_diff(diffmap, defaultmap, km, origmap, addonmap);
607 /* add to list if not empty */
608 if (diffmap->diff_items.first) {
609 BLI_addtail(lb, diffmap);
612 WM_keymap_free(diffmap);
616 /* free temporary default map */
618 WM_keymap_free(defaultmap);
619 MEM_freeN(defaultmap);
623 /* ****************** storage in WM ************ */
625 /* name id's are for storing general or multiple keymaps,
626 * space/region ids are same as DNA_space_types.h */
627 /* gets freed in wm.c */
629 wmKeyMap *WM_keymap_list_find(ListBase *lb, const char *idname, int spaceid, int regionid)
633 for (km = lb->first; km; km = km->next)
634 if (km->spaceid == spaceid && km->regionid == regionid)
635 if (0 == strncmp(idname, km->idname, KMAP_MAX_NAME))
641 wmKeyMap *WM_keymap_find(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
643 wmKeyMap *km = WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
646 km = wm_keymap_new(idname, spaceid, regionid);
647 BLI_addtail(&keyconf->keymaps, km);
649 WM_keyconfig_update_tag(km, NULL);
655 wmKeyMap *WM_keymap_find_all(const bContext *C, const char *idname, int spaceid, int regionid)
657 wmWindowManager *wm = CTX_wm_manager(C);
659 return WM_keymap_list_find(&wm->userconf->keymaps, idname, spaceid, regionid);
662 /* ****************** modal keymaps ************ */
664 /* modal maps get linked to a running operator, and filter the keys before sending to modal() callback */
666 wmKeyMap *WM_modalkeymap_add(wmKeyConfig *keyconf, const char *idname, EnumPropertyItem *items)
668 wmKeyMap *km = WM_keymap_find(keyconf, idname, 0, 0);
669 km->flag |= KEYMAP_MODAL;
670 km->modal_items = items;
673 /* init modal items from default config */
674 wmWindowManager *wm = G.main->wm.first;
675 wmKeyMap *defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
678 km->modal_items = defaultkm->modal_items;
679 km->poll = defaultkm->poll;
686 wmKeyMap *WM_modalkeymap_get(wmKeyConfig *keyconf, const char *idname)
690 for (km = keyconf->keymaps.first; km; km = km->next)
691 if (km->flag & KEYMAP_MODAL)
692 if (0 == strncmp(idname, km->idname, KMAP_MAX_NAME))
699 wmKeyMapItem *WM_modalkeymap_add_item(wmKeyMap *km, int type, int val, int modifier, int keymodifier, int value)
701 wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
703 BLI_addtail(&km->items, kmi);
704 kmi->propvalue = value;
706 keymap_event_set(kmi, type, val, modifier, keymodifier);
708 keymap_item_set_id(km, kmi);
710 WM_keyconfig_update_tag(km, kmi);
715 wmKeyMapItem *WM_modalkeymap_add_item_str(wmKeyMap *km, int type, int val, int modifier, int keymodifier, const char *value)
717 wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
719 BLI_addtail(&km->items, kmi);
720 BLI_strncpy(kmi->propvalue_str, value, sizeof(kmi->propvalue_str));
722 keymap_event_set(kmi, type, val, modifier, keymodifier);
724 keymap_item_set_id(km, kmi);
726 WM_keyconfig_update_tag(km, kmi);
731 void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
733 wmOperatorType *ot = WM_operatortype_find(opname, 0);
736 ot->modalkeymap = km;
738 printf("error: modalkeymap_assign, unknown operator %s\n", opname);
741 static void wm_user_modal_keymap_set_items(wmWindowManager *wm, wmKeyMap *km)
743 /* here we convert propvalue string values delayed, due to python keymaps
744 * being created before the actual modal keymaps, so no modal_items */
749 if (km && (km->flag & KEYMAP_MODAL) && !km->modal_items) {
750 defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
755 km->modal_items = defaultkm->modal_items;
756 km->poll = defaultkm->poll;
758 for (kmi = km->items.first; kmi; kmi = kmi->next) {
759 if (kmi->propvalue_str[0]) {
760 if (RNA_enum_value_from_id(km->modal_items, kmi->propvalue_str, &propvalue))
761 kmi->propvalue = propvalue;
762 kmi->propvalue_str[0] = '\0';
768 /* ***************** get string from key events **************** */
770 const char *WM_key_event_string(short type)
772 const char *name = NULL;
773 if (RNA_enum_name(event_type_items, (int)type, &name))
779 char *WM_keymap_item_to_string(wmKeyMapItem *kmi, char *str, int len)
785 if (kmi->shift == KM_ANY &&
786 kmi->ctrl == KM_ANY &&
787 kmi->alt == KM_ANY &&
788 kmi->oskey == KM_ANY) {
794 strcat(buf, "Shift ");
797 strcat(buf, "Ctrl ");
806 if (kmi->keymodifier) {
807 strcat(buf, WM_key_event_string(kmi->keymodifier));
811 strcat(buf, WM_key_event_string(kmi->type));
812 BLI_strncpy(str, buf, len);
817 static wmKeyMapItem *wm_keymap_item_find_handlers(
818 const bContext *C, ListBase *handlers, const char *opname, int UNUSED(opcontext),
819 IDProperty *properties, int compare_props, int hotkey, wmKeyMap **keymap_r)
821 wmWindowManager *wm = CTX_wm_manager(C);
822 wmEventHandler *handler;
826 /* find keymap item in handlers */
827 for (handler = handlers->first; handler; handler = handler->next) {
828 keymap = WM_keymap_active(wm, handler->keymap);
830 if (keymap && (!keymap->poll || keymap->poll((bContext *)C))) {
831 for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
833 if (strcmp(kmi->idname, opname) == 0 && WM_key_event_string(kmi->type)[0]) {
835 if (!ISHOTKEY(kmi->type))
839 if (kmi->ptr && IDP_EqualsProperties(properties, kmi->ptr->data)) {
840 if (keymap_r) *keymap_r = keymap;
845 if (keymap_r) *keymap_r = keymap;
853 /* ensure un-initialized keymap is never used */
854 if (keymap_r) *keymap_r = NULL;
858 static wmKeyMapItem *wm_keymap_item_find_props(
859 const bContext *C, const char *opname, int opcontext,
860 IDProperty *properties, int compare_props, int hotkey, wmKeyMap **keymap_r)
862 wmWindow *win = CTX_wm_window(C);
863 ScrArea *sa = CTX_wm_area(C);
864 ARegion *ar = CTX_wm_region(C);
865 wmKeyMapItem *found = NULL;
867 /* look into multiple handler lists to find the item */
869 found = wm_keymap_item_find_handlers(C, &win->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
872 if (sa && found == NULL)
873 found = wm_keymap_item_find_handlers(C, &sa->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
876 if (ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) {
878 if (!(ar && ar->regiontype == RGN_TYPE_WINDOW))
879 ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
882 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
885 else if (ELEM(opcontext, WM_OP_EXEC_REGION_CHANNELS, WM_OP_INVOKE_REGION_CHANNELS)) {
886 if (!(ar && ar->regiontype == RGN_TYPE_CHANNELS))
887 ar = BKE_area_find_region_type(sa, RGN_TYPE_CHANNELS);
890 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
892 else if (ELEM(opcontext, WM_OP_EXEC_REGION_PREVIEW, WM_OP_INVOKE_REGION_PREVIEW)) {
893 if (!(ar && ar->regiontype == RGN_TYPE_PREVIEW))
894 ar = BKE_area_find_region_type(sa, RGN_TYPE_PREVIEW);
897 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
901 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
908 static wmKeyMapItem *wm_keymap_item_find(
909 const bContext *C, const char *opname, int opcontext,
910 IDProperty *properties, const short hotkey, const short sloppy, wmKeyMap **keymap_r)
912 wmKeyMapItem *found = wm_keymap_item_find_props(C, opname, opcontext, properties, 1, hotkey, keymap_r);
914 if (!found && sloppy)
915 found = wm_keymap_item_find_props(C, opname, opcontext, NULL, 0, hotkey, keymap_r);
920 char *WM_key_event_operator_string(
921 const bContext *C, const char *opname, int opcontext,
922 IDProperty *properties, const short sloppy, char *str, int len)
924 wmKeyMapItem *kmi = wm_keymap_item_find(C, opname, opcontext, properties, 0, sloppy, NULL);
927 WM_keymap_item_to_string(kmi, str, len);
934 int WM_key_event_operator_id(
935 const bContext *C, const char *opname, int opcontext,
936 IDProperty *properties, int hotkey, wmKeyMap **keymap_r)
938 wmKeyMapItem *kmi = wm_keymap_item_find(C, opname, opcontext, properties, hotkey, TRUE, keymap_r);
946 int WM_keymap_item_compare(wmKeyMapItem *k1, wmKeyMapItem *k2)
950 if (k1->flag & KMI_INACTIVE || k2->flag & KMI_INACTIVE)
953 /* take event mapping into account */
954 k1type = WM_userdef_event_map(k1->type);
955 k2type = WM_userdef_event_map(k2->type);
957 if (k1type != KM_ANY && k2type != KM_ANY && k1type != k2type)
960 if (k1->val != KM_ANY && k2->val != KM_ANY) {
961 /* take click, press, release conflict into account */
962 if (k1->val == KM_CLICK && ELEM3(k2->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0)
964 if (k2->val == KM_CLICK && ELEM3(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0)
966 if (k1->val != k2->val)
970 if (k1->shift != KM_ANY && k2->shift != KM_ANY && k1->shift != k2->shift)
973 if (k1->ctrl != KM_ANY && k2->ctrl != KM_ANY && k1->ctrl != k2->ctrl)
976 if (k1->alt != KM_ANY && k2->alt != KM_ANY && k1->alt != k2->alt)
979 if (k1->oskey != KM_ANY && k2->oskey != KM_ANY && k1->oskey != k2->oskey)
982 if (k1->keymodifier != k2->keymodifier)
988 /************************* Update Final Configuration *************************
989 * On load or other changes, the final user key configuration is rebuilt from
990 * the preset, addon and user preferences keymaps. We also test if the final
991 * configuration changed and write the changes to the user preferences. */
993 static int WM_KEYMAP_UPDATE = 0;
995 void WM_keyconfig_update_tag(wmKeyMap *km, wmKeyMapItem *kmi)
997 /* quick tag to do delayed keymap updates */
998 WM_KEYMAP_UPDATE = 1;
1001 km->flag |= KEYMAP_UPDATE;
1003 kmi->flag |= KMI_UPDATE;
1006 static int wm_keymap_test_and_clear_update(wmKeyMap *km)
1011 update = (km->flag & KEYMAP_UPDATE);
1012 km->flag &= ~KEYMAP_UPDATE;
1014 for (kmi = km->items.first; kmi; kmi = kmi->next) {
1015 update = update || (kmi->flag & KMI_UPDATE);
1016 kmi->flag &= ~KMI_UPDATE;
1022 static wmKeyMap *wm_keymap_preset(wmWindowManager *wm, wmKeyMap *km)
1024 wmKeyConfig *keyconf = WM_keyconfig_active(wm);
1027 keymap = WM_keymap_list_find(&keyconf->keymaps, km->idname, km->spaceid, km->regionid);
1029 keymap = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, km->spaceid, km->regionid);
1034 void WM_keyconfig_update(wmWindowManager *wm)
1036 wmKeyMap *km, *defaultmap, *addonmap, *usermap, *kmn;
1038 wmKeyMapDiffItem *kmdi;
1039 int compat_update = 0;
1043 if (!WM_KEYMAP_UPDATE)
1046 /* update operator properties for non-modal user keymaps */
1047 for (km = U.user_keymaps.first; km; km = km->next) {
1048 if ((km->flag & KEYMAP_MODAL) == 0) {
1049 for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {
1051 wm_keymap_item_properties_set(kmdi->add_item);
1052 if (kmdi->remove_item)
1053 wm_keymap_item_properties_set(kmdi->remove_item);
1056 for (kmi = km->items.first; kmi; kmi = kmi->next)
1057 wm_keymap_item_properties_set(kmi);
1061 /* update U.user_keymaps with user key configuration changes */
1062 for (km = wm->userconf->keymaps.first; km; km = km->next) {
1063 /* only diff if the user keymap was modified */
1064 if (wm_keymap_test_and_clear_update(km)) {
1066 defaultmap = wm_keymap_preset(wm, km);
1067 addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
1071 wm_keymap_diff_update(&U.user_keymaps, defaultmap, addonmap, km);
1075 /* create user key configuration from preset + addon + user preferences */
1076 for (km = wm->defaultconf->keymaps.first; km; km = km->next) {
1078 defaultmap = wm_keymap_preset(wm, km);
1079 addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
1080 usermap = WM_keymap_list_find(&U.user_keymaps, km->idname, km->spaceid, km->regionid);
1082 wm_user_modal_keymap_set_items(wm, defaultmap);
1085 kmn = wm_keymap_patch_update(&wm->userconf->keymaps, defaultmap, addonmap, usermap);
1088 kmn->modal_items = km->modal_items;
1089 kmn->poll = km->poll;
1092 /* in case of old non-diff keymaps, force extra update to create diffs */
1093 compat_update = compat_update || (usermap && !(usermap->flag & KEYMAP_DIFF));
1096 WM_KEYMAP_UPDATE = 0;
1098 if (compat_update) {
1099 WM_keyconfig_update_tag(NULL, NULL);
1100 WM_keyconfig_update(wm);
1104 /********************************* Event Handling *****************************
1105 * Handlers have pointers to the keymap in the default configuration. During
1106 * event handling this function is called to get the keymap from the final
1109 wmKeyMap *WM_keymap_active(wmWindowManager *wm, wmKeyMap *keymap)
1116 /* first user defined keymaps */
1117 km = WM_keymap_list_find(&wm->userconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
1125 /******************************* Keymap Editor ********************************
1126 * In the keymap editor the user key configuration is edited. */
1128 void WM_keymap_restore_item_to_default(bContext *C, wmKeyMap *keymap, wmKeyMapItem *kmi)
1130 wmWindowManager *wm = CTX_wm_manager(C);
1131 wmKeyMap *defaultmap, *addonmap;
1137 /* construct default keymap from preset + addons */
1138 defaultmap = wm_keymap_preset(wm, keymap);
1139 addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
1142 defaultmap = wm_keymap_copy(defaultmap);
1143 wm_keymap_addon_add(defaultmap, addonmap);
1146 /* find original item */
1147 orig = WM_keymap_item_find_id(defaultmap, kmi->id);
1150 /* restore to original */
1151 if (strcmp(orig->idname, kmi->idname) != 0) {
1152 BLI_strncpy(kmi->idname, orig->idname, sizeof(kmi->idname));
1153 WM_keymap_properties_reset(kmi, NULL);
1156 if (orig->properties) {
1157 if (kmi->properties) {
1158 IDP_FreeProperty(kmi->properties);
1159 MEM_freeN(kmi->properties);
1160 kmi->properties = NULL;
1163 kmi->properties = IDP_CopyProperty(orig->properties);
1164 kmi->ptr->data = kmi->properties;
1167 kmi->propvalue = orig->propvalue;
1168 kmi->type = orig->type;
1169 kmi->val = orig->val;
1170 kmi->shift = orig->shift;
1171 kmi->ctrl = orig->ctrl;
1172 kmi->alt = orig->alt;
1173 kmi->oskey = orig->oskey;
1174 kmi->keymodifier = orig->keymodifier;
1175 kmi->maptype = orig->maptype;
1177 WM_keyconfig_update_tag(keymap, kmi);
1180 /* free temporary keymap */
1182 WM_keymap_free(defaultmap);
1183 MEM_freeN(defaultmap);
1187 void WM_keymap_restore_to_default(wmKeyMap *keymap, bContext *C)
1189 wmWindowManager *wm = CTX_wm_manager(C);
1192 /* remove keymap from U.user_keymaps and update */
1193 usermap = WM_keymap_list_find(&U.user_keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
1196 WM_keymap_free(usermap);
1197 BLI_freelinkN(&U.user_keymaps, usermap);
1199 WM_keyconfig_update_tag(NULL, NULL);
1200 WM_keyconfig_update(wm);
1204 wmKeyMapItem *WM_keymap_item_find_id(wmKeyMap *keymap, int id)
1208 for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
1209 if (kmi->id == id) {
1217 /* Guess an appropriate keymap from the operator name */
1218 /* Needs to be kept up to date with Keymap and Operator naming */
1219 wmKeyMap *WM_keymap_guess_opname(const bContext *C, const char *opname)
1221 wmKeyMap *km = NULL;
1222 SpaceLink *sl = CTX_wm_space_data(C);
1225 if (strstr(opname, "WM_OT")) {
1226 km = WM_keymap_find_all(C, "Window", 0, 0);
1229 else if (strstr(opname, "SCREEN_OT")) {
1230 km = WM_keymap_find_all(C, "Screen", 0, 0);
1233 else if (strstr(opname, "GPENCIL_OT")) {
1234 km = WM_keymap_find_all(C, "Grease Pencil", 0, 0);
1237 else if (strstr(opname, "MARKER_OT")) {
1238 km = WM_keymap_find_all(C, "Markers", 0, 0);
1241 else if (strstr(opname, "IMPORT_") || strstr(opname, "EXPORT_")) {
1242 km = WM_keymap_find_all(C, "Window", 0, 0);
1247 else if (strstr(opname, "VIEW3D_OT")) {
1248 km = WM_keymap_find_all(C, "3D View", sl->spacetype, 0);
1250 else if (strstr(opname, "OBJECT_OT")) {
1251 km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1256 else if (strstr(opname, "MESH_OT")) {
1257 km = WM_keymap_find_all(C, "Mesh", 0, 0);
1259 /* some mesh operators are active in object mode too, like add-prim */
1260 if (km && km->poll && km->poll((bContext *)C) == 0) {
1261 km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1264 else if (strstr(opname, "CURVE_OT")) {
1265 km = WM_keymap_find_all(C, "Curve", 0, 0);
1267 /* some curve operators are active in object mode too, like add-prim */
1268 if (km && km->poll && km->poll((bContext *)C) == 0) {
1269 km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1272 else if (strstr(opname, "ARMATURE_OT")) {
1273 km = WM_keymap_find_all(C, "Armature", 0, 0);
1275 else if (strstr(opname, "POSE_OT")) {
1276 km = WM_keymap_find_all(C, "Pose", 0, 0);
1278 else if (strstr(opname, "SCULPT_OT")) {
1279 switch (CTX_data_mode_enum(C)) {
1280 case OB_MODE_SCULPT:
1281 km = WM_keymap_find_all(C, "Sculpt", 0, 0);
1284 km = WM_keymap_find_all(C, "UV Sculpt", 0, 0);
1288 else if (strstr(opname, "MBALL_OT")) {
1289 km = WM_keymap_find_all(C, "Metaball", 0, 0);
1291 /* some mball operators are active in object mode too, like add-prim */
1292 if (km && km->poll && km->poll((bContext *)C) == 0) {
1293 km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1296 else if (strstr(opname, "LATTICE_OT")) {
1297 km = WM_keymap_find_all(C, "Lattice", 0, 0);
1299 else if (strstr(opname, "PARTICLE_OT")) {
1300 km = WM_keymap_find_all(C, "Particle", 0, 0);
1302 else if (strstr(opname, "FONT_OT")) {
1303 km = WM_keymap_find_all(C, "Font", 0, 0);
1305 else if (strstr(opname, "PAINT_OT")) {
1307 /* check for relevant mode */
1308 switch (CTX_data_mode_enum(C)) {
1309 case OB_MODE_WEIGHT_PAINT:
1310 km = WM_keymap_find_all(C, "Weight Paint", 0, 0);
1312 case OB_MODE_VERTEX_PAINT:
1313 km = WM_keymap_find_all(C, "Vertex Paint", 0, 0);
1315 case OB_MODE_TEXTURE_PAINT:
1316 km = WM_keymap_find_all(C, "Image Paint", 0, 0);
1320 /* Paint Face Mask */
1321 else if (strstr(opname, "PAINT_OT_face_select")) {
1322 km = WM_keymap_find_all(C, "Face Mask", sl->spacetype, 0);
1325 else if (strstr(opname, "TIME_OT")) {
1326 km = WM_keymap_find_all(C, "Timeline", sl->spacetype, 0);
1329 else if (strstr(opname, "IMAGE_OT")) {
1330 km = WM_keymap_find_all(C, "Image", sl->spacetype, 0);
1333 else if (strstr(opname, "UV_OT")) {
1334 km = WM_keymap_find_all(C, "UV Editor", sl->spacetype, 0);
1337 else if (strstr(opname, "NODE_OT")) {
1338 km = WM_keymap_find_all(C, "Node Editor", sl->spacetype, 0);
1340 /* Animation Editor Channels */
1341 else if (strstr(opname, "ANIM_OT_channels")) {
1342 km = WM_keymap_find_all(C, "Animation Channels", sl->spacetype, 0);
1344 /* Animation Generic - after channels */
1345 else if (strstr(opname, "ANIM_OT")) {
1346 km = WM_keymap_find_all(C, "Animation", 0, 0);
1349 else if (strstr(opname, "GRAPH_OT")) {
1350 km = WM_keymap_find_all(C, "Graph Editor", sl->spacetype, 0);
1352 /* Dopesheet Editor */
1353 else if (strstr(opname, "ACTION_OT")) {
1354 km = WM_keymap_find_all(C, "Dopesheet", sl->spacetype, 0);
1357 else if (strstr(opname, "NLA_OT")) {
1358 km = WM_keymap_find_all(C, "NLA Editor", sl->spacetype, 0);
1361 else if (strstr(opname, "SCRIPT_OT")) {
1362 km = WM_keymap_find_all(C, "Script", sl->spacetype, 0);
1365 else if (strstr(opname, "TEXT_OT")) {
1366 km = WM_keymap_find_all(C, "Text", sl->spacetype, 0);
1369 else if (strstr(opname, "SEQUENCER_OT")) {
1370 km = WM_keymap_find_all(C, "Sequencer", sl->spacetype, 0);
1373 else if (strstr(opname, "CONSOLE_OT")) {
1374 km = WM_keymap_find_all(C, "Console", sl->spacetype, 0);
1377 else if (strstr(opname, "INFO_OT")) {
1378 km = WM_keymap_find_all(C, "Info", sl->spacetype, 0);
1382 else if (strstr(opname, "TRANSFORM_OT")) {
1384 /* check for relevant editor */
1385 switch (sl->spacetype) {
1387 km = WM_keymap_find_all(C, "3D View", sl->spacetype, 0);
1390 km = WM_keymap_find_all(C, "Graph Editor", sl->spacetype, 0);
1393 km = WM_keymap_find_all(C, "Dopesheet", sl->spacetype, 0);
1396 km = WM_keymap_find_all(C, "NLA Editor", sl->spacetype, 0);
1399 km = WM_keymap_find_all(C, "UV Editor", sl->spacetype, 0);
1402 km = WM_keymap_find_all(C, "Node Editor", sl->spacetype, 0);
1405 km = WM_keymap_find_all(C, "Sequencer", sl->spacetype, 0);