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                 return 0;
 107
 108         if ((a->flag & KMI_INACTIVE) != (b->flag & KMI_INACTIVE))
 109                 return 0;
 110
 111         return (a->propvalue == b->propvalue);
 112 }
 113
 114 static int wm_keymap_item_equals(wmKeyMapItem *a, wmKeyMapItem *b)
 115 {
 116         return (wm_keymap_item_equals_result(a, b) &&
 117                 a->type == b->type &&
 118                 a->val == b->val &&
 119                 a->shift == b->shift &&
 120                 a->ctrl == b->ctrl &&
 121                 a->alt == b->alt &&
 122                 a->oskey == b->oskey &&
 123                 a->keymodifier == b->keymodifier &&
 124                 a->maptype == b->maptype);
 125 }
 126
 127 /* properties can be NULL, otherwise the arg passed is used and ownership is given to the kmi */
 128 void WM_keymap_properties_reset(wmKeyMapItem *kmi, struct IDProperty *properties)
 129 {
 130         WM_operator_properties_free(kmi->ptr);
 131         MEM_freeN(kmi->ptr);
 132
 133         kmi->ptr = NULL;
 134         kmi->properties = properties;
 135
 136         wm_keymap_item_properties_set(kmi);
 137 }
 138
 139 /**************************** Keymap Diff Item *********************************
 140  * Item in a diff keymap, used for saving diff of keymaps in user preferences */
 141
 142 static wmKeyMapDiffItem *wm_keymap_diff_item_copy(wmKeyMapDiffItem *kmdi)
 143 {
 144         wmKeyMapDiffItem *kmdin = MEM_dupallocN(kmdi);
 145
 146         kmdin->next = kmdin->prev = NULL;
 147         if (kmdi->add_item)
 148                 kmdin->add_item = wm_keymap_item_copy(kmdi->add_item);
 149         if (kmdi->remove_item)
 150                 kmdin->remove_item = wm_keymap_item_copy(kmdi->remove_item);
 151
 152         return kmdin;
 153 }
 154
 155 static void wm_keymap_diff_item_free(wmKeyMapDiffItem *kmdi)
 156 {
 157         if (kmdi->remove_item) {
 158                 wm_keymap_item_free(kmdi->remove_item);
 159                 MEM_freeN(kmdi->remove_item);
 160         }
 161         if (kmdi->add_item) {
 162                 wm_keymap_item_free(kmdi->add_item);
 163                 MEM_freeN(kmdi->add_item);
 164         }
 165 }
 166
 167 /***************************** Key Configuration ******************************
 168  * List of keymaps for all editors, modes, ... . There is a builtin default key
 169  * configuration, a user key configuration, and other preset configurations. */
 170
 171 wmKeyConfig *WM_keyconfig_new(wmWindowManager *wm, const char *idname)
 172 {
 173         wmKeyConfig *keyconf;
 174
 175         keyconf = MEM_callocN(sizeof(wmKeyConfig), "wmKeyConfig");
 176         BLI_strncpy(keyconf->idname, idname, sizeof(keyconf->idname));
 177         BLI_addtail(&wm->keyconfigs, keyconf);
 178
 179         return keyconf;
 180 }
 181
 182 wmKeyConfig *WM_keyconfig_new_user(wmWindowManager *wm, const char *idname)
 183 {
 184         wmKeyConfig *keyconf = WM_keyconfig_new(wm, idname);
 185
 186         keyconf->flag |= KEYCONF_USER;
 187
 188         return keyconf;
 189 }
 190
 191 void WM_keyconfig_remove(wmWindowManager *wm, wmKeyConfig *keyconf)
 192 {
 193         if (keyconf) {
 194                 if (strncmp(U.keyconfigstr, keyconf->idname, sizeof(U.keyconfigstr)) == 0) {
 195                         BLI_strncpy(U.keyconfigstr, wm->defaultconf->idname, sizeof(U.keyconfigstr));
 196                         WM_keyconfig_update_tag(NULL, NULL);
 197                 }
 198
 199                 BLI_remlink(&wm->keyconfigs, keyconf);
 200                 WM_keyconfig_free(keyconf);
 201         }
 202 }
 203
 204 void WM_keyconfig_free(wmKeyConfig *keyconf)
 205 {
 206         wmKeyMap *km;
 207
 208         while ((km = keyconf->keymaps.first)) {
 209                 WM_keymap_free(km);
 210                 BLI_freelinkN(&keyconf->keymaps, km);
 211         }
 212
 213         MEM_freeN(keyconf);
 214 }
 215
 216 static wmKeyConfig *wm_keyconfig_list_find(ListBase *lb, char *idname)
 217 {
 218         wmKeyConfig *kc;
 219
 220         for (kc = lb->first; kc; kc = kc->next)
 221                 if (0 == strncmp(idname, kc->idname, KMAP_MAX_NAME))
 222                         return kc;
 223
 224         return NULL;
 225 }
 226
 227 static wmKeyConfig *WM_keyconfig_active(wmWindowManager *wm)
 228 {
 229         wmKeyConfig *keyconf;
 230
 231         /* first try from preset */
 232         keyconf = wm_keyconfig_list_find(&wm->keyconfigs, U.keyconfigstr);
 233         if (keyconf)
 234                 return keyconf;
 235
 236         /* otherwise use default */
 237         return wm->defaultconf;
 238 }
 239
 240 void WM_keyconfig_set_active(wmWindowManager *wm, const char *idname)
 241 {
 242         /* setting a different key configuration as active: we ensure all is
 243          * updated properly before and after making the change */
 244
 245         WM_keyconfig_update(wm);
 246
 247         BLI_strncpy(U.keyconfigstr, idname, sizeof(U.keyconfigstr));
 248
 249         WM_keyconfig_update_tag(NULL, NULL);
 250         WM_keyconfig_update(wm);
 251 }
 252
 253 /********************************** Keymap *************************************
 254  * List of keymap items for one editor, mode, modal operator, ... */
 255
 256 static wmKeyMap *wm_keymap_new(const char *idname, int spaceid, int regionid)
 257 {
 258         wmKeyMap *km = MEM_callocN(sizeof(struct wmKeyMap), "keymap list");
 259
 260         BLI_strncpy(km->idname, idname, KMAP_MAX_NAME);
 261         km->spaceid = spaceid;
 262         km->regionid = regionid;
 263
 264         return km;
 265 }
 266
 267 static wmKeyMap *wm_keymap_copy(wmKeyMap *keymap)
 268 {
 269         wmKeyMap *keymapn = MEM_dupallocN(keymap);
 270         wmKeyMapItem *kmi, *kmin;
 271         wmKeyMapDiffItem *kmdi, *kmdin;
 272
 273         keymapn->modal_items = keymap->modal_items;
 274         keymapn->poll = keymap->poll;
 275         keymapn->items.first = keymapn->items.last = NULL;
 276         keymapn->flag &= ~(KEYMAP_UPDATE | KEYMAP_EXPANDED);
 277
 278         for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) {
 279                 kmdin = wm_keymap_diff_item_copy(kmdi);
 280                 BLI_addtail(&keymapn->items, kmdin);
 281         }
 282
 283         for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
 284                 kmin = wm_keymap_item_copy(kmi);
 285                 BLI_addtail(&keymapn->items, kmin);
 286         }
 287
 288         return keymapn;
 289 }
 290
 291 void WM_keymap_free(wmKeyMap *keymap)
 292 {
 293         wmKeyMapItem *kmi;
 294         wmKeyMapDiffItem *kmdi;
 295
 296         for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next)
 297                 wm_keymap_diff_item_free(kmdi);
 298
 299         for (kmi = keymap->items.first; kmi; kmi = kmi->next)
 300                 wm_keymap_item_free(kmi);
 301
 302         BLI_freelistN(&keymap->diff_items);
 303         BLI_freelistN(&keymap->items);
 304 }
 305
 306 static void keymap_event_set(wmKeyMapItem *kmi, short type, short val, int modifier, short keymodifier)
 307 {
 308         kmi->type = type;
 309         kmi->val = val;
 310         kmi->keymodifier = keymodifier;
 311
 312         if (modifier == KM_ANY) {
 313                 kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY;
 314         }
 315         else {
 316                 kmi->shift = (modifier & KM_SHIFT) ? KM_MOD_FIRST : ((modifier & KM_SHIFT2) ? KM_MOD_SECOND : FALSE);
 317                 kmi->ctrl =  (modifier & KM_CTRL)  ? KM_MOD_FIRST : ((modifier & KM_CTRL2)  ? KM_MOD_SECOND : FALSE);
 318                 kmi->alt =   (modifier & KM_ALT)   ? KM_MOD_FIRST : ((modifier & KM_ALT2)   ? KM_MOD_SECOND : FALSE);
 319                 kmi->oskey = (modifier & KM_OSKEY) ? KM_MOD_FIRST : ((modifier & KM_OSKEY2) ? KM_MOD_SECOND : FALSE);
 320         }
 321 }
 322
 323 static void keymap_item_set_id(wmKeyMap *keymap, wmKeyMapItem *kmi)
 324 {
 325         keymap->kmi_id++;
 326         if ((keymap->flag & KEYMAP_USER) == 0) {
 327                 kmi->id = keymap->kmi_id;
 328         }
 329         else {
 330                 kmi->id = -keymap->kmi_id; // User defined keymap entries have negative ids
 331         }
 332 }
 333
 334 /* if item was added, then bail out */
 335 wmKeyMapItem *WM_keymap_verify_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
 336 {
 337         wmKeyMapItem *kmi;
 338
 339         for (kmi = keymap->items.first; kmi; kmi = kmi->next)
 340                 if (strncmp(kmi->idname, idname, OP_MAX_TYPENAME) == 0)
 341                         break;
 342         if (kmi == NULL) {
 343                 kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 344
 345                 BLI_addtail(&keymap->items, kmi);
 346                 BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
 347
 348                 keymap_item_set_id(keymap, kmi);
 349
 350                 keymap_event_set(kmi, type, val, modifier, keymodifier);
 351                 wm_keymap_item_properties_set(kmi);
 352         }
 353         return kmi;
 354 }
 355
 356 /* always add item */
 357 wmKeyMapItem *WM_keymap_add_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
 358 {
 359         wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 360
 361         BLI_addtail(&keymap->items, kmi);
 362         BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
 363
 364         keymap_event_set(kmi, type, val, modifier, keymodifier);
 365         wm_keymap_item_properties_set(kmi);
 366
 367         keymap_item_set_id(keymap, kmi);
 368
 369         WM_keyconfig_update_tag(keymap, kmi);
 370
 371         return kmi;
 372 }
 373
 374 /* menu wrapper for WM_keymap_add_item */
 375 wmKeyMapItem *WM_keymap_add_menu(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
 376 {
 377         wmKeyMapItem *kmi = WM_keymap_add_item(keymap, "WM_OT_call_menu", type, val, modifier, keymodifier);
 378         RNA_string_set(kmi->ptr, "name", idname);
 379         return kmi;
 380 }
 381
 382 void WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi)
 383 {
 384         if (BLI_findindex(&keymap->items, kmi) != -1) {
 385                 if (kmi->ptr) {
 386                         WM_operator_properties_free(kmi->ptr);
 387                         MEM_freeN(kmi->ptr);
 388                 }
 389                 BLI_freelinkN(&keymap->items, kmi);
 390
 391                 WM_keyconfig_update_tag(keymap, kmi);
 392         }
 393 }
 394
 395 /************************** Keymap Diff and Patch ****************************
 396  * Rather than saving the entire keymap for user preferences, we only save a
 397  * diff so that changes in the defaults get synced. This system is not perfect
 398  * but works better than overriding the keymap entirely when only few items
 399  * are changed. */
 400
 401 static void wm_keymap_addon_add(wmKeyMap *keymap, wmKeyMap *addonmap)
 402 {
 403         wmKeyMapItem *kmi, *kmin;
 404
 405         for (kmi = addonmap->items.first; kmi; kmi = kmi->next) {
 406                 kmin = wm_keymap_item_copy(kmi);
 407                 keymap_item_set_id(keymap, kmin);
 408                 BLI_addhead(&keymap->items, kmin);
 409         }
 410 }
 411
 412 static wmKeyMapItem *wm_keymap_find_item_equals(wmKeyMap *km, wmKeyMapItem *needle)
 413 {
 414         wmKeyMapItem *kmi;
 415
 416         for (kmi = km->items.first; kmi; kmi = kmi->next)
 417                 if (wm_keymap_item_equals(kmi, needle))
 418                         return kmi;
 419
 420         return NULL;
 421 }
 422
 423 static wmKeyMapItem *wm_keymap_find_item_equals_result(wmKeyMap *km, wmKeyMapItem *needle)
 424 {
 425         wmKeyMapItem *kmi;
 426
 427         for (kmi = km->items.first; kmi; kmi = kmi->next)
 428                 if (wm_keymap_item_equals_result(kmi, needle))
 429                         return kmi;
 430
 431         return NULL;
 432 }
 433
 434 static void wm_keymap_diff(wmKeyMap *diff_km, wmKeyMap *from_km, wmKeyMap *to_km, wmKeyMap *orig_km, wmKeyMap *addon_km)
 435 {
 436         wmKeyMapItem *kmi, *to_kmi, *orig_kmi;
 437         wmKeyMapDiffItem *kmdi;
 438
 439         for (kmi = from_km->items.first; kmi; kmi = kmi->next) {
 440                 to_kmi = WM_keymap_item_find_id(to_km, kmi->id);
 441
 442                 if (!to_kmi) {
 443                         /* remove item */
 444                         kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
 445                         kmdi->remove_item = wm_keymap_item_copy(kmi);
 446                         BLI_addtail(&diff_km->diff_items, kmdi);
 447                 }
 448                 else if (to_kmi && !wm_keymap_item_equals(kmi, to_kmi)) {
 449                         /* replace item */
 450                         kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
 451                         kmdi->remove_item = wm_keymap_item_copy(kmi);
 452                         kmdi->add_item = wm_keymap_item_copy(to_kmi);
 453                         BLI_addtail(&diff_km->diff_items, kmdi);
 454                 }
 455
 456                 /* sync expanded flag back to original so we don't loose it on repatch */
 457                 if (to_kmi) {
 458                         orig_kmi = WM_keymap_item_find_id(orig_km, kmi->id);
 459
 460                         if (!orig_kmi)
 461                                 orig_kmi = wm_keymap_find_item_equals(addon_km, kmi);
 462
 463                         if (orig_kmi) {
 464                                 orig_kmi->flag &= ~KMI_EXPANDED;
 465                                 orig_kmi->flag |= (to_kmi->flag & KMI_EXPANDED);
 466                         }
 467                 }
 468         }
 469
 470         for (kmi = to_km->items.first; kmi; kmi = kmi->next) {
 471                 if (kmi->id < 0) {
 472                         /* add item */
 473                         kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
 474                         kmdi->add_item = wm_keymap_item_copy(kmi);
 475                         BLI_addtail(&diff_km->diff_items, kmdi);
 476                 }
 477         }
 478 }
 479
 480 static void wm_keymap_patch(wmKeyMap *km, wmKeyMap *diff_km)
 481 {
 482         wmKeyMapDiffItem *kmdi;
 483         wmKeyMapItem *kmi_remove, *kmi_add;
 484
 485         for (kmdi = diff_km->diff_items.first; kmdi; kmdi = kmdi->next) {
 486                 /* find item to remove */
 487                 kmi_remove = NULL;
 488                 if (kmdi->remove_item) {
 489                         kmi_remove = wm_keymap_find_item_equals(km, kmdi->remove_item);
 490                         if (!kmi_remove)
 491                                 kmi_remove = wm_keymap_find_item_equals_result(km, kmdi->remove_item);
 492                 }
 493
 494                 /* add item */
 495                 if (kmdi->add_item) {
 496                         /* only if nothing to remove or item to remove found */
 497                         if (!kmdi->remove_item || kmi_remove) {
 498                                 kmi_add = wm_keymap_item_copy(kmdi->add_item);
 499                                 kmi_add->flag |= KMI_USER_MODIFIED;
 500
 501                                 if (kmi_remove) {
 502                                         kmi_add->flag &= ~KMI_EXPANDED;
 503                                         kmi_add->flag |= (kmi_remove->flag & KMI_EXPANDED);
 504                                         kmi_add->id = kmi_remove->id;
 505                                         BLI_insertlinkbefore(&km->items, kmi_remove, kmi_add);
 506                                 }
 507                                 else {
 508                                         keymap_item_set_id(km, kmi_add);
 509                                         BLI_addtail(&km->items, kmi_add);
 510                                 }
 511                         }
 512                 }
 513
 514                 /* remove item */
 515                 if (kmi_remove) {
 516                         wm_keymap_item_free(kmi_remove);
 517                         BLI_freelinkN(&km->items, kmi_remove);
 518                 }
 519         }
 520 }
 521
 522 static wmKeyMap *wm_keymap_patch_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *usermap)
 523 {
 524         wmKeyMap *km;
 525         int expanded = 0;
 526
 527         /* remove previous keymap in list, we will replace it */
 528         km = WM_keymap_list_find(lb, defaultmap->idname, defaultmap->spaceid, defaultmap->regionid);
 529         if (km) {
 530                 expanded = (km->flag & (KEYMAP_EXPANDED | KEYMAP_CHILDREN_EXPANDED));
 531                 WM_keymap_free(km);
 532                 BLI_freelinkN(lb, km);
 533         }
 534
 535         /* copy new keymap from an existing one */
 536         if (usermap && !(usermap->flag & KEYMAP_DIFF)) {
 537                 /* for compatibiltiy with old user preferences with non-diff
 538                  * keymaps we override the original entirely */
 539                 wmKeyMapItem *kmi, *orig_kmi;
 540
 541                 km = wm_keymap_copy(usermap);
 542
 543                 /* try to find corresponding id's for items */
 544                 for (kmi = km->items.first; kmi; kmi = kmi->next) {
 545                         orig_kmi = wm_keymap_find_item_equals(defaultmap, kmi);
 546                         if (!orig_kmi)
 547                                 orig_kmi = wm_keymap_find_item_equals_result(defaultmap, kmi);
 548
 549                         if (orig_kmi)
 550                                 kmi->id = orig_kmi->id;
 551                         else
 552                                 kmi->id = -(km->kmi_id++);
 553                 }
 554
 555                 km->flag |= KEYMAP_UPDATE; /* update again to create diff */
 556         }
 557         else
 558                 km = wm_keymap_copy(defaultmap);
 559
 560         /* add addon keymap items */
 561         if (addonmap)
 562                 wm_keymap_addon_add(km, addonmap);
 563
 564         /* tag as being user edited */
 565         if (usermap)
 566                 km->flag |= KEYMAP_USER_MODIFIED;
 567         km->flag |= KEYMAP_USER | expanded;
 568
 569         /* apply user changes of diff keymap */
 570         if (usermap && (usermap->flag & KEYMAP_DIFF))
 571                 wm_keymap_patch(km, usermap);
 572
 573         /* add to list */
 574         BLI_addtail(lb, km);
 575
 576         return km;
 577 }
 578
 579 static void wm_keymap_diff_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *km)
 580 {
 581         wmKeyMap *diffmap, *prevmap, *origmap;
 582
 583         /* create temporary default + addon keymap for diff */
 584         origmap = defaultmap;
 585
 586         if (addonmap) {
 587                 defaultmap = wm_keymap_copy(defaultmap);
 588                 wm_keymap_addon_add(defaultmap, addonmap);
 589         }
 590
 591         /* remove previous diff keymap in list, we will replace it */
 592         prevmap = WM_keymap_list_find(lb, km->idname, km->spaceid, km->regionid);
 593         if (prevmap) {
 594                 WM_keymap_free(prevmap);
 595                 BLI_freelinkN(lb, prevmap);
 596         }
 597
 598         /* create diff keymap */
 599         diffmap = wm_keymap_new(km->idname, km->spaceid, km->regionid);
 600         diffmap->flag |= KEYMAP_DIFF;
 601         if (defaultmap->flag & KEYMAP_MODAL)
 602                 diffmap->flag |= KEYMAP_MODAL;
 603         wm_keymap_diff(diffmap, defaultmap, km, origmap, addonmap);
 604
 605         /* add to list if not empty */
 606         if (diffmap->diff_items.first) {
 607                 BLI_addtail(lb, diffmap);
 608         }
 609         else {
 610                 WM_keymap_free(diffmap);
 611                 MEM_freeN(diffmap);
 612         }
 613
 614         /* free temporary default map */
 615         if (addonmap) {
 616                 WM_keymap_free(defaultmap);
 617                 MEM_freeN(defaultmap);
 618         }
 619 }
 620
 621 /* ****************** storage in WM ************ */
 622
 623 /* name id's are for storing general or multiple keymaps,
 624  * space/region ids are same as DNA_space_types.h */
 625 /* gets freed in wm.c */
 626
 627 wmKeyMap *WM_keymap_list_find(ListBase *lb, const char *idname, int spaceid, int regionid)
 628 {
 629         wmKeyMap *km;
 630
 631         for (km = lb->first; km; km = km->next)
 632                 if (km->spaceid == spaceid && km->regionid == regionid)
 633                         if (0 == strncmp(idname, km->idname, KMAP_MAX_NAME))
 634                                 return km;
 635
 636         return NULL;
 637 }
 638
 639 wmKeyMap *WM_keymap_find(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
 640 {
 641         wmKeyMap *km = WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
 642
 643         if (km == NULL) {
 644                 km = wm_keymap_new(idname, spaceid, regionid);
 645                 BLI_addtail(&keyconf->keymaps, km);
 646
 647                 WM_keyconfig_update_tag(km, NULL);
 648         }
 649
 650         return km;
 651 }
 652
 653 wmKeyMap *WM_keymap_find_all(const bContext *C, const char *idname, int spaceid, int regionid)
 654 {
 655         wmWindowManager *wm = CTX_wm_manager(C);
 656
 657         return WM_keymap_list_find(&wm->userconf->keymaps, idname, spaceid, regionid);
 658 }
 659
 660 /* ****************** modal keymaps ************ */
 661
 662 /* modal maps get linked to a running operator, and filter the keys before sending to modal() callback */
 663
 664 wmKeyMap *WM_modalkeymap_add(wmKeyConfig *keyconf, const char *idname, EnumPropertyItem *items)
 665 {
 666         wmKeyMap *km = WM_keymap_find(keyconf, idname, 0, 0);
 667         km->flag |= KEYMAP_MODAL;
 668         km->modal_items = items;
 669
 670         if (!items) {
 671                 /* init modal items from default config */
 672                 wmWindowManager *wm = G.main->wm.first;
 673                 wmKeyMap *defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
 674
 675                 if (defaultkm) {
 676                         km->modal_items = defaultkm->modal_items;
 677                         km->poll = defaultkm->poll;
 678                 }
 679         }
 680
 681         return km;
 682 }
 683
 684 wmKeyMap *WM_modalkeymap_get(wmKeyConfig *keyconf, const char *idname)
 685 {
 686         wmKeyMap *km;
 687
 688         for (km = keyconf->keymaps.first; km; km = km->next)
 689                 if (km->flag & KEYMAP_MODAL)
 690                         if (0 == strncmp(idname, km->idname, KMAP_MAX_NAME))
 691                                 break;
 692
 693         return km;
 694 }
 695
 696
 697 wmKeyMapItem *WM_modalkeymap_add_item(wmKeyMap *km, int type, int val, int modifier, int keymodifier, int value)
 698 {
 699         wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 700
 701         BLI_addtail(&km->items, kmi);
 702         kmi->propvalue = value;
 703
 704         keymap_event_set(kmi, type, val, modifier, keymodifier);
 705
 706         keymap_item_set_id(km, kmi);
 707
 708         WM_keyconfig_update_tag(km, kmi);
 709
 710         return kmi;
 711 }
 712
 713 wmKeyMapItem *WM_modalkeymap_add_item_str(wmKeyMap *km, int type, int val, int modifier, int keymodifier, const char *value)
 714 {
 715         wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 716
 717         BLI_addtail(&km->items, kmi);
 718         BLI_strncpy(kmi->propvalue_str, value, sizeof(kmi->propvalue_str));
 719
 720         keymap_event_set(kmi, type, val, modifier, keymodifier);
 721
 722         keymap_item_set_id(km, kmi);
 723
 724         WM_keyconfig_update_tag(km, kmi);
 725
 726         return kmi;
 727 }
 728
 729 void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
 730 {
 731         wmOperatorType *ot = WM_operatortype_find(opname, 0);
 732
 733         if (ot)
 734                 ot->modalkeymap = km;
 735         else
 736                 printf("error: modalkeymap_assign, unknown operator %s\n", opname);
 737 }
 738
 739 static void wm_user_modal_keymap_set_items(wmWindowManager *wm, wmKeyMap *km)
 740 {
 741         /* here we convert propvalue string values delayed, due to python keymaps
 742          * being created before the actual modal keymaps, so no modal_items */
 743         wmKeyMap *defaultkm;
 744         wmKeyMapItem *kmi;
 745         int propvalue;
 746
 747         if (km && (km->flag & KEYMAP_MODAL) && !km->modal_items) {
 748                 defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
 749
 750                 if (!defaultkm)
 751                         return;
 752
 753                 km->modal_items = defaultkm->modal_items;
 754                 km->poll = defaultkm->poll;
 755
 756                 for (kmi = km->items.first; kmi; kmi = kmi->next) {
 757                         if (kmi->propvalue_str[0]) {
 758                                 if (RNA_enum_value_from_id(km->modal_items, kmi->propvalue_str, &propvalue))
 759                                         kmi->propvalue = propvalue;
 760                                 kmi->propvalue_str[0] = '\0';
 761                         }
 762                 }
 763         }
 764 }
 765
 766 /* ***************** get string from key events **************** */
 767
 768 const char *WM_key_event_string(short type)
 769 {
 770         const char *name = NULL;
 771         if (RNA_enum_name(event_type_items, (int)type, &name))
 772                 return name;
 773
 774         return "";
 775 }
 776
 777 char *WM_keymap_item_to_string(wmKeyMapItem *kmi, char *str, int len)
 778 {
 779         char buf[128];
 780
 781         buf[0] = 0;
 782
 783         if (kmi->shift == KM_ANY &&
 784             kmi->ctrl == KM_ANY &&
 785             kmi->alt == KM_ANY &&
 786             kmi->oskey == KM_ANY) {
 787
 788                 strcat(buf, "Any ");
 789         }
 790         else {
 791                 if (kmi->shift)
 792                         strcat(buf, "Shift ");
 793
 794                 if (kmi->ctrl)
 795                         strcat(buf, "Ctrl ");
 796
 797                 if (kmi->alt)
 798                         strcat(buf, "Alt ");
 799
 800                 if (kmi->oskey)
 801                         strcat(buf, "Cmd ");
 802         }
 803
 804         if (kmi->keymodifier) {
 805                 strcat(buf, WM_key_event_string(kmi->keymodifier));
 806                 strcat(buf, " ");
 807         }
 808
 809         strcat(buf, WM_key_event_string(kmi->type));
 810         BLI_strncpy(str, buf, len);
 811
 812         return str;
 813 }
 814
 815 static wmKeyMapItem *wm_keymap_item_find_handlers(
 816     const bContext *C, ListBase *handlers, const char *opname, int UNUSED(opcontext),
 817     IDProperty *properties, int compare_props, int hotkey, wmKeyMap **keymap_r)
 818 {
 819         wmWindowManager *wm = CTX_wm_manager(C);
 820         wmEventHandler *handler;
 821         wmKeyMap *keymap;
 822         wmKeyMapItem *kmi;
 823
 824         /* find keymap item in handlers */
 825         for (handler = handlers->first; handler; handler = handler->next) {
 826                 keymap = WM_keymap_active(wm, handler->keymap);
 827
 828                 if (keymap && (!keymap->poll || keymap->poll((bContext *)C))) {
 829                         for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
 830
 831                                 if (strcmp(kmi->idname, opname) == 0 && WM_key_event_string(kmi->type)[0]) {
 832                                         if (hotkey)
 833                                                 if (!ISHOTKEY(kmi->type))
 834                                                         continue;
 835
 836                                         if (compare_props) {
 837                                                 if (kmi->ptr && IDP_EqualsProperties(properties, kmi->ptr->data)) {
 838                                                         if (keymap_r) *keymap_r = keymap;
 839                                                         return kmi;
 840                                                 }
 841                                         }
 842                                         else {
 843                                                 if (keymap_r) *keymap_r = keymap;
 844                                                 return kmi;
 845                                         }
 846                                 }
 847                         }
 848                 }
 849         }
 850
 851         /* ensure un-initialized keymap is never used */
 852         if (keymap_r) *keymap_r = NULL;
 853         return NULL;
 854 }
 855
 856 static wmKeyMapItem *wm_keymap_item_find_props(
 857     const bContext *C, const char *opname, int opcontext,
 858     IDProperty *properties, int compare_props, int hotkey, wmKeyMap **keymap_r)
 859 {
 860         wmWindow *win = CTX_wm_window(C);
 861         ScrArea *sa = CTX_wm_area(C);
 862         ARegion *ar = CTX_wm_region(C);
 863         wmKeyMapItem *found = NULL;
 864
 865         /* look into multiple handler lists to find the item */
 866         if (win)
 867                 found = wm_keymap_item_find_handlers(C, &win->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 868
 869
 870         if (sa && found == NULL)
 871                 found = wm_keymap_item_find_handlers(C, &sa->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 872
 873         if (found == NULL) {
 874                 if (ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) {
 875                         if (sa) {
 876                                 if (!(ar && ar->regiontype == RGN_TYPE_WINDOW))
 877                                         ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
 878
 879                                 if (ar)
 880                                         found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 881                         }
 882                 }
 883                 else if (ELEM(opcontext, WM_OP_EXEC_REGION_CHANNELS, WM_OP_INVOKE_REGION_CHANNELS)) {
 884                         if (!(ar && ar->regiontype == RGN_TYPE_CHANNELS))
 885                                 ar = BKE_area_find_region_type(sa, RGN_TYPE_CHANNELS);
 886
 887                         if (ar)
 888                                 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 889                 }
 890                 else if (ELEM(opcontext, WM_OP_EXEC_REGION_PREVIEW, WM_OP_INVOKE_REGION_PREVIEW)) {
 891                         if (!(ar && ar->regiontype == RGN_TYPE_PREVIEW))
 892                                 ar = BKE_area_find_region_type(sa, RGN_TYPE_PREVIEW);
 893
 894                         if (ar)
 895                                 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 896                 }
 897                 else {
 898                         if (ar)
 899                                 found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, compare_props, hotkey, keymap_r);
 900                 }
 901         }
 902
 903         return found;
 904 }
 905
 906 static wmKeyMapItem *wm_keymap_item_find(
 907     const bContext *C, const char *opname, int opcontext,
 908     IDProperty *properties, const short hotkey, const short sloppy, wmKeyMap **keymap_r)
 909 {
 910         wmKeyMapItem *found = wm_keymap_item_find_props(C, opname, opcontext, properties, 1, hotkey, keymap_r);
 911
 912         if (!found && sloppy)
 913                 found = wm_keymap_item_find_props(C, opname, opcontext, NULL, 0, hotkey, keymap_r);
 914
 915         return found;
 916 }
 917
 918 char *WM_key_event_operator_string(
 919     const bContext *C, const char *opname, int opcontext,
 920     IDProperty *properties, const short sloppy, char *str, int len)
 921 {
 922         wmKeyMapItem *kmi = wm_keymap_item_find(C, opname, opcontext, properties, 0, sloppy, NULL);
 923
 924         if (kmi) {
 925                 WM_keymap_item_to_string(kmi, str, len);
 926                 return str;
 927         }
 928
 929         return NULL;
 930 }
 931
 932 int WM_key_event_operator_id(
 933     const bContext *C, const char *opname, int opcontext,
 934     IDProperty *properties, int hotkey, wmKeyMap **keymap_r)
 935 {
 936         wmKeyMapItem *kmi = wm_keymap_item_find(C, opname, opcontext, properties, hotkey, TRUE, keymap_r);
 937
 938         if (kmi)
 939                 return kmi->id;
 940         else
 941                 return 0;
 942 }
 943
 944 int WM_keymap_item_compare(wmKeyMapItem *k1, wmKeyMapItem *k2)
 945 {
 946         int k1type, k2type;
 947
 948         if (k1->flag & KMI_INACTIVE || k2->flag & KMI_INACTIVE)
 949                 return 0;
 950
 951         /* take event mapping into account */
 952         k1type = WM_userdef_event_map(k1->type);
 953         k2type = WM_userdef_event_map(k2->type);
 954
 955         if (k1type != KM_ANY && k2type != KM_ANY && k1type != k2type)
 956                 return 0;
 957
 958         if (k1->val != KM_ANY && k2->val != KM_ANY) {
 959                 /* take click, press, release conflict into account */
 960                 if (k1->val == KM_CLICK && ELEM3(k2->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0)
 961                         return 0;
 962                 if (k2->val == KM_CLICK && ELEM3(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0)
 963                         return 0;
 964                 if (k1->val != k2->val)
 965                         return 0;
 966         }
 967
 968         if (k1->shift != KM_ANY && k2->shift != KM_ANY && k1->shift != k2->shift)
 969                 return 0;
 970
 971         if (k1->ctrl != KM_ANY && k2->ctrl != KM_ANY && k1->ctrl != k2->ctrl)
 972                 return 0;
 973
 974         if (k1->alt != KM_ANY && k2->alt != KM_ANY && k1->alt != k2->alt)
 975                 return 0;
 976
 977         if (k1->oskey != KM_ANY && k2->oskey != KM_ANY && k1->oskey != k2->oskey)
 978                 return 0;
 979
 980         if (k1->keymodifier != k2->keymodifier)
 981                 return 0;
 982
 983         return 1;
 984 }
 985
 986 /************************* Update Final Configuration *************************
 987  * On load or other changes, the final user key configuration is rebuilt from
 988  * the preset, addon and user preferences keymaps. We also test if the final
 989  * configuration changed and write the changes to the user preferences. */
 990
 991 static int WM_KEYMAP_UPDATE = 0;
 992
 993 void WM_keyconfig_update_tag(wmKeyMap *km, wmKeyMapItem *kmi)
 994 {
 995         /* quick tag to do delayed keymap updates */
 996         WM_KEYMAP_UPDATE = 1;
 997
 998         if (km)
 999                 km->flag |= KEYMAP_UPDATE;
1000         if (kmi)
1001                 kmi->flag |= KMI_UPDATE;
1002 }
1003
1004 static int wm_keymap_test_and_clear_update(wmKeyMap *km)
1005 {
1006         wmKeyMapItem *kmi;
1007         int update;
1008
1009         update = (km->flag & KEYMAP_UPDATE);
1010         km->flag &= ~KEYMAP_UPDATE;
1011
1012         for (kmi = km->items.first; kmi; kmi = kmi->next) {
1013                 update = update || (kmi->flag & KMI_UPDATE);
1014                 kmi->flag &= ~KMI_UPDATE;
1015         }
1016
1017         return update;
1018 }
1019
1020 static wmKeyMap *wm_keymap_preset(wmWindowManager *wm, wmKeyMap *km)
1021 {
1022         wmKeyConfig *keyconf = WM_keyconfig_active(wm);
1023         wmKeyMap *keymap;
1024
1025         keymap = WM_keymap_list_find(&keyconf->keymaps, km->idname, km->spaceid, km->regionid);
1026         if (!keymap)
1027                 keymap = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, km->spaceid, km->regionid);
1028
1029         return keymap;
1030 }
1031
1032 void WM_keyconfig_update(wmWindowManager *wm)
1033 {
1034         wmKeyMap *km, *defaultmap, *addonmap, *usermap, *kmn;
1035         wmKeyMapItem *kmi;
1036         wmKeyMapDiffItem *kmdi;
1037         int compat_update = 0;
1038
1039         if (G.background)
1040                 return;
1041         if (!WM_KEYMAP_UPDATE)
1042                 return;
1043
1044         /* update operator properties for non-modal user keymaps */
1045         for (km = U.user_keymaps.first; km; km = km->next) {
1046                 if ((km->flag & KEYMAP_MODAL) == 0) {
1047                         for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {
1048                                 if (kmdi->add_item)
1049                                         wm_keymap_item_properties_set(kmdi->add_item);
1050                                 if (kmdi->remove_item)
1051                                         wm_keymap_item_properties_set(kmdi->remove_item);
1052                         }
1053
1054                         for (kmi = km->items.first; kmi; kmi = kmi->next)
1055                                 wm_keymap_item_properties_set(kmi);
1056                 }
1057         }
1058
1059         /* update U.user_keymaps with user key configuration changes */
1060         for (km = wm->userconf->keymaps.first; km; km = km->next) {
1061                 /* only diff if the user keymap was modified */
1062                 if (wm_keymap_test_and_clear_update(km)) {
1063                         /* find keymaps */
1064                         defaultmap = wm_keymap_preset(wm, km);
1065                         addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
1066
1067                         /* diff */
1068                         if (defaultmap)
1069                                 wm_keymap_diff_update(&U.user_keymaps, defaultmap, addonmap, km);
1070                 }
1071         }
1072
1073         /* create user key configuration from preset + addon + user preferences */
1074         for (km = wm->defaultconf->keymaps.first; km; km = km->next) {
1075                 /* find keymaps */
1076                 defaultmap = wm_keymap_preset(wm, km);
1077                 addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
1078                 usermap = WM_keymap_list_find(&U.user_keymaps, km->idname, km->spaceid, km->regionid);
1079
1080                 wm_user_modal_keymap_set_items(wm, defaultmap);
1081
1082                 /* add */
1083                 kmn = wm_keymap_patch_update(&wm->userconf->keymaps, defaultmap, addonmap, usermap);
1084
1085                 if (kmn) {
1086                         kmn->modal_items = km->modal_items;
1087                         kmn->poll = km->poll;
1088                 }
1089
1090                 /* in case of old non-diff keymaps, force extra update to create diffs */
1091                 compat_update = compat_update || (usermap && !(usermap->flag & KEYMAP_DIFF));
1092         }
1093
1094         WM_KEYMAP_UPDATE = 0;
1095
1096         if (compat_update) {
1097                 WM_keyconfig_update_tag(NULL, NULL);
1098                 WM_keyconfig_update(wm);
1099         }
1100 }
1101
1102 /********************************* Event Handling *****************************
1103  * Handlers have pointers to the keymap in the default configuration. During
1104  * event handling this function is called to get the keymap from the final
1105  * configuration. */
1106
1107 wmKeyMap *WM_keymap_active(wmWindowManager *wm, wmKeyMap *keymap)
1108 {
1109         wmKeyMap *km;
1110
1111         if (!keymap)
1112                 return NULL;
1113
1114         /* first user defined keymaps */
1115         km = WM_keymap_list_find(&wm->userconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
1116
1117         if (km)
1118                 return km;
1119
1120         return keymap;
1121 }
1122
1123 /******************************* Keymap Editor ********************************
1124  * In the keymap editor the user key configuration is edited. */
1125
1126 void WM_keymap_restore_item_to_default(bContext *C, wmKeyMap *keymap, wmKeyMapItem *kmi)
1127 {
1128         wmWindowManager *wm = CTX_wm_manager(C);
1129         wmKeyMap *defaultmap, *addonmap;
1130         wmKeyMapItem *orig;
1131
1132         if (!keymap)
1133                 return;
1134
1135         /* construct default keymap from preset + addons */
1136         defaultmap = wm_keymap_preset(wm, keymap);
1137         addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
1138
1139         if (addonmap) {
1140                 defaultmap = wm_keymap_copy(defaultmap);
1141                 wm_keymap_addon_add(defaultmap, addonmap);
1142         }
1143
1144         /* find original item */
1145         orig = WM_keymap_item_find_id(defaultmap, kmi->id);
1146
1147         if (orig) {
1148                 /* restore to original */
1149                 if (strcmp(orig->idname, kmi->idname) != 0) {
1150                         BLI_strncpy(kmi->idname, orig->idname, sizeof(kmi->idname));
1151                         WM_keymap_properties_reset(kmi, NULL);
1152                 }
1153
1154                 if (orig->properties) {
1155                         if (kmi->properties) {
1156                                 IDP_FreeProperty(kmi->properties);
1157                                 MEM_freeN(kmi->properties);
1158                                 kmi->properties = NULL;
1159                         }
1160
1161                         kmi->properties = IDP_CopyProperty(orig->properties);
1162                         kmi->ptr->data = kmi->properties;
1163                 }
1164
1165                 kmi->propvalue = orig->propvalue;
1166                 kmi->type = orig->type;
1167                 kmi->val = orig->val;
1168                 kmi->shift = orig->shift;
1169                 kmi->ctrl = orig->ctrl;
1170                 kmi->alt = orig->alt;
1171                 kmi->oskey = orig->oskey;
1172                 kmi->keymodifier = orig->keymodifier;
1173                 kmi->maptype = orig->maptype;
1174
1175                 WM_keyconfig_update_tag(keymap, kmi);
1176         }
1177
1178         /* free temporary keymap */
1179         if (addonmap) {
1180                 WM_keymap_free(defaultmap);
1181                 MEM_freeN(defaultmap);
1182         }
1183 }
1184
1185 void WM_keymap_restore_to_default(wmKeyMap *keymap, bContext *C)
1186 {
1187         wmWindowManager *wm = CTX_wm_manager(C);
1188         wmKeyMap *usermap;
1189
1190         /* remove keymap from U.user_keymaps and update */
1191         usermap = WM_keymap_list_find(&U.user_keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
1192
1193         if (usermap) {
1194                 WM_keymap_free(usermap);
1195                 BLI_freelinkN(&U.user_keymaps, usermap);
1196
1197                 WM_keyconfig_update_tag(NULL, NULL);
1198                 WM_keyconfig_update(wm);
1199         }
1200 }
1201
1202 wmKeyMapItem *WM_keymap_item_find_id(wmKeyMap *keymap, int id)
1203 {
1204         wmKeyMapItem *kmi;
1205
1206         for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
1207                 if (kmi->id == id) {
1208                         return kmi;
1209                 }
1210         }
1211
1212         return NULL;
1213 }
1214
1215 /* Guess an appropriate keymap from the operator name */
1216 /* Needs to be kept up to date with Keymap and Operator naming */
1217 wmKeyMap *WM_keymap_guess_opname(const bContext *C, const char *opname)
1218 {
1219         wmKeyMap *km = NULL;
1220         SpaceLink *sl = CTX_wm_space_data(C);
1221
1222         /* Window */
1223         if (strstr(opname, "WM_OT")) {
1224                 km = WM_keymap_find_all(C, "Window", 0, 0);
1225         }
1226         /* Screen */
1227         else if (strstr(opname, "SCREEN_OT")) {
1228                 km = WM_keymap_find_all(C, "Screen", 0, 0);
1229         }
1230         /* Grease Pencil */
1231         else if (strstr(opname, "GPENCIL_OT")) {
1232                 km = WM_keymap_find_all(C, "Grease Pencil", 0, 0);
1233         }
1234         /* Markers */
1235         else if (strstr(opname, "MARKER_OT")) {
1236                 km = WM_keymap_find_all(C, "Markers", 0, 0);
1237         }
1238         /* Import/Export*/
1239         else if (strstr(opname, "IMPORT_") || strstr(opname, "EXPORT_")) {
1240                 km = WM_keymap_find_all(C, "Window", 0, 0);
1241         }
1242
1243
1244         /* 3D View */
1245         else if (strstr(opname, "VIEW3D_OT")) {
1246                 km = WM_keymap_find_all(C, "3D View", sl->spacetype, 0);
1247         }
1248         else if (strstr(opname, "OBJECT_OT")) {
1249                 km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1250         }
1251
1252
1253         /* Editing Modes */
1254         else if (strstr(opname, "MESH_OT")) {
1255                 km = WM_keymap_find_all(C, "Mesh", 0, 0);
1256
1257                 /* some mesh operators are active in object mode too, like add-prim */
1258                 if (km && km->poll && km->poll((bContext *)C) == 0) {
1259                         km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1260                 }
1261         }
1262         else if (strstr(opname, "CURVE_OT")) {
1263                 km = WM_keymap_find_all(C, "Curve", 0, 0);
1264
1265                 /* some curve operators are active in object mode too, like add-prim */
1266                 if (km && km->poll && km->poll((bContext *)C) == 0) {
1267                         km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1268                 }
1269         }
1270         else if (strstr(opname, "ARMATURE_OT")) {
1271                 km = WM_keymap_find_all(C, "Armature", 0, 0);
1272         }
1273         else if (strstr(opname, "POSE_OT")) {
1274                 km = WM_keymap_find_all(C, "Pose", 0, 0);
1275         }
1276         else if (strstr(opname, "SCULPT_OT")) {
1277                 switch (CTX_data_mode_enum(C)) {
1278                         case OB_MODE_SCULPT:
1279                                 km = WM_keymap_find_all(C, "Sculpt", 0, 0);
1280                                 break;
1281                         case OB_MODE_EDIT:
1282                                 km = WM_keymap_find_all(C, "UV Sculpt", 0, 0);
1283                                 break;
1284                 }
1285         }
1286         else if (strstr(opname, "MBALL_OT")) {
1287                 km = WM_keymap_find_all(C, "Metaball", 0, 0);
1288
1289                 /* some mball operators are active in object mode too, like add-prim */
1290                 if (km && km->poll && km->poll((bContext *)C) == 0) {
1291                         km = WM_keymap_find_all(C, "Object Mode", 0, 0);
1292                 }
1293         }
1294         else if (strstr(opname, "LATTICE_OT")) {
1295                 km = WM_keymap_find_all(C, "Lattice", 0, 0);
1296         }
1297         else if (strstr(opname, "PARTICLE_OT")) {
1298                 km = WM_keymap_find_all(C, "Particle", 0, 0);
1299         }
1300         else if (strstr(opname, "FONT_OT")) {
1301                 km = WM_keymap_find_all(C, "Font", 0, 0);
1302         }
1303         else if (strstr(opname, "PAINT_OT")) {
1304
1305                 /* check for relevant mode */
1306                 switch (CTX_data_mode_enum(C)) {
1307                         case OB_MODE_WEIGHT_PAINT:
1308                                 km = WM_keymap_find_all(C, "Weight Paint", 0, 0);
1309                                 break;
1310                         case OB_MODE_VERTEX_PAINT:
1311                                 km = WM_keymap_find_all(C, "Vertex Paint", 0, 0);
1312                                 break;
1313                         case OB_MODE_TEXTURE_PAINT:
1314                                 km = WM_keymap_find_all(C, "Image Paint", 0, 0);
1315                                 break;
1316                 }
1317         }
1318         /* Paint Face Mask */
1319         else if (strstr(opname, "PAINT_OT_face_select")) {
1320                 km = WM_keymap_find_all(C, "Face Mask", sl->spacetype, 0);
1321         }
1322         /* Timeline */
1323         else if (strstr(opname, "TIME_OT")) {
1324                 km = WM_keymap_find_all(C, "Timeline", sl->spacetype, 0);
1325         }
1326         /* Image Editor */
1327         else if (strstr(opname, "IMAGE_OT")) {
1328                 km = WM_keymap_find_all(C, "Image", sl->spacetype, 0);
1329         }
1330         /* UV Editor */
1331         else if (strstr(opname, "UV_OT")) {
1332                 km = WM_keymap_find_all(C, "UV Editor", sl->spacetype, 0);
1333         }
1334         /* Node Editor */
1335         else if (strstr(opname, "NODE_OT")) {
1336                 km = WM_keymap_find_all(C, "Node Editor", sl->spacetype, 0);
1337         }
1338         /* Animation Editor Channels */
1339         else if (strstr(opname, "ANIM_OT_channels")) {
1340                 km = WM_keymap_find_all(C, "Animation Channels", sl->spacetype, 0);
1341         }
1342         /* Animation Generic - after channels */
1343         else if (strstr(opname, "ANIM_OT")) {
1344                 km = WM_keymap_find_all(C, "Animation", 0, 0);
1345         }
1346         /* Graph Editor */
1347         else if (strstr(opname, "GRAPH_OT")) {
1348                 km = WM_keymap_find_all(C, "Graph Editor", sl->spacetype, 0);
1349         }
1350         /* Dopesheet Editor */
1351         else if (strstr(opname, "ACTION_OT")) {
1352                 km = WM_keymap_find_all(C, "Dopesheet", sl->spacetype, 0);
1353         }
1354         /* NLA Editor */
1355         else if (strstr(opname, "NLA_OT")) {
1356                 km = WM_keymap_find_all(C, "NLA Editor", sl->spacetype, 0);
1357         }
1358         /* Script */
1359         else if (strstr(opname, "SCRIPT_OT")) {
1360                 km = WM_keymap_find_all(C, "Script", sl->spacetype, 0);
1361         }
1362         /* Text */
1363         else if (strstr(opname, "TEXT_OT")) {
1364                 km = WM_keymap_find_all(C, "Text", sl->spacetype, 0);
1365         }
1366         /* Sequencer */
1367         else if (strstr(opname, "SEQUENCER_OT")) {
1368                 km = WM_keymap_find_all(C, "Sequencer", sl->spacetype, 0);
1369         }
1370         /* Console */
1371         else if (strstr(opname, "CONSOLE_OT")) {
1372                 km = WM_keymap_find_all(C, "Console", sl->spacetype, 0);
1373         }
1374         /* Console */
1375         else if (strstr(opname, "INFO_OT")) {
1376                 km = WM_keymap_find_all(C, "Info", sl->spacetype, 0);
1377         }
1378
1379         /* Transform */
1380         else if (strstr(opname, "TRANSFORM_OT")) {
1381
1382                 /* check for relevant editor */
1383                 switch (sl->spacetype) {
1384                         case SPACE_VIEW3D:
1385                                 km = WM_keymap_find_all(C, "3D View", sl->spacetype, 0);
1386                                 break;
1387                         case SPACE_IPO:
1388                                 km = WM_keymap_find_all(C, "Graph Editor", sl->spacetype, 0);
1389                                 break;
1390                         case SPACE_ACTION:
1391                                 km = WM_keymap_find_all(C, "Dopesheet", sl->spacetype, 0);
1392                                 break;
1393                         case SPACE_NLA:
1394                                 km = WM_keymap_find_all(C, "NLA Editor", sl->spacetype, 0);
1395                                 break;
1396                         case SPACE_IMAGE:
1397                                 km = WM_keymap_find_all(C, "UV Editor", sl->spacetype, 0);
1398                                 break;
1399                         case SPACE_NODE:
1400                                 km = WM_keymap_find_all(C, "Node Editor", sl->spacetype, 0);
1401                                 break;
1402                         case SPACE_SEQ:
1403                                 km = WM_keymap_find_all(C, "Sequencer", sl->spacetype, 0);
1404                                 break;
1405                 }
1406         }
1407
1408         return km;
1409 }
1410