source/blender/windowmanager/intern/wm_keymap.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   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.
   8  *
   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.
  13  *
  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.
  17  *
  18  * The Original Code is Copyright (C) 2007 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  *
  22  * Contributor(s): Blender Foundation
  23  *
  24  * ***** END GPL LICENSE BLOCK *****
  25  */
  26
  27 /** \file blender/windowmanager/intern/wm_keymap.c
  28  *  \ingroup wm
  29  */
  30
  31
  32 #include <string.h>
  33
  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"
  39
  40 #include "MEM_guardedalloc.h"
  41
  42 #include "BLI_blenlib.h"
  43 #include "BLI_utildefines.h"
  44
  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"
  50 #include "BKE_main.h"
  51 #include "BKE_screen.h"
  52
  53
  54 #include "RNA_access.h"
  55 #include "RNA_enum_types.h"
  56
  57 #include "WM_api.h"
  58 #include "WM_types.h"
  59 #include "wm_window.h"
  60 #include "wm_event_system.h"
  61 #include "wm_event_types.h"
  62
  63 /******************************* Keymap Item **********************************
  64  * Item in a keymap, that maps from an event to an operator or modal map item */
  65
  66 static wmKeyMapItem *wm_keymap_item_copy(wmKeyMapItem *kmi)
  67 {
  68         wmKeyMapItem *kmin = MEM_dupallocN(kmi);
  69
  70         kmin->prev = kmin->next = NULL;
  71         kmin->flag &= ~KMI_UPDATE;
  72
  73         if (kmin->properties) {
  74                 kmin->ptr = MEM_callocN(sizeof(PointerRNA), "UserKeyMapItemPtr");
  75                 WM_operator_properties_create(kmin->ptr, kmin->idname);
  76
  77                 kmin->properties = IDP_CopyProperty(kmin->properties);
  78                 kmin->ptr->data = kmin->properties;
  79         }
  80
  81         return kmin;
  82 }
  83
  84 static void wm_keymap_item_free(wmKeyMapItem *kmi)
  85 {
  86         /* not kmi itself */
  87         if (kmi->ptr) {
  88                 WM_operator_properties_free(kmi->ptr);
  89                 MEM_freeN(kmi->ptr);
  90         }
  91 }
  92
  93 static void wm_keymap_item_properties_set(wmKeyMapItem *kmi)
  94 {
  95         WM_operator_properties_alloc(&(kmi->ptr), &(kmi->properties), kmi->idname);
  96         WM_operator_properties_sanitize(kmi->ptr, 1);
  97 }
  98
  99 static int wm_keymap_item_equals_result(wmKeyMapItem *a, wmKeyMapItem *b)
 100 {
 101         if (strcmp(a->idname, b->idname) != 0)
 102                 return 0;
 103
 104         if (!((a->ptr == NULL && b->ptr == NULL) ||
 105               (a->ptr && b->ptr && IDP_EqualsProperties(a->ptr->data, b->ptr->data))))
 106         {
 107                 return 0;
 108         }
 109
 110         if ((a->flag & KMI_INACTIVE) != (b->flag & KMI_INACTIVE))
 111                 return 0;
 112
 113         return (a->propvalue == b->propvalue);
 114 }
 115
 116 static int wm_keymap_item_equals(wmKeyMapItem *a, wmKeyMapItem *b)
 117 {
 118         return (wm_keymap_item_equals_result(a, b) &&
 119                 a->type == b->type &&
 120                 a->val == b->val &&
 121                 a->shift == b->shift &&
 122                 a->ctrl == b->ctrl &&
 123                 a->alt == b->alt &&
 124                 a->oskey == b->oskey &&
 125                 a->keymodifier == b->keymodifier &&
 126                 a->maptype == b->maptype);
 127 }
 128
 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)
 131 {
 132         WM_operator_properties_free(kmi->ptr);
 133         MEM_freeN(kmi->ptr);
 134
 135         kmi->ptr = NULL;
 136         kmi->properties = properties;
 137
 138         wm_keymap_item_properties_set(kmi);
 139 }
 140
 141 /**************************** Keymap Diff Item *********************************
 142  * Item in a diff keymap, used for saving diff of keymaps in user preferences */
 143
 144 static wmKeyMapDiffItem *wm_keymap_diff_item_copy(wmKeyMapDiffItem *kmdi)
 145 {
 146         wmKeyMapDiffItem *kmdin = MEM_dupallocN(kmdi);
 147
 148         kmdin->next = kmdin->prev = NULL;
 149         if (kmdi->add_item)
 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);
 153
 154         return kmdin;
 155 }
 156
 157 static void wm_keymap_diff_item_free(wmKeyMapDiffItem *kmdi)
 158 {
 159         if (kmdi->remove_item) {
 160                 wm_keymap_item_free(kmdi->remove_item);
 161                 MEM_freeN(kmdi->remove_item);
 162         }
 163         if (kmdi->add_item) {
 164                 wm_keymap_item_free(kmdi->add_item);
 165                 MEM_freeN(kmdi->add_item);
 166         }
 167 }
 168
 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. */
 172
 173 wmKeyConfig *WM_keyconfig_new(wmWindowManager *wm, const char *idname)
 174 {
 175         wmKeyConfig *keyconf;
 176
 177         keyconf = MEM_callocN(sizeof(wmKeyConfig), "wmKeyConfig");
 178         BLI_strncpy(keyconf->idname, idname, sizeof(keyconf->idname));
 179         BLI_addtail(&wm->keyconfigs, keyconf);
 180
 181         return keyconf;
 182 }
 183
 184 wmKeyConfig *WM_keyconfig_new_user(wmWindowManager *wm, const char *idname)
 185 {
 186         wmKeyConfig *keyconf = WM_keyconfig_new(wm, idname);
 187
 188         keyconf->flag |= KEYCONF_USER;
 189
 190         return keyconf;
 191 }
 192
 193 void WM_keyconfig_remove(wmWindowManager *wm, wmKeyConfig *keyconf)
 194 {
 195         if (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);
 199                 }
 200
 201                 BLI_remlink(&wm->keyconfigs, keyconf);
 202                 WM_keyconfig_free(keyconf);
 203         }
 204 }
 205
 206 void WM_keyconfig_free(wmKeyConfig *keyconf)
 207 {
 208         wmKeyMap *km;
 209
 210         while ((km = keyconf->keymaps.first)) {
 211                 WM_keymap_free(km);
 212                 BLI_freelinkN(&keyconf->keymaps, km);
 213         }
 214
 215         MEM_freeN(keyconf);
 216 }
 217
 218 static wmKeyConfig *wm_keyconfig_list_find(ListBase *lb, char *idname)
 219 {
 220         wmKeyConfig *kc;
 221
 222         for (kc = lb->first; kc; kc = kc->next)
 223                 if (0 == strncmp(idname, kc->idname, KMAP_MAX_NAME))
 224                         return kc;
 225
 226         return NULL;
 227 }
 228
 229 static wmKeyConfig *WM_keyconfig_active(wmWindowManager *wm)
 230 {
 231         wmKeyConfig *keyconf;
 232
 233         /* first try from preset */
 234         keyconf = wm_keyconfig_list_find(&wm->keyconfigs, U.keyconfigstr);
 235         if (keyconf)
 236                 return keyconf;
 237
 238         /* otherwise use default */
 239         return wm->defaultconf;
 240 }
 241
 242 void WM_keyconfig_set_active(wmWindowManager *wm, const char *idname)
 243 {
 244         /* setting a different key configuration as active: we ensure all is
 245          * updated properly before and after making the change */
 246
 247         WM_keyconfig_update(wm);
 248
 249         BLI_strncpy(U.keyconfigstr, idname, sizeof(U.keyconfigstr));
 250
 251         WM_keyconfig_update_tag(NULL, NULL);
 252         WM_keyconfig_update(wm);
 253 }
 254
 255 /********************************** Keymap *************************************
 256  * List of keymap items for one editor, mode, modal operator, ... */
 257
 258 static wmKeyMap *wm_keymap_new(const char *idname, int spaceid, int regionid)
 259 {
 260         wmKeyMap *km = MEM_callocN(sizeof(struct wmKeyMap), "keymap list");
 261
 262         BLI_strncpy(km->idname, idname, KMAP_MAX_NAME);
 263         km->spaceid = spaceid;
 264         km->regionid = regionid;
 265
 266         return km;
 267 }
 268
 269 static wmKeyMap *wm_keymap_copy(wmKeyMap *keymap)
 270 {
 271         wmKeyMap *keymapn = MEM_dupallocN(keymap);
 272         wmKeyMapItem *kmi, *kmin;
 273         wmKeyMapDiffItem *kmdi, *kmdin;
 274
 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);
 279
 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);
 283         }
 284
 285         for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
 286                 kmin = wm_keymap_item_copy(kmi);
 287                 BLI_addtail(&keymapn->items, kmin);
 288         }
 289
 290         return keymapn;
 291 }
 292
 293 void WM_keymap_free(wmKeyMap *keymap)
 294 {
 295         wmKeyMapItem *kmi;
 296         wmKeyMapDiffItem *kmdi;
 297
 298         for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next)
 299                 wm_keymap_diff_item_free(kmdi);
 300
 301         for (kmi = keymap->items.first; kmi; kmi = kmi->next)
 302                 wm_keymap_item_free(kmi);
 303
 304         BLI_freelistN(&keymap->diff_items);
 305         BLI_freelistN(&keymap->items);
 306 }
 307
 308 static void keymap_event_set(wmKeyMapItem *kmi, short type, short val, int modifier, short keymodifier)
 309 {
 310         kmi->type = type;
 311         kmi->val = val;
 312         kmi->keymodifier = keymodifier;
 313
 314         if (modifier == KM_ANY) {
 315                 kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY;
 316         }
 317         else {
 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);
 322         }
 323 }
 324
 325 static void keymap_item_set_id(wmKeyMap *keymap, wmKeyMapItem *kmi)
 326 {
 327         keymap->kmi_id++;
 328         if ((keymap->flag & KEYMAP_USER) == 0) {
 329                 kmi->id = keymap->kmi_id;
 330         }
 331         else {
 332                 kmi->id = -keymap->kmi_id; // User defined keymap entries have negative ids
 333         }
 334 }
 335
 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)
 338 {
 339         wmKeyMapItem *kmi;
 340
 341         for (kmi = keymap->items.first; kmi; kmi = kmi->next)
 342                 if (strncmp(kmi->idname, idname, OP_MAX_TYPENAME) == 0)
 343                         break;
 344         if (kmi == NULL) {
 345                 kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 346
 347                 BLI_addtail(&keymap->items, kmi);
 348                 BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
 349
 350                 keymap_item_set_id(keymap, kmi);
 351
 352                 keymap_event_set(kmi, type, val, modifier, keymodifier);
 353                 wm_keymap_item_properties_set(kmi);
 354         }
 355         return kmi;
 356 }
 357
 358 /* always add item */
 359 wmKeyMapItem *WM_keymap_add_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
 360 {
 361         wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 362
 363         BLI_addtail(&keymap->items, kmi);
 364         BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
 365
 366         keymap_event_set(kmi, type, val, modifier, keymodifier);
 367         wm_keymap_item_properties_set(kmi);
 368
 369         keymap_item_set_id(keymap, kmi);
 370
 371         WM_keyconfig_update_tag(keymap, kmi);
 372
 373         return kmi;
 374 }
 375
 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)
 378 {
 379         wmKeyMapItem *kmi = WM_keymap_add_item(keymap, "WM_OT_call_menu", type, val, modifier, keymodifier);
 380         RNA_string_set(kmi->ptr, "name", idname);
 381         return kmi;
 382 }
 383
 384 void WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi)
 385 {
 386         if (BLI_findindex(&keymap->items, kmi) != -1) {
 387                 if (kmi->ptr) {
 388                         WM_operator_properties_free(kmi->ptr);
 389                         MEM_freeN(kmi->ptr);
 390                 }
 391                 BLI_freelinkN(&keymap->items, kmi);
 392
 393                 WM_keyconfig_update_tag(keymap, kmi);
 394         }
 395 }
 396
 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
 401  * are changed. */
 402
 403 static void wm_keymap_addon_add(wmKeyMap *keymap, wmKeyMap *addonmap)
 404 {
 405         wmKeyMapItem *kmi, *kmin;
 406
 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);
 411         }
 412 }
 413
 414 static wmKeyMapItem *wm_keymap_find_item_equals(wmKeyMap *km, wmKeyMapItem *needle)
 415 {
 416         wmKeyMapItem *kmi;
 417
 418         for (kmi = km->items.first; kmi; kmi = kmi->next)
 419                 if (wm_keymap_item_equals(kmi, needle))
 420                         return kmi;
 421
 422         return NULL;
 423 }
 424
 425 static wmKeyMapItem *wm_keymap_find_item_equals_result(wmKeyMap *km, wmKeyMapItem *needle)
 426 {
 427         wmKeyMapItem *kmi;
 428
 429         for (kmi = km->items.first; kmi; kmi = kmi->next)
 430                 if (wm_keymap_item_equals_result(kmi, needle))
 431                         return kmi;
 432
 433         return NULL;
 434 }
 435
 436 static void wm_keymap_diff(wmKeyMap *diff_km, wmKeyMap *from_km, wmKeyMap *to_km, wmKeyMap *orig_km, wmKeyMap *addon_km)
 437 {
 438         wmKeyMapItem *kmi, *to_kmi, *orig_kmi;
 439         wmKeyMapDiffItem *kmdi;
 440
 441         for (kmi = from_km->items.first; kmi; kmi = kmi->next) {
 442                 to_kmi = WM_keymap_item_find_id(to_km, kmi->id);
 443
 444                 if (!to_kmi) {
 445                         /* remove item */
 446                         kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
 447                         kmdi->remove_item = wm_keymap_item_copy(kmi);
 448                         BLI_addtail(&diff_km->diff_items, kmdi);
 449                 }
 450                 else if (to_kmi && !wm_keymap_item_equals(kmi, to_kmi)) {
 451                         /* replace item */
 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);
 456                 }
 457
 458                 /* sync expanded flag back to original so we don't loose it on repatch */
 459                 if (to_kmi) {
 460                         orig_kmi = WM_keymap_item_find_id(orig_km, kmi->id);
 461
 462                         if (!orig_kmi)
 463                                 orig_kmi = wm_keymap_find_item_equals(addon_km, kmi);
 464
 465                         if (orig_kmi) {
 466                                 orig_kmi->flag &= ~KMI_EXPANDED;
 467                                 orig_kmi->flag |= (to_kmi->flag & KMI_EXPANDED);
 468                         }
 469                 }
 470         }
 471
 472         for (kmi = to_km->items.first; kmi; kmi = kmi->next) {
 473                 if (kmi->id < 0) {
 474                         /* add item */
 475                         kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
 476                         kmdi->add_item = wm_keymap_item_copy(kmi);
 477                         BLI_addtail(&diff_km->diff_items, kmdi);
 478                 }
 479         }
 480 }
 481
 482 static void wm_keymap_patch(wmKeyMap *km, wmKeyMap *diff_km)
 483 {
 484         wmKeyMapDiffItem *kmdi;
 485         wmKeyMapItem *kmi_remove, *kmi_add;
 486
 487         for (kmdi = diff_km->diff_items.first; kmdi; kmdi = kmdi->next) {
 488                 /* find item to remove */
 489                 kmi_remove = NULL;
 490                 if (kmdi->remove_item) {
 491                         kmi_remove = wm_keymap_find_item_equals(km, kmdi->remove_item);
 492                         if (!kmi_remove)
 493                                 kmi_remove = wm_keymap_find_item_equals_result(km, kmdi->remove_item);
 494                 }
 495
 496                 /* add 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;
 502
 503                                 if (kmi_remove) {
 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);
 508                                 }
 509                                 else {
 510                                         keymap_item_set_id(km, kmi_add);
 511                                         BLI_addtail(&km->items, kmi_add);
 512                                 }
 513                         }
 514                 }
 515
 516                 /* remove item */
 517                 if (kmi_remove) {
 518                         wm_keymap_item_free(kmi_remove);
 519                         BLI_freelinkN(&km->items, kmi_remove);
 520                 }
 521         }
 522 }
 523
 524 static wmKeyMap *wm_keymap_patch_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *usermap)
 525 {
 526         wmKeyMap *km;
 527         int expanded = 0;
 528
 529         /* remove previous keymap in list, we will replace it */
 530         km = WM_keymap_list_find(lb, defaultmap->idname, defaultmap->spaceid, defaultmap->regionid);
 531         if (km) {
 532                 expanded = (km->flag & (KEYMAP_EXPANDED | KEYMAP_CHILDREN_EXPANDED));
 533                 WM_keymap_free(km);
 534                 BLI_freelinkN(lb, km);
 535         }
 536
 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;
 542
 543                 km = wm_keymap_copy(usermap);
 544
 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);
 548                         if (!orig_kmi)
 549                                 orig_kmi = wm_keymap_find_item_equals_result(defaultmap, kmi);
 550
 551                         if (orig_kmi)
 552                                 kmi->id = orig_kmi->id;
 553                         else
 554                                 kmi->id = -(km->kmi_id++);
 555                 }
 556
 557                 km->flag |= KEYMAP_UPDATE; /* update again to create diff */
 558         }
 559         else
 560                 km = wm_keymap_copy(defaultmap);
 561
 562         /* add addon keymap items */
 563         if (addonmap)
 564                 wm_keymap_addon_add(km, addonmap);
 565
 566         /* tag as being user edited */
 567         if (usermap)
 568                 km->flag |= KEYMAP_USER_MODIFIED;
 569         km->flag |= KEYMAP_USER | expanded;
 570
 571         /* apply user changes of diff keymap */
 572         if (usermap && (usermap->flag & KEYMAP_DIFF))
 573                 wm_keymap_patch(km, usermap);
 574
 575         /* add to list */
 576         BLI_addtail(lb, km);
 577
 578         return km;
 579 }
 580
 581 static void wm_keymap_diff_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *km)
 582 {
 583         wmKeyMap *diffmap, *prevmap, *origmap;
 584
 585         /* create temporary default + addon keymap for diff */
 586         origmap = defaultmap;
 587
 588         if (addonmap) {
 589                 defaultmap = wm_keymap_copy(defaultmap);
 590                 wm_keymap_addon_add(defaultmap, addonmap);
 591         }
 592
 593         /* remove previous diff keymap in list, we will replace it */
 594         prevmap = WM_keymap_list_find(lb, km->idname, km->spaceid, km->regionid);
 595         if (prevmap) {
 596                 WM_keymap_free(prevmap);
 597                 BLI_freelinkN(lb, prevmap);
 598         }
 599
 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);
 606
 607         /* add to list if not empty */
 608         if (diffmap->diff_items.first) {
 609                 BLI_addtail(lb, diffmap);
 610         }
 611         else {
 612                 WM_keymap_free(diffmap);
 613                 MEM_freeN(diffmap);
 614         }
 615
 616         /* free temporary default map */
 617         if (addonmap) {
 618                 WM_keymap_free(defaultmap);
 619                 MEM_freeN(defaultmap);
 620         }
 621 }
 622
 623 /* ****************** storage in WM ************ */
 624
 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 */
 628
 629 wmKeyMap *WM_keymap_list_find(ListBase *lb, const char *idname, int spaceid, int regionid)
 630 {
 631         wmKeyMap *km;
 632
 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))
 636                                 return km;
 637
 638         return NULL;
 639 }
 640
 641 wmKeyMap *WM_keymap_find(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
 642 {
 643         wmKeyMap *km = WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
 644
 645         if (km == NULL) {
 646                 km = wm_keymap_new(idname, spaceid, regionid);
 647                 BLI_addtail(&keyconf->keymaps, km);
 648
 649                 WM_keyconfig_update_tag(km, NULL);
 650         }
 651
 652         return km;
 653 }
 654
 655 wmKeyMap *WM_keymap_find_all(const bContext *C, const char *idname, int spaceid, int regionid)
 656 {
 657         wmWindowManager *wm = CTX_wm_manager(C);
 658
 659         return WM_keymap_list_find(&wm->userconf->keymaps, idname, spaceid, regionid);
 660 }
 661
 662 /* ****************** modal keymaps ************ */
 663
 664 /* modal maps get linked to a running operator, and filter the keys before sending to modal() callback */
 665
 666 wmKeyMap *WM_modalkeymap_add(wmKeyConfig *keyconf, const char *idname, EnumPropertyItem *items)
 667 {
 668         wmKeyMap *km = WM_keymap_find(keyconf, idname, 0, 0);
 669         km->flag |= KEYMAP_MODAL;
 670         km->modal_items = items;
 671
 672         if (!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);
 676
 677                 if (defaultkm) {
 678                         km->modal_items = defaultkm->modal_items;
 679                         km->poll = defaultkm->poll;
 680                 }
 681         }
 682
 683         return km;
 684 }
 685
 686 wmKeyMap *WM_modalkeymap_get(wmKeyConfig *keyconf, const char *idname)
 687 {
 688         wmKeyMap *km;
 689
 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))
 693                                 break;
 694
 695         return km;
 696 }
 697
 698
 699 wmKeyMapItem *WM_modalkeymap_add_item(wmKeyMap *km, int type, int val, int modifier, int keymodifier, int value)
 700 {
 701         wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 702
 703         BLI_addtail(&km->items, kmi);
 704         kmi->propvalue = value;
 705
 706         keymap_event_set(kmi, type, val, modifier, keymodifier);
 707
 708         keymap_item_set_id(km, kmi);
 709
 710         WM_keyconfig_update_tag(km, kmi);
 711
 712         return kmi;
 713 }
 714
 715 wmKeyMapItem *WM_modalkeymap_add_item_str(wmKeyMap *km, int type, int val, int modifier, int keymodifier, const char *value)
 716 {
 717         wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 718
 719         BLI_addtail(&km->items, kmi);
 720         BLI_strncpy(kmi->propvalue_str, value, sizeof(kmi->propvalue_str));
 721
 722         keymap_event_set(kmi, type, val, modifier, keymodifier);
 723
 724         keymap_item_set_id(km, kmi);
 725
 726         WM_keyconfig_update_tag(km, kmi);
 727
 728         return kmi;
 729 }
 730
 731 void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
 732 {
 733         wmOperatorType *ot = WM_operatortype_find(opname, 0);
 734
 735         if (ot)
 736                 ot->modalkeymap = km;
 737         else
 738                 printf("error: modalkeymap_assign, unknown operator %s\n", opname);
 739 }
 740
 741 static void wm_user_modal_keymap_set_items(wmWindowManager *wm, wmKeyMap *km)
 742 {
 743         /* here we convert propvalue string values delayed, due to python keymaps
 744          * being created before the actual modal keymaps, so no modal_items */
 745         wmKeyMap *defaultkm;
 746         wmKeyMapItem *kmi;
 747         int propvalue;
 748
 749         if (km && (km->flag & KEYMAP_MODAL) && !km->modal_items) {
 750                 defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
 751
 752                 if (!defaultkm)
 753                         return;
 754
 755                 km->modal_items = defaultkm->modal_items;
 756                 km->poll = defaultkm->poll;
 757
 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';
 763                         }
 764                 }
 765         }
 766 }
 767
 768 /* ***************** get string from key events **************** */
 769
 770 const char *WM_key_event_string(short type)
 771 {
 772         const char *name = NULL;
 773         if (RNA_enum_name(event_type_items, (int)type, &name))
 774                 return name;
 775
 776         return "";
 777 }
 778
 779 char *WM_keymap_item_to_string(wmKeyMapItem *kmi, char *str, int len)
 780 {
 781         char buf[128];
 782
 783         buf[0] = 0;
 784
 785         if (kmi->shift == KM_ANY &&
 786             kmi->ctrl == KM_ANY &&
 787             kmi->alt == KM_ANY &&
 788             kmi->oskey == KM_ANY) {
 789
 790                 strcat(buf, "Any ");
 791         }
 792         else {
 793                 if (kmi->shift)
 794                         strcat(buf, "Shift ");
 795
 796                 if (kmi->ctrl)
 797                         strcat(buf, "Ctrl ");
 798
 799                 if (kmi->alt)
 800                         strcat(buf, "Alt ");
 801
 802                 if (kmi->oskey)
 803                         strcat(buf, "Cmd ");
 804         }
 805
 806         if (kmi->keymodifier) {
 807                 strcat(buf, WM_key_event_string(kmi->keymodifier));
 808                 strcat(buf, " ");
 809         }
 810
 811         strcat(buf, WM_key_event_string(kmi->type));
 812         BLI_strncpy(str, buf, len);
 813
 814         return str;
 815 }
 816
 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)
 820 {
 821         wmWindowManager *wm = CTX_wm_manager(C);
 822         wmEventHandler *handler;
 823         wmKeyMap *keymap;
 824         wmKeyMapItem *kmi;
 825
 826         /* find keymap item in handlers */
 827         for (handler = handlers->first; handler; handler = handler->next) {
 828                 keymap = WM_keymap_active(wm, handler->keymap);
 829
 830                 if (keymap && (!keymap->poll || keymap->poll((bContext *)C))) {
 831                         for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
 832
 833                                 if (strcmp(kmi->idname, opname) == 0 && WM_key_event_string(kmi->type)[0]) {
 834                                         if (hotkey)
 835                                                 if (!ISHOTKEY(kmi->type))
 836                                                         continue;
 837
 838                                         if (compare_props) {
 839                                                 if (kmi->ptr && IDP_EqualsProperties(properties, kmi->ptr->data)) {
 840                                                         if (keymap_r) *keymap_r = keymap;
 841                                                         return kmi;
 842                                                 }
 843                                         }
 844                                         else {
 845                                                 if (keymap_r) *keymap_r = keymap;
 846                                                 return kmi;
 847                                         }
 848                                 }
 849                         }
 850                 }
 851         }
 852
 853         /* ensure un-initialized keymap is never used */
 854         if (keymap_r) *keymap_r = NULL;
 855         return NULL;
 856 }
 857
 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)
 861 {
 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;
 866
 867         /* look into multiple handler lists to find the item */
 868         if (win)
 869                 found = wm_keymap_item_find_handlers(C, &win->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 870
 871
 872         if (sa && found == NULL)
 873                 found = wm_keymap_item_find_handlers(C, &sa->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 874
 875         if (found == NULL) {
 876                 if (ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) {
 877                         if (sa) {
 878                                 if (!(ar && ar->regiontype == RGN_TYPE_WINDOW))
 879                                         ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
 880
 881                                 if (ar)
 882                                         found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 883                         }
 884                 }
 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);
 888
 889                         if (ar)
 890                                 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 891                 }
 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);
 895
 896                         if (ar)
 897                                 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 898                 }
 899                 else {
 900                         if (ar)
 901                                 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 902                 }
 903         }
 904
 905         return found;
 906 }
 907
 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)
 911 {
 912         wmKeyMapItem *found = wm_keymap_item_find_props(C, opname, opcontext, properties, 1, hotkey, keymap_r);
 913
 914         if (!found && sloppy)
 915                 found = wm_keymap_item_find_props(C, opname, opcontext, NULL, 0, hotkey, keymap_r);
 916
 917         return found;
 918 }
 919
 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)
 923 {
 924         wmKeyMapItem *kmi = wm_keymap_item_find(C, opname, opcontext, properties, 0, sloppy, NULL);
 925
 926         if (kmi) {
 927                 WM_keymap_item_to_string(kmi, str, len);
 928                 return str;
 929         }
 930
 931         return NULL;
 932 }
 933
 934 int WM_key_event_operator_id(
 935     const bContext *C, const char *opname, int opcontext,
 936     IDProperty *properties, int hotkey, wmKeyMap **keymap_r)
 937 {
 938         wmKeyMapItem *kmi = wm_keymap_item_find(C, opname, opcontext, properties, hotkey, TRUE, keymap_r);
 939
 940         if (kmi)
 941                 return kmi->id;
 942         else
 943                 return 0;
 944 }
 945
 946 int WM_keymap_item_compare(wmKeyMapItem *k1, wmKeyMapItem *k2)
 947 {
 948         int k1type, k2type;
 949
 950         if (k1->flag & KMI_INACTIVE || k2->flag & KMI_INACTIVE)
 951                 return 0;
 952
 953         /* take event mapping into account */
 954         k1type = WM_userdef_event_map(k1->type);
 955         k2type = WM_userdef_event_map(k2->type);
 956
 957         if (k1type != KM_ANY && k2type != KM_ANY && k1type != k2type)
 958                 return 0;
 959
 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)
 963                         return 0;
 964                 if (k2->val == KM_CLICK && ELEM3(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0)
 965                         return 0;
 966                 if (k1->val != k2->val)
 967                         return 0;
 968         }
 969
 970         if (k1->shift != KM_ANY && k2->shift != KM_ANY && k1->shift != k2->shift)
 971                 return 0;
 972
 973         if (k1->ctrl != KM_ANY && k2->ctrl != KM_ANY && k1->ctrl != k2->ctrl)
 974                 return 0;
 975
 976         if (k1->alt != KM_ANY && k2->alt != KM_ANY && k1->alt != k2->alt)
 977                 return 0;
 978
 979         if (k1->oskey != KM_ANY && k2->oskey != KM_ANY && k1->oskey != k2->oskey)
 980                 return 0;
 981
 982         if (k1->keymodifier != k2->keymodifier)
 983                 return 0;
 984
 985         return 1;
 986 }
 987
 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. */
 992
 993 static int WM_KEYMAP_UPDATE = 0;
 994
 995 void WM_keyconfig_update_tag(wmKeyMap *km, wmKeyMapItem *kmi)
 996 {
 997         /* quick tag to do delayed keymap updates */
 998         WM_KEYMAP_UPDATE = 1;
 999
1000         if (km)
1001                 km->flag |= KEYMAP_UPDATE;
1002         if (kmi)
1003                 kmi->flag |= KMI_UPDATE;
1004 }
1005
1006 static int wm_keymap_test_and_clear_update(wmKeyMap *km)
1007 {
1008         wmKeyMapItem *kmi;
1009         int update;
1010
1011         update = (km->flag & KEYMAP_UPDATE);
1012         km->flag &= ~KEYMAP_UPDATE;
1013
1014         for (kmi = km->items.first; kmi; kmi = kmi->next) {
1015                 update = update || (kmi->flag & KMI_UPDATE);
1016                 kmi->flag &= ~KMI_UPDATE;
1017         }
1018
1019         return update;
1020 }
1021
1022 static wmKeyMap *wm_keymap_preset(wmWindowManager *wm, wmKeyMap *km)
1023 {
1024         wmKeyConfig *keyconf = WM_keyconfig_active(wm);
1025         wmKeyMap *keymap;
1026
1027         keymap = WM_keymap_list_find(&keyconf->keymaps, km->idname, km->spaceid, km->regionid);
1028         if (!keymap)
1029                 keymap = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, km->spaceid, km->regionid);
1030
1031         return keymap;
1032 }
1033
1034 void WM_keyconfig_update(wmWindowManager *wm)
1035 {
1036         wmKeyMap *km, *defaultmap, *addonmap, *usermap, *kmn;
1037         wmKeyMapItem *kmi;
1038         wmKeyMapDiffItem *kmdi;
1039         int compat_update = 0;
1040
1041         if (G.background)
1042                 return;
1043         if (!WM_KEYMAP_UPDATE)
1044                 return;
1045
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) {
1050                                 if (kmdi->add_item)
1051                                         wm_keymap_item_properties_set(kmdi->add_item);
1052                                 if (kmdi->remove_item)
1053                                         wm_keymap_item_properties_set(kmdi->remove_item);
1054                         }
1055
1056                         for (kmi = km->items.first; kmi; kmi = kmi->next)
1057                                 wm_keymap_item_properties_set(kmi);
1058                 }
1059         }
1060
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)) {
1065                         /* find keymaps */
1066                         defaultmap = wm_keymap_preset(wm, km);
1067                         addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
1068
1069                         /* diff */
1070                         if (defaultmap)
1071                                 wm_keymap_diff_update(&U.user_keymaps, defaultmap, addonmap, km);
1072                 }
1073         }
1074
1075         /* create user key configuration from preset + addon + user preferences */
1076         for (km = wm->defaultconf->keymaps.first; km; km = km->next) {
1077                 /* find keymaps */
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);
1081
1082                 wm_user_modal_keymap_set_items(wm, defaultmap);
1083
1084                 /* add */
1085                 kmn = wm_keymap_patch_update(&wm->userconf->keymaps, defaultmap, addonmap, usermap);
1086
1087                 if (kmn) {
1088                         kmn->modal_items = km->modal_items;
1089                         kmn->poll = km->poll;
1090                 }
1091
1092                 /* in case of old non-diff keymaps, force extra update to create diffs */
1093                 compat_update = compat_update || (usermap && !(usermap->flag & KEYMAP_DIFF));
1094         }
1095
1096         WM_KEYMAP_UPDATE = 0;
1097
1098         if (compat_update) {
1099                 WM_keyconfig_update_tag(NULL, NULL);
1100                 WM_keyconfig_update(wm);
1101         }
1102 }
1103
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
1107  * configuration. */
1108
1109 wmKeyMap *WM_keymap_active(wmWindowManager *wm, wmKeyMap *keymap)
1110 {
1111         wmKeyMap *km;
1112
1113         if (!keymap)
1114                 return NULL;
1115
1116         /* first user defined keymaps */
1117         km = WM_keymap_list_find(&wm->userconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
1118
1119         if (km)
1120                 return km;
1121
1122         return keymap;
1123 }
1124
1125 /******************************* Keymap Editor ********************************
1126  * In the keymap editor the user key configuration is edited. */
1127
1128 void WM_keymap_restore_item_to_default(bContext *C, wmKeyMap *keymap, wmKeyMapItem *kmi)
1129 {
1130         wmWindowManager *wm = CTX_wm_manager(C);
1131         wmKeyMap *defaultmap, *addonmap;
1132         wmKeyMapItem *orig;
1133
1134         if (!keymap)
1135                 return;
1136
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);
1140
1141         if (addonmap) {
1142                 defaultmap = wm_keymap_copy(defaultmap);
1143                 wm_keymap_addon_add(defaultmap, addonmap);
1144         }
1145
1146         /* find original item */
1147         orig = WM_keymap_item_find_id(defaultmap, kmi->id);
1148
1149         if (orig) {
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);
1154                 }
1155
1156                 if (orig->properties) {
1157                         if (kmi->properties) {
1158                                 IDP_FreeProperty(kmi->properties);
1159                                 MEM_freeN(kmi->properties);
1160                                 kmi->properties = NULL;
1161                         }
1162
1163                         kmi->properties = IDP_CopyProperty(orig->properties);
1164                         kmi->ptr->data = kmi->properties;
1165                 }
1166
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;
1176
1177                 WM_keyconfig_update_tag(keymap, kmi);
1178         }
1179
1180         /* free temporary keymap */
1181         if (addonmap) {
1182                 WM_keymap_free(defaultmap);
1183                 MEM_freeN(defaultmap);
1184         }
1185 }
1186
1187 void WM_keymap_restore_to_default(wmKeyMap *keymap, bContext *C)
1188 {
1189         wmWindowManager *wm = CTX_wm_manager(C);
1190         wmKeyMap *usermap;
1191
1192         /* remove keymap from U.user_keymaps and update */
1193         usermap = WM_keymap_list_find(&U.user_keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
1194
1195         if (usermap) {
1196                 WM_keymap_free(usermap);
1197                 BLI_freelinkN(&U.user_keymaps, usermap);
1198
1199                 WM_keyconfig_update_tag(NULL, NULL);
1200                 WM_keyconfig_update(wm);
1201         }
1202 }
1203
1204 wmKeyMapItem *WM_keymap_item_find_id(wmKeyMap *keymap, int id)
1205 {
1206         wmKeyMapItem *kmi;
1207
1208         for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
1209                 if (kmi->id == id) {
1210                         return kmi;
1211                 }
1212         }
1213
1214         return NULL;
1215 }
1216
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)
1220 {
1221         wmKeyMap *km = NULL;
1222         SpaceLink *sl = CTX_wm_space_data(C);
1223
1224         /* Window */
1225         if (strstr(opname, "WM_OT")) {
1226                 km = WM_keymap_find_all(C, "Window", 0, 0);
1227         }
1228         /* Screen */
1229         else if (strstr(opname, "SCREEN_OT")) {
1230                 km = WM_keymap_find_all(C, "Screen", 0, 0);
1231         }
1232         /* Grease Pencil */
1233         else if (strstr(opname, "GPENCIL_OT")) {
1234                 km = WM_keymap_find_all(C, "Grease Pencil", 0, 0);
1235         }
1236         /* Markers */
1237         else if (strstr(opname, "MARKER_OT")) {
1238                 km = WM_keymap_find_all(C, "Markers", 0, 0);
1239         }
1240         /* Import/Export*/
1241         else if (strstr(opname, "IMPORT_") || strstr(opname, "EXPORT_")) {
1242                 km = WM_keymap_find_all(C, "Window", 0, 0);
1243         }
1244
1245
1246         /* 3D View */
1247         else if (strstr(opname, "VIEW3D_OT")) {
1248                 km = WM_keymap_find_all(C, "3D View", sl->spacetype, 0);
1249         }
1250         else if (strstr(opname, "OBJECT_OT")) {
1251                 km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1252         }
1253
1254
1255         /* Editing Modes */
1256         else if (strstr(opname, "MESH_OT")) {
1257                 km = WM_keymap_find_all(C, "Mesh", 0, 0);
1258
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);
1262                 }
1263         }
1264         else if (strstr(opname, "CURVE_OT")) {
1265                 km = WM_keymap_find_all(C, "Curve", 0, 0);
1266
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);
1270                 }
1271         }
1272         else if (strstr(opname, "ARMATURE_OT")) {
1273                 km = WM_keymap_find_all(C, "Armature", 0, 0);
1274         }
1275         else if (strstr(opname, "POSE_OT")) {
1276                 km = WM_keymap_find_all(C, "Pose", 0, 0);
1277         }
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);
1282                                 break;
1283                         case OB_MODE_EDIT:
1284                                 km = WM_keymap_find_all(C, "UV Sculpt", 0, 0);
1285                                 break;
1286                 }
1287         }
1288         else if (strstr(opname, "MBALL_OT")) {
1289                 km = WM_keymap_find_all(C, "Metaball", 0, 0);
1290
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);
1294                 }
1295         }
1296         else if (strstr(opname, "LATTICE_OT")) {
1297                 km = WM_keymap_find_all(C, "Lattice", 0, 0);
1298         }
1299         else if (strstr(opname, "PARTICLE_OT")) {
1300                 km = WM_keymap_find_all(C, "Particle", 0, 0);
1301         }
1302         else if (strstr(opname, "FONT_OT")) {
1303                 km = WM_keymap_find_all(C, "Font", 0, 0);
1304         }
1305         else if (strstr(opname, "PAINT_OT")) {
1306
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);
1311                                 break;
1312                         case OB_MODE_VERTEX_PAINT:
1313                                 km = WM_keymap_find_all(C, "Vertex Paint", 0, 0);
1314                                 break;
1315                         case OB_MODE_TEXTURE_PAINT:
1316                                 km = WM_keymap_find_all(C, "Image Paint", 0, 0);
1317                                 break;
1318                 }
1319         }
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);
1323         }
1324         /* Timeline */
1325         else if (strstr(opname, "TIME_OT")) {
1326                 km = WM_keymap_find_all(C, "Timeline", sl->spacetype, 0);
1327         }
1328         /* Image Editor */
1329         else if (strstr(opname, "IMAGE_OT")) {
1330                 km = WM_keymap_find_all(C, "Image", sl->spacetype, 0);
1331         }
1332         /* UV Editor */
1333         else if (strstr(opname, "UV_OT")) {
1334                 km = WM_keymap_find_all(C, "UV Editor", sl->spacetype, 0);
1335         }
1336         /* Node Editor */
1337         else if (strstr(opname, "NODE_OT")) {
1338                 km = WM_keymap_find_all(C, "Node Editor", sl->spacetype, 0);
1339         }
1340         /* Animation Editor Channels */
1341         else if (strstr(opname, "ANIM_OT_channels")) {
1342                 km = WM_keymap_find_all(C, "Animation Channels", sl->spacetype, 0);
1343         }
1344         /* Animation Generic - after channels */
1345         else if (strstr(opname, "ANIM_OT")) {
1346                 km = WM_keymap_find_all(C, "Animation", 0, 0);
1347         }
1348         /* Graph Editor */
1349         else if (strstr(opname, "GRAPH_OT")) {
1350                 km = WM_keymap_find_all(C, "Graph Editor", sl->spacetype, 0);
1351         }
1352         /* Dopesheet Editor */
1353         else if (strstr(opname, "ACTION_OT")) {
1354                 km = WM_keymap_find_all(C, "Dopesheet", sl->spacetype, 0);
1355         }
1356         /* NLA Editor */
1357         else if (strstr(opname, "NLA_OT")) {
1358                 km = WM_keymap_find_all(C, "NLA Editor", sl->spacetype, 0);
1359         }
1360         /* Script */
1361         else if (strstr(opname, "SCRIPT_OT")) {
1362                 km = WM_keymap_find_all(C, "Script", sl->spacetype, 0);
1363         }
1364         /* Text */
1365         else if (strstr(opname, "TEXT_OT")) {
1366                 km = WM_keymap_find_all(C, "Text", sl->spacetype, 0);
1367         }
1368         /* Sequencer */
1369         else if (strstr(opname, "SEQUENCER_OT")) {
1370                 km = WM_keymap_find_all(C, "Sequencer", sl->spacetype, 0);
1371         }
1372         /* Console */
1373         else if (strstr(opname, "CONSOLE_OT")) {
1374                 km = WM_keymap_find_all(C, "Console", sl->spacetype, 0);
1375         }
1376         /* Console */
1377         else if (strstr(opname, "INFO_OT")) {
1378                 km = WM_keymap_find_all(C, "Info", sl->spacetype, 0);
1379         }
1380
1381         /* Transform */
1382         else if (strstr(opname, "TRANSFORM_OT")) {
1383
1384                 /* check for relevant editor */
1385                 switch (sl->spacetype) {
1386                         case SPACE_VIEW3D:
1387                                 km = WM_keymap_find_all(C, "3D View", sl->spacetype, 0);
1388                                 break;
1389                         case SPACE_IPO:
1390                                 km = WM_keymap_find_all(C, "Graph Editor", sl->spacetype, 0);
1391                                 break;
1392                         case SPACE_ACTION:
1393                                 km = WM_keymap_find_all(C, "Dopesheet", sl->spacetype, 0);
1394                                 break;
1395                         case SPACE_NLA:
1396                                 km = WM_keymap_find_all(C, "NLA Editor", sl->spacetype, 0);
1397                                 break;
1398                         case SPACE_IMAGE:
1399                                 km = WM_keymap_find_all(C, "UV Editor", sl->spacetype, 0);
1400                                 break;
1401                         case SPACE_NODE:
1402                                 km = WM_keymap_find_all(C, "Node Editor", sl->spacetype, 0);
1403                                 break;
1404                         case SPACE_SEQ:
1405                                 km = WM_keymap_find_all(C, "Sequencer", sl->spacetype, 0);
1406                                 break;
1407                 }
1408         }
1409
1410         return km;
1411 }
1412