ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 1449 insertions, 1377 deletions

diff --git a/source/blender/windowmanager/intern/wm_keymap.c b/source/blender/windowmanager/intern/wm_keymap.c
index ba9accb5dee..3feae3d7dfc 100644
--- a/source/blender/windowmanager/intern/wm_keymap.c
+++ b/source/blender/windowmanager/intern/wm_keymap.c
@@ -57,8 +57,8 @@
 #include "wm_event_types.h"
 
 struct wmKeyMapItemFind_Params {
-	bool (*filter_fn)(const wmKeyMap *km, const wmKeyMapItem *kmi, void *user_data);
-	void *user_data;
+  bool (*filter_fn)(const wmKeyMap *km, const wmKeyMapItem *kmi, void *user_data);
+  void *user_data;
 };
 
 /******************************* Keymap Item **********************************
@@ -66,41 +66,41 @@ struct wmKeyMapItemFind_Params {
 
 static wmKeyMapItem *wm_keymap_item_copy(wmKeyMapItem *kmi)
 {
-	wmKeyMapItem *kmin = MEM_dupallocN(kmi);
+  wmKeyMapItem *kmin = MEM_dupallocN(kmi);
 
-	kmin->prev = kmin->next = NULL;
-	kmin->flag &= ~KMI_UPDATE;
+  kmin->prev = kmin->next = NULL;
+  kmin->flag &= ~KMI_UPDATE;
 
-	if (kmin->properties) {
-		kmin->ptr = MEM_callocN(sizeof(PointerRNA), "UserKeyMapItemPtr");
-		WM_operator_properties_create(kmin->ptr, kmin->idname);
+  if (kmin->properties) {
+    kmin->ptr = MEM_callocN(sizeof(PointerRNA), "UserKeyMapItemPtr");
+    WM_operator_properties_create(kmin->ptr, kmin->idname);
 
-		kmin->properties = IDP_CopyProperty(kmin->properties);
-		kmin->ptr->data = kmin->properties;
-	}
-	else {
-		kmin->properties = NULL;
-		kmin->ptr = NULL;
-	}
+    kmin->properties = IDP_CopyProperty(kmin->properties);
+    kmin->ptr->data = kmin->properties;
+  }
+  else {
+    kmin->properties = NULL;
+    kmin->ptr = NULL;
+  }
 
-	return kmin;
+  return kmin;
 }
 
 static void wm_keymap_item_free(wmKeyMapItem *kmi)
 {
-	/* not kmi itself */
-	if (kmi->ptr) {
-		WM_operator_properties_free(kmi->ptr);
-		MEM_freeN(kmi->ptr);
-		kmi->ptr = NULL;
-		kmi->properties = NULL;
-	}
+  /* not kmi itself */
+  if (kmi->ptr) {
+    WM_operator_properties_free(kmi->ptr);
+    MEM_freeN(kmi->ptr);
+    kmi->ptr = NULL;
+    kmi->properties = NULL;
+  }
 }
 
 static void wm_keymap_item_properties_set(wmKeyMapItem *kmi)
 {
-	WM_operator_properties_alloc(&(kmi->ptr), &(kmi->properties), kmi->idname);
-	WM_operator_properties_sanitize(kmi->ptr, 1);
+  WM_operator_properties_alloc(&(kmi->ptr), &(kmi->properties), kmi->idname);
+  WM_operator_properties_sanitize(kmi->ptr, 1);
 }
 
 /**
@@ -108,152 +108,144 @@ static void wm_keymap_item_properties_set(wmKeyMapItem *kmi)
  */
 static void wm_keymap_item_properties_update_ot(wmKeyMapItem *kmi)
 {
-	if (kmi->idname[0] == 0) {
-		BLI_assert(kmi->ptr == NULL);
-		return;
-	}
-
-	if (kmi->ptr == NULL) {
-		wm_keymap_item_properties_set(kmi);
-	}
-	else {
-		wmOperatorType *ot = WM_operatortype_find(kmi->idname, 0);
-		if (ot) {
-			if (ot->srna != kmi->ptr->type) {
-				/* matches wm_keymap_item_properties_set but doesn't alloc new ptr */
-				WM_operator_properties_create_ptr(kmi->ptr, ot);
-				/* 'kmi->ptr->data' NULL'd above, keep using existing properties.
-				 * Note: the operators property types may have changed,
-				 * we will need a more comprehensive sanitize function to support this properly.
-				 */
-				if (kmi->properties) {
-					kmi->ptr->data = kmi->properties;
-				}
-				WM_operator_properties_sanitize(kmi->ptr, 1);
-			}
-		}
-		else {
-			/* zombie keymap item */
-			wm_keymap_item_free(kmi);
-		}
-	}
+  if (kmi->idname[0] == 0) {
+    BLI_assert(kmi->ptr == NULL);
+    return;
+  }
+
+  if (kmi->ptr == NULL) {
+    wm_keymap_item_properties_set(kmi);
+  }
+  else {
+    wmOperatorType *ot = WM_operatortype_find(kmi->idname, 0);
+    if (ot) {
+      if (ot->srna != kmi->ptr->type) {
+        /* matches wm_keymap_item_properties_set but doesn't alloc new ptr */
+        WM_operator_properties_create_ptr(kmi->ptr, ot);
+        /* 'kmi->ptr->data' NULL'd above, keep using existing properties.
+         * Note: the operators property types may have changed,
+         * we will need a more comprehensive sanitize function to support this properly.
+         */
+        if (kmi->properties) {
+          kmi->ptr->data = kmi->properties;
+        }
+        WM_operator_properties_sanitize(kmi->ptr, 1);
+      }
+    }
+    else {
+      /* zombie keymap item */
+      wm_keymap_item_free(kmi);
+    }
+  }
 }
 
 static void wm_keyconfig_properties_update_ot(ListBase *km_lb)
 {
-	wmKeyMap *km;
-	wmKeyMapItem *kmi;
+  wmKeyMap *km;
+  wmKeyMapItem *kmi;
 
-	for (km = km_lb->first; km; km = km->next) {
-		wmKeyMapDiffItem *kmdi;
+  for (km = km_lb->first; km; km = km->next) {
+    wmKeyMapDiffItem *kmdi;
 
-		for (kmi = km->items.first; kmi; kmi = kmi->next) {
-			wm_keymap_item_properties_update_ot(kmi);
-		}
+    for (kmi = km->items.first; kmi; kmi = kmi->next) {
+      wm_keymap_item_properties_update_ot(kmi);
+    }
 
-		for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {
-			if (kmdi->add_item) {
-				wm_keymap_item_properties_update_ot(kmdi->add_item);
-			}
-			if (kmdi->remove_item) {
-				wm_keymap_item_properties_update_ot(kmdi->remove_item);
-			}
-		}
-	}
+    for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {
+      if (kmdi->add_item) {
+        wm_keymap_item_properties_update_ot(kmdi->add_item);
+      }
+      if (kmdi->remove_item) {
+        wm_keymap_item_properties_update_ot(kmdi->remove_item);
+      }
+    }
+  }
 }
 
 static bool wm_keymap_item_equals_result(wmKeyMapItem *a, wmKeyMapItem *b)
 {
-	return (STREQ(a->idname, b->idname) &&
-	        /* We do not really care about which Main we pass here, tbh. */
-	        RNA_struct_equals(G_MAIN, a->ptr, b->ptr, RNA_EQ_UNSET_MATCH_NONE) &&
-	        (a->flag & KMI_INACTIVE) == (b->flag & KMI_INACTIVE) &&
-	        a->propvalue == b->propvalue);
+  return (STREQ(a->idname, b->idname) &&
+          /* We do not really care about which Main we pass here, tbh. */
+          RNA_struct_equals(G_MAIN, a->ptr, b->ptr, RNA_EQ_UNSET_MATCH_NONE) &&
+          (a->flag & KMI_INACTIVE) == (b->flag & KMI_INACTIVE) && a->propvalue == b->propvalue);
 }
 
 static bool wm_keymap_item_equals(wmKeyMapItem *a, wmKeyMapItem *b)
 {
-	return (wm_keymap_item_equals_result(a, b) &&
-	        a->type == b->type &&
-	        a->val == b->val &&
-	        a->shift == b->shift &&
-	        a->ctrl == b->ctrl &&
-	        a->alt == b->alt &&
-	        a->oskey == b->oskey &&
-	        a->keymodifier == b->keymodifier &&
-	        a->maptype == b->maptype);
+  return (wm_keymap_item_equals_result(a, b) && a->type == b->type && a->val == b->val &&
+          a->shift == b->shift && a->ctrl == b->ctrl && a->alt == b->alt && a->oskey == b->oskey &&
+          a->keymodifier == b->keymodifier && a->maptype == b->maptype);
 }
 
 /* properties can be NULL, otherwise the arg passed is used and ownership is given to the kmi */
 void WM_keymap_properties_reset(wmKeyMapItem *kmi, struct IDProperty *properties)
 {
-	if (LIKELY(kmi->ptr)) {
-		WM_operator_properties_free(kmi->ptr);
-		MEM_freeN(kmi->ptr);
+  if (LIKELY(kmi->ptr)) {
+    WM_operator_properties_free(kmi->ptr);
+    MEM_freeN(kmi->ptr);
 
-		kmi->ptr = NULL;
-	}
+    kmi->ptr = NULL;
+  }
 
-	kmi->properties = properties;
+  kmi->properties = properties;
 
-	wm_keymap_item_properties_set(kmi);
+  wm_keymap_item_properties_set(kmi);
 }
 
 int WM_keymap_map_type_get(wmKeyMapItem *kmi)
 {
-	if (ISTIMER(kmi->type)) {
-		return KMI_TYPE_TIMER;
-	}
-	if (ISKEYBOARD(kmi->type)) {
-		return KMI_TYPE_KEYBOARD;
-	}
-	if (ISTWEAK(kmi->type)) {
-		return KMI_TYPE_TWEAK;
-	}
-	if (ISMOUSE(kmi->type)) {
-		return KMI_TYPE_MOUSE;
-	}
-	if (ISNDOF(kmi->type)) {
-		return KMI_TYPE_NDOF;
-	}
-	if (kmi->type == KM_TEXTINPUT) {
-		return KMI_TYPE_TEXTINPUT;
-	}
-	if (ELEM(kmi->type, TABLET_STYLUS, TABLET_ERASER)) {
-		return KMI_TYPE_MOUSE;
-	}
-	return KMI_TYPE_KEYBOARD;
+  if (ISTIMER(kmi->type)) {
+    return KMI_TYPE_TIMER;
+  }
+  if (ISKEYBOARD(kmi->type)) {
+    return KMI_TYPE_KEYBOARD;
+  }
+  if (ISTWEAK(kmi->type)) {
+    return KMI_TYPE_TWEAK;
+  }
+  if (ISMOUSE(kmi->type)) {
+    return KMI_TYPE_MOUSE;
+  }
+  if (ISNDOF(kmi->type)) {
+    return KMI_TYPE_NDOF;
+  }
+  if (kmi->type == KM_TEXTINPUT) {
+    return KMI_TYPE_TEXTINPUT;
+  }
+  if (ELEM(kmi->type, TABLET_STYLUS, TABLET_ERASER)) {
+    return KMI_TYPE_MOUSE;
+  }
+  return KMI_TYPE_KEYBOARD;
 }
 
-
 /**************************** Keymap Diff Item *********************************
  * Item in a diff keymap, used for saving diff of keymaps in user preferences */
 
 static wmKeyMapDiffItem *wm_keymap_diff_item_copy(wmKeyMapDiffItem *kmdi)
 {
-	wmKeyMapDiffItem *kmdin = MEM_dupallocN(kmdi);
+  wmKeyMapDiffItem *kmdin = MEM_dupallocN(kmdi);
 
-	kmdin->next = kmdin->prev = NULL;
-	if (kmdi->add_item) {
-		kmdin->add_item = wm_keymap_item_copy(kmdi->add_item);
-	}
-	if (kmdi->remove_item) {
-		kmdin->remove_item = wm_keymap_item_copy(kmdi->remove_item);
-	}
+  kmdin->next = kmdin->prev = NULL;
+  if (kmdi->add_item) {
+    kmdin->add_item = wm_keymap_item_copy(kmdi->add_item);
+  }
+  if (kmdi->remove_item) {
+    kmdin->remove_item = wm_keymap_item_copy(kmdi->remove_item);
+  }
 
-	return kmdin;
+  return kmdin;
 }
 
 static void wm_keymap_diff_item_free(wmKeyMapDiffItem *kmdi)
 {
-	if (kmdi->remove_item) {
-		wm_keymap_item_free(kmdi->remove_item);
-		MEM_freeN(kmdi->remove_item);
-	}
-	if (kmdi->add_item) {
-		wm_keymap_item_free(kmdi->add_item);
-		MEM_freeN(kmdi->add_item);
-	}
+  if (kmdi->remove_item) {
+    wm_keymap_item_free(kmdi->remove_item);
+    MEM_freeN(kmdi->remove_item);
+  }
+  if (kmdi->add_item) {
+    wm_keymap_item_free(kmdi->add_item);
+    MEM_freeN(kmdi->add_item);
+  }
 }
 
 /***************************** Key Configuration ******************************
@@ -262,98 +254,98 @@ static void wm_keymap_diff_item_free(wmKeyMapDiffItem *kmdi)
 
 wmKeyConfig *WM_keyconfig_new(wmWindowManager *wm, const char *idname, bool user_defined)
 {
-	wmKeyConfig *keyconf = BLI_findstring(&wm->keyconfigs, idname, offsetof(wmKeyConfig, idname));
-	if (keyconf) {
-		if (keyconf == wm->defaultconf) {
-			/* For default configuration, we need to keep keymap
-			 * modal items and poll functions intact. */
-			for (wmKeyMap *km = keyconf->keymaps.first; km; km = km->next) {
-				WM_keymap_clear(km);
-			}
-		}
-		else {
-			/* For user defined key configuration, clear all keymaps. */
-			WM_keyconfig_clear(keyconf);
-		}
+  wmKeyConfig *keyconf = BLI_findstring(&wm->keyconfigs, idname, offsetof(wmKeyConfig, idname));
+  if (keyconf) {
+    if (keyconf == wm->defaultconf) {
+      /* For default configuration, we need to keep keymap
+       * modal items and poll functions intact. */
+      for (wmKeyMap *km = keyconf->keymaps.first; km; km = km->next) {
+        WM_keymap_clear(km);
+      }
+    }
+    else {
+      /* For user defined key configuration, clear all keymaps. */
+      WM_keyconfig_clear(keyconf);
+    }
 
-		return keyconf;
-	}
+    return keyconf;
+  }
 
-	/* Create new configuration. */
-	keyconf = MEM_callocN(sizeof(wmKeyConfig), "wmKeyConfig");
-	BLI_strncpy(keyconf->idname, idname, sizeof(keyconf->idname));
-	BLI_addtail(&wm->keyconfigs, keyconf);
+  /* Create new configuration. */
+  keyconf = MEM_callocN(sizeof(wmKeyConfig), "wmKeyConfig");
+  BLI_strncpy(keyconf->idname, idname, sizeof(keyconf->idname));
+  BLI_addtail(&wm->keyconfigs, keyconf);
 
-	if (user_defined) {
-		keyconf->flag |= KEYCONF_USER;
-	}
+  if (user_defined) {
+    keyconf->flag |= KEYCONF_USER;
+  }
 
-	return keyconf;
+  return keyconf;
 }
 
 wmKeyConfig *WM_keyconfig_new_user(wmWindowManager *wm, const char *idname)
 {
-	return WM_keyconfig_new(wm, idname, true);
+  return WM_keyconfig_new(wm, idname, true);
 }
 
 bool WM_keyconfig_remove(wmWindowManager *wm, wmKeyConfig *keyconf)
 {
-	if (BLI_findindex(&wm->keyconfigs, keyconf) != -1) {
-		if (STREQLEN(U.keyconfigstr, keyconf->idname, sizeof(U.keyconfigstr))) {
-			BLI_strncpy(U.keyconfigstr, wm->defaultconf->idname, sizeof(U.keyconfigstr));
-			WM_keyconfig_update_tag(NULL, NULL);
-		}
+  if (BLI_findindex(&wm->keyconfigs, keyconf) != -1) {
+    if (STREQLEN(U.keyconfigstr, keyconf->idname, sizeof(U.keyconfigstr))) {
+      BLI_strncpy(U.keyconfigstr, wm->defaultconf->idname, sizeof(U.keyconfigstr));
+      WM_keyconfig_update_tag(NULL, NULL);
+    }
 
-		BLI_remlink(&wm->keyconfigs, keyconf);
-		WM_keyconfig_free(keyconf);
+    BLI_remlink(&wm->keyconfigs, keyconf);
+    WM_keyconfig_free(keyconf);
 
-		return true;
-	}
-	else {
-		return false;
-	}
+    return true;
+  }
+  else {
+    return false;
+  }
 }
 
 void WM_keyconfig_clear(wmKeyConfig *keyconf)
 {
-	for (wmKeyMap *km = keyconf->keymaps.first; km; km = km->next) {
-		WM_keymap_clear(km);
-	}
+  for (wmKeyMap *km = keyconf->keymaps.first; km; km = km->next) {
+    WM_keymap_clear(km);
+  }
 
-	BLI_freelistN(&keyconf->keymaps);
+  BLI_freelistN(&keyconf->keymaps);
 }
 
 void WM_keyconfig_free(wmKeyConfig *keyconf)
 {
-	WM_keyconfig_clear(keyconf);
-	MEM_freeN(keyconf);
+  WM_keyconfig_clear(keyconf);
+  MEM_freeN(keyconf);
 }
 
 static wmKeyConfig *WM_keyconfig_active(wmWindowManager *wm)
 {
-	wmKeyConfig *keyconf;
+  wmKeyConfig *keyconf;
 
-	/* first try from preset */
-	keyconf = BLI_findstring(&wm->keyconfigs, U.keyconfigstr, offsetof(wmKeyConfig, idname));
-	if (keyconf) {
-		return keyconf;
-	}
+  /* first try from preset */
+  keyconf = BLI_findstring(&wm->keyconfigs, U.keyconfigstr, offsetof(wmKeyConfig, idname));
+  if (keyconf) {
+    return keyconf;
+  }
 
-	/* otherwise use default */
-	return wm->defaultconf;
+  /* otherwise use default */
+  return wm->defaultconf;
 }
 
 void WM_keyconfig_set_active(wmWindowManager *wm, const char *idname)
 {
-	/* setting a different key configuration as active: we ensure all is
-	 * updated properly before and after making the change */
+  /* setting a different key configuration as active: we ensure all is
+   * updated properly before and after making the change */
 
-	WM_keyconfig_update(wm);
+  WM_keyconfig_update(wm);
 
-	BLI_strncpy(U.keyconfigstr, idname, sizeof(U.keyconfigstr));
+  BLI_strncpy(U.keyconfigstr, idname, sizeof(U.keyconfigstr));
 
-	WM_keyconfig_update_tag(NULL, NULL);
-	WM_keyconfig_update(wm);
+  WM_keyconfig_update_tag(NULL, NULL);
+  WM_keyconfig_update(wm);
 }
 
 /********************************** Keymap *************************************
@@ -361,200 +353,204 @@ void WM_keyconfig_set_active(wmWindowManager *wm, const char *idname)
 
 static wmKeyMap *wm_keymap_new(const char *idname, int spaceid, int regionid)
 {
-	wmKeyMap *km = MEM_callocN(sizeof(struct wmKeyMap), "keymap list");
+  wmKeyMap *km = MEM_callocN(sizeof(struct wmKeyMap), "keymap list");
 
-	BLI_strncpy(km->idname, idname, KMAP_MAX_NAME);
-	km->spaceid = spaceid;
-	km->regionid = regionid;
+  BLI_strncpy(km->idname, idname, KMAP_MAX_NAME);
+  km->spaceid = spaceid;
+  km->regionid = regionid;
 
-	{
-		const char *owner_id = RNA_struct_state_owner_get();
-		if (owner_id) {
-			BLI_strncpy(km->owner_id, owner_id, sizeof(km->owner_id));
-		}
-	}
-	return km;
+  {
+    const char *owner_id = RNA_struct_state_owner_get();
+    if (owner_id) {
+      BLI_strncpy(km->owner_id, owner_id, sizeof(km->owner_id));
+    }
+  }
+  return km;
 }
 
 static wmKeyMap *wm_keymap_copy(wmKeyMap *keymap)
 {
-	wmKeyMap *keymapn = MEM_dupallocN(keymap);
-	wmKeyMapItem *kmi, *kmin;
-	wmKeyMapDiffItem *kmdi, *kmdin;
+  wmKeyMap *keymapn = MEM_dupallocN(keymap);
+  wmKeyMapItem *kmi, *kmin;
+  wmKeyMapDiffItem *kmdi, *kmdin;
 
-	keymapn->modal_items = keymap->modal_items;
-	keymapn->poll = keymap->poll;
-	keymapn->poll_modal_item = keymap->poll_modal_item;
-	BLI_listbase_clear(&keymapn->items);
-	keymapn->flag &= ~(KEYMAP_UPDATE | KEYMAP_EXPANDED);
+  keymapn->modal_items = keymap->modal_items;
+  keymapn->poll = keymap->poll;
+  keymapn->poll_modal_item = keymap->poll_modal_item;
+  BLI_listbase_clear(&keymapn->items);
+  keymapn->flag &= ~(KEYMAP_UPDATE | KEYMAP_EXPANDED);
 
-	for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) {
-		kmdin = wm_keymap_diff_item_copy(kmdi);
-		BLI_addtail(&keymapn->items, kmdin);
-	}
+  for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) {
+    kmdin = wm_keymap_diff_item_copy(kmdi);
+    BLI_addtail(&keymapn->items, kmdin);
+  }
 
-	for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
-		kmin = wm_keymap_item_copy(kmi);
-		BLI_addtail(&keymapn->items, kmin);
-	}
+  for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
+    kmin = wm_keymap_item_copy(kmi);
+    BLI_addtail(&keymapn->items, kmin);
+  }
 
-	return keymapn;
+  return keymapn;
 }
 
 void WM_keymap_clear(wmKeyMap *keymap)
 {
-	wmKeyMapItem *kmi;
-	wmKeyMapDiffItem *kmdi;
+  wmKeyMapItem *kmi;
+  wmKeyMapDiffItem *kmdi;
 
-	for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) {
-		wm_keymap_diff_item_free(kmdi);
-	}
+  for (kmdi = keymap->diff_items.first; kmdi; kmdi = kmdi->next) {
+    wm_keymap_diff_item_free(kmdi);
+  }
 
-	for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
-		wm_keymap_item_free(kmi);
-	}
+  for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
+    wm_keymap_item_free(kmi);
+  }
 
-	BLI_freelistN(&keymap->diff_items);
-	BLI_freelistN(&keymap->items);
+  BLI_freelistN(&keymap->diff_items);
+  BLI_freelistN(&keymap->items);
 }
 
 bool WM_keymap_remove(wmKeyConfig *keyconf, wmKeyMap *keymap)
 {
-	if (BLI_findindex(&keyconf->keymaps, keymap) != -1) {
+  if (BLI_findindex(&keyconf->keymaps, keymap) != -1) {
 
-		WM_keymap_clear(keymap);
-		BLI_remlink(&keyconf->keymaps, keymap);
-		MEM_freeN(keymap);
+    WM_keymap_clear(keymap);
+    BLI_remlink(&keyconf->keymaps, keymap);
+    MEM_freeN(keymap);
 
-		return true;
-	}
-	else {
-		return false;
-	}
+    return true;
+  }
+  else {
+    return false;
+  }
 }
 
-
 bool WM_keymap_poll(bContext *C, wmKeyMap *keymap)
 {
-	/* If we're tagged, only use compatible. */
-	if (keymap->owner_id[0] != '\0') {
-		const WorkSpace *workspace = CTX_wm_workspace(C);
-		if (BKE_workspace_owner_id_check(workspace, keymap->owner_id) == false) {
-			return false;
-		}
-	}
-
-	if (UNLIKELY(BLI_listbase_is_empty(&keymap->items))) {
-		/* Empty key-maps may be missing more there may be a typo in the name.
-		 * Warn early to avoid loosing time investigating each case. */
-		CLOG_WARN(WM_LOG_KEYMAPS, "empty keymap '%s'", keymap->idname);
-	}
-
-	if (keymap->poll != NULL) {
-		return keymap->poll(C);
-	}
-	return true;
-}
-
-static void keymap_event_set(wmKeyMapItem *kmi, short type, short val, int modifier, short keymodifier)
-{
-	kmi->type = type;
-	kmi->val = val;
-	kmi->keymodifier = keymodifier;
-
-	if (modifier == KM_ANY) {
-		kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY;
-	}
-	else {
-		kmi->shift = (modifier & KM_SHIFT) ? KM_MOD_FIRST : ((modifier & KM_SHIFT2) ? KM_MOD_SECOND : false);
-		kmi->ctrl =  (modifier & KM_CTRL)  ? KM_MOD_FIRST : ((modifier & KM_CTRL2)  ? KM_MOD_SECOND : false);
-		kmi->alt =   (modifier & KM_ALT)   ? KM_MOD_FIRST : ((modifier & KM_ALT2)   ? KM_MOD_SECOND : false);
-		kmi->oskey = (modifier & KM_OSKEY) ? KM_MOD_FIRST : ((modifier & KM_OSKEY2) ? KM_MOD_SECOND : false);
-	}
+  /* If we're tagged, only use compatible. */
+  if (keymap->owner_id[0] != '\0') {
+    const WorkSpace *workspace = CTX_wm_workspace(C);
+    if (BKE_workspace_owner_id_check(workspace, keymap->owner_id) == false) {
+      return false;
+    }
+  }
+
+  if (UNLIKELY(BLI_listbase_is_empty(&keymap->items))) {
+    /* Empty key-maps may be missing more there may be a typo in the name.
+     * Warn early to avoid loosing time investigating each case. */
+    CLOG_WARN(WM_LOG_KEYMAPS, "empty keymap '%s'", keymap->idname);
+  }
+
+  if (keymap->poll != NULL) {
+    return keymap->poll(C);
+  }
+  return true;
+}
+
+static void keymap_event_set(
+    wmKeyMapItem *kmi, short type, short val, int modifier, short keymodifier)
+{
+  kmi->type = type;
+  kmi->val = val;
+  kmi->keymodifier = keymodifier;
+
+  if (modifier == KM_ANY) {
+    kmi->shift = kmi->ctrl = kmi->alt = kmi->oskey = KM_ANY;
+  }
+  else {
+    kmi->shift = (modifier & KM_SHIFT) ? KM_MOD_FIRST :
+                                         ((modifier & KM_SHIFT2) ? KM_MOD_SECOND : false);
+    kmi->ctrl = (modifier & KM_CTRL) ? KM_MOD_FIRST :
+                                       ((modifier & KM_CTRL2) ? KM_MOD_SECOND : false);
+    kmi->alt = (modifier & KM_ALT) ? KM_MOD_FIRST : ((modifier & KM_ALT2) ? KM_MOD_SECOND : false);
+    kmi->oskey = (modifier & KM_OSKEY) ? KM_MOD_FIRST :
+                                         ((modifier & KM_OSKEY2) ? KM_MOD_SECOND : false);
+  }
 }
 
 static void keymap_item_set_id(wmKeyMap *keymap, wmKeyMapItem *kmi)
 {
-	keymap->kmi_id++;
-	if ((keymap->flag & KEYMAP_USER) == 0) {
-		kmi->id = keymap->kmi_id;
-	}
-	else {
-		kmi->id = -keymap->kmi_id; /* User defined keymap entries have negative ids */
-	}
+  keymap->kmi_id++;
+  if ((keymap->flag & KEYMAP_USER) == 0) {
+    kmi->id = keymap->kmi_id;
+  }
+  else {
+    kmi->id = -keymap->kmi_id; /* User defined keymap entries have negative ids */
+  }
 }
 
 /* if item was added, then bail out */
-wmKeyMapItem *WM_keymap_verify_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
+wmKeyMapItem *WM_keymap_verify_item(
+    wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
 {
-	wmKeyMapItem *kmi;
+  wmKeyMapItem *kmi;
 
-	for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
-		if (STREQLEN(kmi->idname, idname, OP_MAX_TYPENAME)) {
-			break;
-		}
-	}
-	if (kmi == NULL) {
-		kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
+  for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
+    if (STREQLEN(kmi->idname, idname, OP_MAX_TYPENAME)) {
+      break;
+    }
+  }
+  if (kmi == NULL) {
+    kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 
-		BLI_addtail(&keymap->items, kmi);
-		BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
+    BLI_addtail(&keymap->items, kmi);
+    BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
 
-		keymap_item_set_id(keymap, kmi);
+    keymap_item_set_id(keymap, kmi);
 
-		keymap_event_set(kmi, type, val, modifier, keymodifier);
-		wm_keymap_item_properties_set(kmi);
-	}
-	return kmi;
+    keymap_event_set(kmi, type, val, modifier, keymodifier);
+    wm_keymap_item_properties_set(kmi);
+  }
+  return kmi;
 }
 
 /* always add item */
-wmKeyMapItem *WM_keymap_add_item(wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
+wmKeyMapItem *WM_keymap_add_item(
+    wmKeyMap *keymap, const char *idname, int type, int val, int modifier, int keymodifier)
 {
-	wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
+  wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 
-	BLI_addtail(&keymap->items, kmi);
-	BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
+  BLI_addtail(&keymap->items, kmi);
+  BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
 
-	keymap_event_set(kmi, type, val, modifier, keymodifier);
-	wm_keymap_item_properties_set(kmi);
+  keymap_event_set(kmi, type, val, modifier, keymodifier);
+  wm_keymap_item_properties_set(kmi);
 
-	keymap_item_set_id(keymap, kmi);
+  keymap_item_set_id(keymap, kmi);
 
-	WM_keyconfig_update_tag(keymap, kmi);
+  WM_keyconfig_update_tag(keymap, kmi);
 
-	return kmi;
+  return kmi;
 }
 
-wmKeyMapItem *WM_keymap_add_item_copy(
-        struct wmKeyMap *keymap, wmKeyMapItem *kmi_src)
+wmKeyMapItem *WM_keymap_add_item_copy(struct wmKeyMap *keymap, wmKeyMapItem *kmi_src)
 {
-	wmKeyMapItem *kmi_dst = wm_keymap_item_copy(kmi_src);
+  wmKeyMapItem *kmi_dst = wm_keymap_item_copy(kmi_src);
 
-	BLI_addtail(&keymap->items, kmi_dst);
+  BLI_addtail(&keymap->items, kmi_dst);
 
-	keymap_item_set_id(keymap, kmi_dst);
+  keymap_item_set_id(keymap, kmi_dst);
 
-	WM_keyconfig_update_tag(keymap, kmi_dst);
+  WM_keyconfig_update_tag(keymap, kmi_dst);
 
-	return kmi_dst;
+  return kmi_dst;
 }
 
 bool WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi)
 {
-	if (BLI_findindex(&keymap->items, kmi) != -1) {
-		if (kmi->ptr) {
-			WM_operator_properties_free(kmi->ptr);
-			MEM_freeN(kmi->ptr);
-		}
-		BLI_freelinkN(&keymap->items, kmi);
+  if (BLI_findindex(&keymap->items, kmi) != -1) {
+    if (kmi->ptr) {
+      WM_operator_properties_free(kmi->ptr);
+      MEM_freeN(kmi->ptr);
+    }
+    BLI_freelinkN(&keymap->items, kmi);
 
-		WM_keyconfig_update_tag(keymap, NULL);
-		return true;
-	}
-	else {
-		return false;
-	}
+    WM_keyconfig_update_tag(keymap, NULL);
+    return true;
+  }
+  else {
+    return false;
+  }
 }
 
 /************************** Keymap Diff and Patch ****************************
@@ -565,254 +561,261 @@ bool WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi)
 
 static void wm_keymap_addon_add(wmKeyMap *keymap, wmKeyMap *addonmap)
 {
-	wmKeyMapItem *kmi, *kmin;
+  wmKeyMapItem *kmi, *kmin;
 
-	for (kmi = addonmap->items.first; kmi; kmi = kmi->next) {
-		kmin = wm_keymap_item_copy(kmi);
-		keymap_item_set_id(keymap, kmin);
-		BLI_addhead(&keymap->items, kmin);
-	}
+  for (kmi = addonmap->items.first; kmi; kmi = kmi->next) {
+    kmin = wm_keymap_item_copy(kmi);
+    keymap_item_set_id(keymap, kmin);
+    BLI_addhead(&keymap->items, kmin);
+  }
 }
 
 static wmKeyMapItem *wm_keymap_find_item_equals(wmKeyMap *km, wmKeyMapItem *needle)
 {
-	wmKeyMapItem *kmi;
+  wmKeyMapItem *kmi;
 
-	for (kmi = km->items.first; kmi; kmi = kmi->next) {
-		if (wm_keymap_item_equals(kmi, needle)) {
-			return kmi;
-		}
-	}
+  for (kmi = km->items.first; kmi; kmi = kmi->next) {
+    if (wm_keymap_item_equals(kmi, needle)) {
+      return kmi;
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
 
 static wmKeyMapItem *wm_keymap_find_item_equals_result(wmKeyMap *km, wmKeyMapItem *needle)
 {
-	wmKeyMapItem *kmi;
-
-	for (kmi = km->items.first; kmi; kmi = kmi->next) {
-		if (wm_keymap_item_equals_result(kmi, needle)) {
-			return kmi;
-		}
-	}
-
-	return NULL;
-}
-
-static void wm_keymap_diff(wmKeyMap *diff_km, wmKeyMap *from_km, wmKeyMap *to_km, wmKeyMap *orig_km, wmKeyMap *addon_km)
-{
-	wmKeyMapItem *kmi, *to_kmi, *orig_kmi;
-	wmKeyMapDiffItem *kmdi;
-
-	for (kmi = from_km->items.first; kmi; kmi = kmi->next) {
-		to_kmi = WM_keymap_item_find_id(to_km, kmi->id);
-
-		if (!to_kmi) {
-			/* remove item */
-			kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
-			kmdi->remove_item = wm_keymap_item_copy(kmi);
-			BLI_addtail(&diff_km->diff_items, kmdi);
-		}
-		else if (to_kmi && !wm_keymap_item_equals(kmi, to_kmi)) {
-			/* replace item */
-			kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
-			kmdi->remove_item = wm_keymap_item_copy(kmi);
-			kmdi->add_item = wm_keymap_item_copy(to_kmi);
-			BLI_addtail(&diff_km->diff_items, kmdi);
-		}
-
-		/* sync expanded flag back to original so we don't loose it on repatch */
-		if (to_kmi) {
-			orig_kmi = WM_keymap_item_find_id(orig_km, kmi->id);
-
-			if (!orig_kmi && addon_km) {
-				orig_kmi = wm_keymap_find_item_equals(addon_km, kmi);
-			}
-
-			if (orig_kmi) {
-				orig_kmi->flag &= ~KMI_EXPANDED;
-				orig_kmi->flag |= (to_kmi->flag & KMI_EXPANDED);
-			}
-		}
-	}
-
-	for (kmi = to_km->items.first; kmi; kmi = kmi->next) {
-		if (kmi->id < 0) {
-			/* add item */
-			kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
-			kmdi->add_item = wm_keymap_item_copy(kmi);
-			BLI_addtail(&diff_km->diff_items, kmdi);
-		}
-	}
+  wmKeyMapItem *kmi;
+
+  for (kmi = km->items.first; kmi; kmi = kmi->next) {
+    if (wm_keymap_item_equals_result(kmi, needle)) {
+      return kmi;
+    }
+  }
+
+  return NULL;
+}
+
+static void wm_keymap_diff(
+    wmKeyMap *diff_km, wmKeyMap *from_km, wmKeyMap *to_km, wmKeyMap *orig_km, wmKeyMap *addon_km)
+{
+  wmKeyMapItem *kmi, *to_kmi, *orig_kmi;
+  wmKeyMapDiffItem *kmdi;
+
+  for (kmi = from_km->items.first; kmi; kmi = kmi->next) {
+    to_kmi = WM_keymap_item_find_id(to_km, kmi->id);
+
+    if (!to_kmi) {
+      /* remove item */
+      kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
+      kmdi->remove_item = wm_keymap_item_copy(kmi);
+      BLI_addtail(&diff_km->diff_items, kmdi);
+    }
+    else if (to_kmi && !wm_keymap_item_equals(kmi, to_kmi)) {
+      /* replace item */
+      kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
+      kmdi->remove_item = wm_keymap_item_copy(kmi);
+      kmdi->add_item = wm_keymap_item_copy(to_kmi);
+      BLI_addtail(&diff_km->diff_items, kmdi);
+    }
+
+    /* sync expanded flag back to original so we don't loose it on repatch */
+    if (to_kmi) {
+      orig_kmi = WM_keymap_item_find_id(orig_km, kmi->id);
+
+      if (!orig_kmi && addon_km) {
+        orig_kmi = wm_keymap_find_item_equals(addon_km, kmi);
+      }
+
+      if (orig_kmi) {
+        orig_kmi->flag &= ~KMI_EXPANDED;
+        orig_kmi->flag |= (to_kmi->flag & KMI_EXPANDED);
+      }
+    }
+  }
+
+  for (kmi = to_km->items.first; kmi; kmi = kmi->next) {
+    if (kmi->id < 0) {
+      /* add item */
+      kmdi = MEM_callocN(sizeof(wmKeyMapDiffItem), "wmKeyMapDiffItem");
+      kmdi->add_item = wm_keymap_item_copy(kmi);
+      BLI_addtail(&diff_km->diff_items, kmdi);
+    }
+  }
 }
 
 static void wm_keymap_patch(wmKeyMap *km, wmKeyMap *diff_km)
 {
-	wmKeyMapDiffItem *kmdi;
-	wmKeyMapItem *kmi_remove, *kmi_add;
-
-	for (kmdi = diff_km->diff_items.first; kmdi; kmdi = kmdi->next) {
-		/* find item to remove */
-		kmi_remove = NULL;
-		if (kmdi->remove_item) {
-			kmi_remove = wm_keymap_find_item_equals(km, kmdi->remove_item);
-			if (!kmi_remove) {
-				kmi_remove = wm_keymap_find_item_equals_result(km, kmdi->remove_item);
-			}
-		}
-
-		/* add item */
-		if (kmdi->add_item) {
-			/* Do not re-add an already existing keymap item! See T42088. */
-			/* We seek only for exact copy here! See T42137. */
-			kmi_add = wm_keymap_find_item_equals(km, kmdi->add_item);
-
-			/* If kmi_add is same as kmi_remove (can happen in some cases, typically when we got kmi_remove
-			 * from wm_keymap_find_item_equals_result()), no need to add or remove anything, see T45579. */
-			/* Note: This typically happens when we apply user-defined keymap diff to a base one that was exported
-			 *       with that customized keymap already. In that case:
-			 *         - wm_keymap_find_item_equals(km, kmdi->remove_item) finds nothing (because actual shortcut of
-			 *           current base does not match kmdi->remove_item any more).
-			 *         - wm_keymap_find_item_equals_result(km, kmdi->remove_item) finds the current kmi from
-			 *           base keymap (because it does exactly the same thing).
-			 *         - wm_keymap_find_item_equals(km, kmdi->add_item) finds the same kmi, since base keymap was
-			 *           exported with that user-defined shortcut already!
-			 *       Maybe we should rather keep user-defined keymaps specific to a given base one? */
-			if (kmi_add != NULL && kmi_add == kmi_remove) {
-				kmi_remove = NULL;
-			}
-			/* only if nothing to remove or item to remove found */
-			else if (!kmi_add && (!kmdi->remove_item || kmi_remove)) {
-				kmi_add = wm_keymap_item_copy(kmdi->add_item);
-				kmi_add->flag |= KMI_USER_MODIFIED;
-
-				if (kmi_remove) {
-					kmi_add->flag &= ~KMI_EXPANDED;
-					kmi_add->flag |= (kmi_remove->flag & KMI_EXPANDED);
-					kmi_add->id = kmi_remove->id;
-					BLI_insertlinkbefore(&km->items, kmi_remove, kmi_add);
-				}
-				else {
-					keymap_item_set_id(km, kmi_add);
-					BLI_addtail(&km->items, kmi_add);
-				}
-			}
-		}
-
-		/* remove item */
-		if (kmi_remove) {
-			wm_keymap_item_free(kmi_remove);
-			BLI_freelinkN(&km->items, kmi_remove);
-		}
-	}
-}
-
-static wmKeyMap *wm_keymap_patch_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *usermap)
-{
-	wmKeyMap *km;
-	int expanded = 0;
-
-	/* remove previous keymap in list, we will replace it */
-	km = WM_keymap_list_find(lb, defaultmap->idname, defaultmap->spaceid, defaultmap->regionid);
-	if (km) {
-		expanded = (km->flag & (KEYMAP_EXPANDED | KEYMAP_CHILDREN_EXPANDED));
-		WM_keymap_clear(km);
-		BLI_freelinkN(lb, km);
-	}
-
-	/* copy new keymap from an existing one */
-	if (usermap && !(usermap->flag & KEYMAP_DIFF)) {
-		/* for compatibility with old user preferences with non-diff
-		 * keymaps we override the original entirely */
-		wmKeyMapItem *kmi, *orig_kmi;
-
-		km = wm_keymap_copy(usermap);
-
-		/* try to find corresponding id's for items */
-		for (kmi = km->items.first; kmi; kmi = kmi->next) {
-			orig_kmi = wm_keymap_find_item_equals(defaultmap, kmi);
-			if (!orig_kmi) {
-				orig_kmi = wm_keymap_find_item_equals_result(defaultmap, kmi);
-			}
-
-			if (orig_kmi) {
-				kmi->id = orig_kmi->id;
-			}
-			else {
-				kmi->id = -(km->kmi_id++);
-			}
-		}
-
-		km->flag |= KEYMAP_UPDATE; /* update again to create diff */
-	}
-	else {
-		km = wm_keymap_copy(defaultmap);
-	}
-
-	/* add addon keymap items */
-	if (addonmap) {
-		wm_keymap_addon_add(km, addonmap);
-	}
-
-	/* tag as being user edited */
-	if (usermap) {
-		km->flag |= KEYMAP_USER_MODIFIED;
-	}
-	km->flag |= KEYMAP_USER | expanded;
-
-	/* apply user changes of diff keymap */
-	if (usermap && (usermap->flag & KEYMAP_DIFF)) {
-		wm_keymap_patch(km, usermap);
-	}
-
-	/* add to list */
-	BLI_addtail(lb, km);
-
-	return km;
-}
-
-static void wm_keymap_diff_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *addonmap, wmKeyMap *km)
-{
-	wmKeyMap *diffmap, *prevmap, *origmap;
-
-	/* create temporary default + addon keymap for diff */
-	origmap = defaultmap;
-
-	if (addonmap) {
-		defaultmap = wm_keymap_copy(defaultmap);
-		wm_keymap_addon_add(defaultmap, addonmap);
-	}
-
-	/* remove previous diff keymap in list, we will replace it */
-	prevmap = WM_keymap_list_find(lb, km->idname, km->spaceid, km->regionid);
-	if (prevmap) {
-		WM_keymap_clear(prevmap);
-		BLI_freelinkN(lb, prevmap);
-	}
-
-	/* create diff keymap */
-	diffmap = wm_keymap_new(km->idname, km->spaceid, km->regionid);
-	diffmap->flag |= KEYMAP_DIFF;
-	if (defaultmap->flag & KEYMAP_MODAL) {
-		diffmap->flag |= KEYMAP_MODAL;
-	}
-	wm_keymap_diff(diffmap, defaultmap, km, origmap, addonmap);
-
-	/* add to list if not empty */
-	if (diffmap->diff_items.first) {
-		BLI_addtail(lb, diffmap);
-	}
-	else {
-		WM_keymap_clear(diffmap);
-		MEM_freeN(diffmap);
-	}
-
-	/* free temporary default map */
-	if (addonmap) {
-		WM_keymap_clear(defaultmap);
-		MEM_freeN(defaultmap);
-	}
+  wmKeyMapDiffItem *kmdi;
+  wmKeyMapItem *kmi_remove, *kmi_add;
+
+  for (kmdi = diff_km->diff_items.first; kmdi; kmdi = kmdi->next) {
+    /* find item to remove */
+    kmi_remove = NULL;
+    if (kmdi->remove_item) {
+      kmi_remove = wm_keymap_find_item_equals(km, kmdi->remove_item);
+      if (!kmi_remove) {
+        kmi_remove = wm_keymap_find_item_equals_result(km, kmdi->remove_item);
+      }
+    }
+
+    /* add item */
+    if (kmdi->add_item) {
+      /* Do not re-add an already existing keymap item! See T42088. */
+      /* We seek only for exact copy here! See T42137. */
+      kmi_add = wm_keymap_find_item_equals(km, kmdi->add_item);
+
+      /* If kmi_add is same as kmi_remove (can happen in some cases, typically when we got kmi_remove
+       * from wm_keymap_find_item_equals_result()), no need to add or remove anything, see T45579. */
+      /* Note: This typically happens when we apply user-defined keymap diff to a base one that was exported
+       *       with that customized keymap already. In that case:
+       *         - wm_keymap_find_item_equals(km, kmdi->remove_item) finds nothing (because actual shortcut of
+       *           current base does not match kmdi->remove_item any more).
+       *         - wm_keymap_find_item_equals_result(km, kmdi->remove_item) finds the current kmi from
+       *           base keymap (because it does exactly the same thing).
+       *         - wm_keymap_find_item_equals(km, kmdi->add_item) finds the same kmi, since base keymap was
+       *           exported with that user-defined shortcut already!
+       *       Maybe we should rather keep user-defined keymaps specific to a given base one? */
+      if (kmi_add != NULL && kmi_add == kmi_remove) {
+        kmi_remove = NULL;
+      }
+      /* only if nothing to remove or item to remove found */
+      else if (!kmi_add && (!kmdi->remove_item || kmi_remove)) {
+        kmi_add = wm_keymap_item_copy(kmdi->add_item);
+        kmi_add->flag |= KMI_USER_MODIFIED;
+
+        if (kmi_remove) {
+          kmi_add->flag &= ~KMI_EXPANDED;
+          kmi_add->flag |= (kmi_remove->flag & KMI_EXPANDED);
+          kmi_add->id = kmi_remove->id;
+          BLI_insertlinkbefore(&km->items, kmi_remove, kmi_add);
+        }
+        else {
+          keymap_item_set_id(km, kmi_add);
+          BLI_addtail(&km->items, kmi_add);
+        }
+      }
+    }
+
+    /* remove item */
+    if (kmi_remove) {
+      wm_keymap_item_free(kmi_remove);
+      BLI_freelinkN(&km->items, kmi_remove);
+    }
+  }
+}
+
+static wmKeyMap *wm_keymap_patch_update(ListBase *lb,
+                                        wmKeyMap *defaultmap,
+                                        wmKeyMap *addonmap,
+                                        wmKeyMap *usermap)
+{
+  wmKeyMap *km;
+  int expanded = 0;
+
+  /* remove previous keymap in list, we will replace it */
+  km = WM_keymap_list_find(lb, defaultmap->idname, defaultmap->spaceid, defaultmap->regionid);
+  if (km) {
+    expanded = (km->flag & (KEYMAP_EXPANDED | KEYMAP_CHILDREN_EXPANDED));
+    WM_keymap_clear(km);
+    BLI_freelinkN(lb, km);
+  }
+
+  /* copy new keymap from an existing one */
+  if (usermap && !(usermap->flag & KEYMAP_DIFF)) {
+    /* for compatibility with old user preferences with non-diff
+     * keymaps we override the original entirely */
+    wmKeyMapItem *kmi, *orig_kmi;
+
+    km = wm_keymap_copy(usermap);
+
+    /* try to find corresponding id's for items */
+    for (kmi = km->items.first; kmi; kmi = kmi->next) {
+      orig_kmi = wm_keymap_find_item_equals(defaultmap, kmi);
+      if (!orig_kmi) {
+        orig_kmi = wm_keymap_find_item_equals_result(defaultmap, kmi);
+      }
+
+      if (orig_kmi) {
+        kmi->id = orig_kmi->id;
+      }
+      else {
+        kmi->id = -(km->kmi_id++);
+      }
+    }
+
+    km->flag |= KEYMAP_UPDATE; /* update again to create diff */
+  }
+  else {
+    km = wm_keymap_copy(defaultmap);
+  }
+
+  /* add addon keymap items */
+  if (addonmap) {
+    wm_keymap_addon_add(km, addonmap);
+  }
+
+  /* tag as being user edited */
+  if (usermap) {
+    km->flag |= KEYMAP_USER_MODIFIED;
+  }
+  km->flag |= KEYMAP_USER | expanded;
+
+  /* apply user changes of diff keymap */
+  if (usermap && (usermap->flag & KEYMAP_DIFF)) {
+    wm_keymap_patch(km, usermap);
+  }
+
+  /* add to list */
+  BLI_addtail(lb, km);
+
+  return km;
+}
+
+static void wm_keymap_diff_update(ListBase *lb,
+                                  wmKeyMap *defaultmap,
+                                  wmKeyMap *addonmap,
+                                  wmKeyMap *km)
+{
+  wmKeyMap *diffmap, *prevmap, *origmap;
+
+  /* create temporary default + addon keymap for diff */
+  origmap = defaultmap;
+
+  if (addonmap) {
+    defaultmap = wm_keymap_copy(defaultmap);
+    wm_keymap_addon_add(defaultmap, addonmap);
+  }
+
+  /* remove previous diff keymap in list, we will replace it */
+  prevmap = WM_keymap_list_find(lb, km->idname, km->spaceid, km->regionid);
+  if (prevmap) {
+    WM_keymap_clear(prevmap);
+    BLI_freelinkN(lb, prevmap);
+  }
+
+  /* create diff keymap */
+  diffmap = wm_keymap_new(km->idname, km->spaceid, km->regionid);
+  diffmap->flag |= KEYMAP_DIFF;
+  if (defaultmap->flag & KEYMAP_MODAL) {
+    diffmap->flag |= KEYMAP_MODAL;
+  }
+  wm_keymap_diff(diffmap, defaultmap, km, origmap, addonmap);
+
+  /* add to list if not empty */
+  if (diffmap->diff_items.first) {
+    BLI_addtail(lb, diffmap);
+  }
+  else {
+    WM_keymap_clear(diffmap);
+    MEM_freeN(diffmap);
+  }
+
+  /* free temporary default map */
+  if (addonmap) {
+    WM_keymap_clear(defaultmap);
+    MEM_freeN(defaultmap);
+  }
 }
 
 /* ****************** storage in WM ************ */
@@ -823,745 +826,812 @@ static void wm_keymap_diff_update(ListBase *lb, wmKeyMap *defaultmap, wmKeyMap *
 
 wmKeyMap *WM_keymap_list_find(ListBase *lb, const char *idname, int spaceid, int regionid)
 {
-	wmKeyMap *km;
+  wmKeyMap *km;
 
-	for (km = lb->first; km; km = km->next) {
-		if (km->spaceid == spaceid && km->regionid == regionid) {
-			if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
-				return km;
-			}
-		}
-	}
+  for (km = lb->first; km; km = km->next) {
+    if (km->spaceid == spaceid && km->regionid == regionid) {
+      if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
+        return km;
+      }
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
 
-wmKeyMap *WM_keymap_list_find_spaceid_or_empty(ListBase *lb, const char *idname, int spaceid, int regionid)
+wmKeyMap *WM_keymap_list_find_spaceid_or_empty(ListBase *lb,
+                                               const char *idname,
+                                               int spaceid,
+                                               int regionid)
 {
-	wmKeyMap *km;
+  wmKeyMap *km;
 
-	for (km = lb->first; km; km = km->next) {
-		if (ELEM(km->spaceid, spaceid, SPACE_EMPTY) && km->regionid == regionid) {
-			if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
-				return km;
-			}
-		}
-	}
+  for (km = lb->first; km; km = km->next) {
+    if (ELEM(km->spaceid, spaceid, SPACE_EMPTY) && km->regionid == regionid) {
+      if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
+        return km;
+      }
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
 
 wmKeyMap *WM_keymap_ensure(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
 {
-	wmKeyMap *km = WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
+  wmKeyMap *km = WM_keymap_list_find(&keyconf->keymaps, idname, spaceid, regionid);
 
-	if (km == NULL) {
-		km = wm_keymap_new(idname, spaceid, regionid);
-		BLI_addtail(&keyconf->keymaps, km);
+  if (km == NULL) {
+    km = wm_keymap_new(idname, spaceid, regionid);
+    BLI_addtail(&keyconf->keymaps, km);
 
-		WM_keyconfig_update_tag(km, NULL);
-	}
+    WM_keyconfig_update_tag(km, NULL);
+  }
 
-	return km;
+  return km;
 }
 
 wmKeyMap *WM_keymap_find_all(const bContext *C, const char *idname, int spaceid, int regionid)
 {
-	wmWindowManager *wm = CTX_wm_manager(C);
+  wmWindowManager *wm = CTX_wm_manager(C);
 
-	return WM_keymap_list_find(&wm->userconf->keymaps, idname, spaceid, regionid);
+  return WM_keymap_list_find(&wm->userconf->keymaps, idname, spaceid, regionid);
 }
 
-wmKeyMap *WM_keymap_find_all_spaceid_or_empty(const bContext *C, const char *idname, int spaceid, int regionid)
+wmKeyMap *WM_keymap_find_all_spaceid_or_empty(const bContext *C,
+                                              const char *idname,
+                                              int spaceid,
+                                              int regionid)
 {
-	wmWindowManager *wm = CTX_wm_manager(C);
+  wmWindowManager *wm = CTX_wm_manager(C);
 
-	return WM_keymap_list_find_spaceid_or_empty(&wm->userconf->keymaps, idname, spaceid, regionid);
+  return WM_keymap_list_find_spaceid_or_empty(&wm->userconf->keymaps, idname, spaceid, regionid);
 }
 
 /* ****************** modal keymaps ************ */
 
 /* modal maps get linked to a running operator, and filter the keys before sending to modal() callback */
 
-wmKeyMap *WM_modalkeymap_add(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items)
+wmKeyMap *WM_modalkeymap_add(wmKeyConfig *keyconf,
+                             const char *idname,
+                             const EnumPropertyItem *items)
 {
-	wmKeyMap *km = WM_keymap_ensure(keyconf, idname, 0, 0);
-	km->flag |= KEYMAP_MODAL;
+  wmKeyMap *km = WM_keymap_ensure(keyconf, idname, 0, 0);
+  km->flag |= KEYMAP_MODAL;
 
-	/* init modal items from default config */
-	wmWindowManager *wm = G_MAIN->wm.first;
-	if (wm->defaultconf && wm->defaultconf != keyconf) {
-		wmKeyMap *defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
+  /* init modal items from default config */
+  wmWindowManager *wm = G_MAIN->wm.first;
+  if (wm->defaultconf && wm->defaultconf != keyconf) {
+    wmKeyMap *defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
 
-		if (defaultkm) {
-			km->modal_items = defaultkm->modal_items;
-			km->poll = defaultkm->poll;
-			km->poll_modal_item = defaultkm->poll_modal_item;
-		}
-	}
+    if (defaultkm) {
+      km->modal_items = defaultkm->modal_items;
+      km->poll = defaultkm->poll;
+      km->poll_modal_item = defaultkm->poll_modal_item;
+    }
+  }
 
-	if (items) {
-		km->modal_items = items;
-	}
+  if (items) {
+    km->modal_items = items;
+  }
 
-	return km;
+  return km;
 }
 
 wmKeyMap *WM_modalkeymap_get(wmKeyConfig *keyconf, const char *idname)
 {
-	wmKeyMap *km;
+  wmKeyMap *km;
 
-	for (km = keyconf->keymaps.first; km; km = km->next) {
-		if (km->flag & KEYMAP_MODAL) {
-			if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
-				break;
-			}
-		}
-	}
+  for (km = keyconf->keymaps.first; km; km = km->next) {
+    if (km->flag & KEYMAP_MODAL) {
+      if (STREQLEN(idname, km->idname, KMAP_MAX_NAME)) {
+        break;
+      }
+    }
+  }
 
-	return km;
+  return km;
 }
 
-
-wmKeyMapItem *WM_modalkeymap_add_item(wmKeyMap *km, int type, int val, int modifier, int keymodifier, int value)
+wmKeyMapItem *WM_modalkeymap_add_item(
+    wmKeyMap *km, int type, int val, int modifier, int keymodifier, int value)
 {
-	wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
+  wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 
-	BLI_addtail(&km->items, kmi);
-	kmi->propvalue = value;
+  BLI_addtail(&km->items, kmi);
+  kmi->propvalue = value;
 
-	keymap_event_set(kmi, type, val, modifier, keymodifier);
+  keymap_event_set(kmi, type, val, modifier, keymodifier);
 
-	keymap_item_set_id(km, kmi);
+  keymap_item_set_id(km, kmi);
 
-	WM_keyconfig_update_tag(km, kmi);
+  WM_keyconfig_update_tag(km, kmi);
 
-	return kmi;
+  return kmi;
 }
 
-wmKeyMapItem *WM_modalkeymap_add_item_str(wmKeyMap *km, int type, int val, int modifier, int keymodifier, const char *value)
+wmKeyMapItem *WM_modalkeymap_add_item_str(
+    wmKeyMap *km, int type, int val, int modifier, int keymodifier, const char *value)
 {
-	wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
+  wmKeyMapItem *kmi = MEM_callocN(sizeof(wmKeyMapItem), "keymap entry");
 
-	BLI_addtail(&km->items, kmi);
-	BLI_strncpy(kmi->propvalue_str, value, sizeof(kmi->propvalue_str));
+  BLI_addtail(&km->items, kmi);
+  BLI_strncpy(kmi->propvalue_str, value, sizeof(kmi->propvalue_str));
 
-	keymap_event_set(kmi, type, val, modifier, keymodifier);
+  keymap_event_set(kmi, type, val, modifier, keymodifier);
 
-	keymap_item_set_id(km, kmi);
+  keymap_item_set_id(km, kmi);
 
-	WM_keyconfig_update_tag(km, kmi);
+  WM_keyconfig_update_tag(km, kmi);
 
-	return kmi;
+  return kmi;
 }
 
-static wmKeyMapItem *wm_modalkeymap_find_propvalue_iter(wmKeyMap *km, wmKeyMapItem *kmi, const int propvalue)
+static wmKeyMapItem *wm_modalkeymap_find_propvalue_iter(wmKeyMap *km,
+                                                        wmKeyMapItem *kmi,
+                                                        const int propvalue)
 {
-	if (km->flag & KEYMAP_MODAL) {
-		kmi = kmi ? kmi->next : km->items.first;
-		for (; kmi; kmi = kmi->next) {
-			if (kmi->propvalue == propvalue) {
-				return kmi;
-			}
-		}
-	}
-	else {
-		BLI_assert(!"called with non modal keymap");
-	}
+  if (km->flag & KEYMAP_MODAL) {
+    kmi = kmi ? kmi->next : km->items.first;
+    for (; kmi; kmi = kmi->next) {
+      if (kmi->propvalue == propvalue) {
+        return kmi;
+      }
+    }
+  }
+  else {
+    BLI_assert(!"called with non modal keymap");
+  }
 
-	return NULL;
+  return NULL;
 }
 
 wmKeyMapItem *WM_modalkeymap_find_propvalue(wmKeyMap *km, const int propvalue)
 {
-	return wm_modalkeymap_find_propvalue_iter(km, NULL, propvalue);
+  return wm_modalkeymap_find_propvalue_iter(km, NULL, propvalue);
 }
 
 void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
 {
-	wmOperatorType *ot = WM_operatortype_find(opname, 0);
+  wmOperatorType *ot = WM_operatortype_find(opname, 0);
 
-	if (ot) {
-		ot->modalkeymap = km;
-	}
-	else {
-		CLOG_ERROR(WM_LOG_KEYMAPS, "unknown operator '%s'", opname);
-	}
+  if (ot) {
+    ot->modalkeymap = km;
+  }
+  else {
+    CLOG_ERROR(WM_LOG_KEYMAPS, "unknown operator '%s'", opname);
+  }
 }
 
 static void wm_user_modal_keymap_set_items(wmWindowManager *wm, wmKeyMap *km)
 {
-	/* here we convert propvalue string values delayed, due to python keymaps
-	 * being created before the actual modal keymaps, so no modal_items */
-	wmKeyMap *defaultkm;
-	wmKeyMapItem *kmi;
-	int propvalue;
+  /* here we convert propvalue string values delayed, due to python keymaps
+   * being created before the actual modal keymaps, so no modal_items */
+  wmKeyMap *defaultkm;
+  wmKeyMapItem *kmi;
+  int propvalue;
 
-	if (km && (km->flag & KEYMAP_MODAL) && !km->modal_items) {
-		if (wm->defaultconf == NULL) {
-			return;
-		}
+  if (km && (km->flag & KEYMAP_MODAL) && !km->modal_items) {
+    if (wm->defaultconf == NULL) {
+      return;
+    }
 
-		defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
+    defaultkm = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, 0, 0);
 
-		if (!defaultkm) {
-			return;
-		}
+    if (!defaultkm) {
+      return;
+    }
 
-		km->modal_items = defaultkm->modal_items;
-		km->poll = defaultkm->poll;
-		km->poll_modal_item = defaultkm->poll_modal_item;
+    km->modal_items = defaultkm->modal_items;
+    km->poll = defaultkm->poll;
+    km->poll_modal_item = defaultkm->poll_modal_item;
 
-		if (km->modal_items) {
-			for (kmi = km->items.first; kmi; kmi = kmi->next) {
-				if (kmi->propvalue_str[0]) {
-					if (RNA_enum_value_from_id(km->modal_items, kmi->propvalue_str, &propvalue)) {
-						kmi->propvalue = propvalue;
-					}
-					kmi->propvalue_str[0] = '\0';
-				}
-			}
-		}
-	}
+    if (km->modal_items) {
+      for (kmi = km->items.first; kmi; kmi = kmi->next) {
+        if (kmi->propvalue_str[0]) {
+          if (RNA_enum_value_from_id(km->modal_items, kmi->propvalue_str, &propvalue)) {
+            kmi->propvalue = propvalue;
+          }
+          kmi->propvalue_str[0] = '\0';
+        }
+      }
+    }
+  }
 }
 
 /* ***************** get string from key events **************** */
 
 const char *WM_key_event_string(const short type, const bool compact)
 {
-	const EnumPropertyItem *it;
-	const int i = RNA_enum_from_value(rna_enum_event_type_items, (int)type);
+  const EnumPropertyItem *it;
+  const int i = RNA_enum_from_value(rna_enum_event_type_items, (int)type);
 
-	if (i == -1) {
-		return "";
-	}
-	it = &rna_enum_event_type_items[i];
+  if (i == -1) {
+    return "";
+  }
+  it = &rna_enum_event_type_items[i];
 
-	/* We first try enum items' description (abused as shortname here), and fall back to usual name if empty. */
-	if (compact && it->description[0]) {
-		/* XXX No context for enum descriptions... In practice shall not be an issue though. */
-		return IFACE_(it->description);
-	}
+  /* We first try enum items' description (abused as shortname here), and fall back to usual name if empty. */
+  if (compact && it->description[0]) {
+    /* XXX No context for enum descriptions... In practice shall not be an issue though. */
+    return IFACE_(it->description);
+  }
 
-	return CTX_IFACE_(BLT_I18NCONTEXT_UI_EVENTS, it->name);
+  return CTX_IFACE_(BLT_I18NCONTEXT_UI_EVENTS, it->name);
 }
 
 /* TODO: also support (some) value, like e.g. double-click? */
-int WM_keymap_item_raw_to_string(
-        const short shift, const short ctrl, const short alt, const short oskey,
-        const short keymodifier, const short val, const short type, const bool compact,
-        char *result, const int result_len)
-{
-#define ADD_SEP if (p != buf) *p++ = ' '; (void)0
-
-	char buf[128];
-	char *p = buf;
-
-	buf[0] = '\0';
-
-	/* TODO: support order (KM_SHIFT vs. KM_SHIFT2) ? */
-	if (shift == KM_ANY &&
-	    ctrl == KM_ANY &&
-	    alt == KM_ANY &&
-	    oskey == KM_ANY)
-	{
-		/* Don't show anything for any mapping. */
-	}
-	else {
-		if (shift) {
-			ADD_SEP;
-			p += BLI_strcpy_rlen(p, IFACE_("Shift"));
-		}
-
-		if (ctrl) {
-			ADD_SEP;
-			p += BLI_strcpy_rlen(p, IFACE_("Ctrl"));
-		}
-
-		if (alt) {
-			ADD_SEP;
-			p += BLI_strcpy_rlen(p, IFACE_("Alt"));
-		}
-
-		if (oskey) {
-			ADD_SEP;
-			p += BLI_strcpy_rlen(p, IFACE_("Cmd"));
-		}
-	}
-
-	if (keymodifier) {
-		ADD_SEP;
-		p += BLI_strcpy_rlen(p, WM_key_event_string(keymodifier, compact));
-	}
-
-	if (type) {
-		ADD_SEP;
-		if (val == KM_DBL_CLICK) {
-			p += BLI_strcpy_rlen(p, IFACE_("dbl-"));
-		}
-		p += BLI_strcpy_rlen(p, WM_key_event_string(type, compact));
-	}
-
-	/* We assume size of buf is enough to always store any possible shortcut, but let's add a debug check about it! */
-	BLI_assert(p - buf < sizeof(buf));
-
-	/* We need utf8 here, otherwise we may 'cut' some unicode chars like arrows... */
-	return BLI_strncpy_utf8_rlen(result, buf, result_len);
+int WM_keymap_item_raw_to_string(const short shift,
+                                 const short ctrl,
+                                 const short alt,
+                                 const short oskey,
+                                 const short keymodifier,
+                                 const short val,
+                                 const short type,
+                                 const bool compact,
+                                 char *result,
+                                 const int result_len)
+{
+#define ADD_SEP \
+  if (p != buf) \
+    *p++ = ' '; \
+  (void)0
+
+  char buf[128];
+  char *p = buf;
+
+  buf[0] = '\0';
+
+  /* TODO: support order (KM_SHIFT vs. KM_SHIFT2) ? */
+  if (shift == KM_ANY && ctrl == KM_ANY && alt == KM_ANY && oskey == KM_ANY) {
+    /* Don't show anything for any mapping. */
+  }
+  else {
+    if (shift) {
+      ADD_SEP;
+      p += BLI_strcpy_rlen(p, IFACE_("Shift"));
+    }
+
+    if (ctrl) {
+      ADD_SEP;
+      p += BLI_strcpy_rlen(p, IFACE_("Ctrl"));
+    }
+
+    if (alt) {
+      ADD_SEP;
+      p += BLI_strcpy_rlen(p, IFACE_("Alt"));
+    }
+
+    if (oskey) {
+      ADD_SEP;
+      p += BLI_strcpy_rlen(p, IFACE_("Cmd"));
+    }
+  }
+
+  if (keymodifier) {
+    ADD_SEP;
+    p += BLI_strcpy_rlen(p, WM_key_event_string(keymodifier, compact));
+  }
+
+  if (type) {
+    ADD_SEP;
+    if (val == KM_DBL_CLICK) {
+      p += BLI_strcpy_rlen(p, IFACE_("dbl-"));
+    }
+    p += BLI_strcpy_rlen(p, WM_key_event_string(type, compact));
+  }
+
+  /* We assume size of buf is enough to always store any possible shortcut, but let's add a debug check about it! */
+  BLI_assert(p - buf < sizeof(buf));
+
+  /* We need utf8 here, otherwise we may 'cut' some unicode chars like arrows... */
+  return BLI_strncpy_utf8_rlen(result, buf, result_len);
 
 #undef ADD_SEP
 }
 
-int WM_keymap_item_to_string(
-        wmKeyMapItem *kmi, const bool compact,
-        char *result, const int result_len)
+int WM_keymap_item_to_string(wmKeyMapItem *kmi,
+                             const bool compact,
+                             char *result,
+                             const int result_len)
 {
-	return WM_keymap_item_raw_to_string(
-	        kmi->shift, kmi->ctrl, kmi->alt, kmi->oskey, kmi->keymodifier, kmi->val, kmi->type,
-	        compact, result, result_len);
+  return WM_keymap_item_raw_to_string(kmi->shift,
+                                      kmi->ctrl,
+                                      kmi->alt,
+                                      kmi->oskey,
+                                      kmi->keymodifier,
+                                      kmi->val,
+                                      kmi->type,
+                                      compact,
+                                      result,
+                                      result_len);
 }
 
 int WM_modalkeymap_items_to_string(
-        wmKeyMap *km, const int propvalue, const bool compact,
-        char *result, const int result_len)
-{
-	int totlen = 0;
-	bool add_sep = false;
-
-	if (km) {
-		wmKeyMapItem *kmi;
-
-		/* Find all shortcuts related to that propvalue! */
-		for (kmi = WM_modalkeymap_find_propvalue(km, propvalue);
-		     kmi && totlen < (result_len - 2);
-		     kmi = wm_modalkeymap_find_propvalue_iter(km, kmi, propvalue))
-		{
-			if (add_sep) {
-				result[totlen++] = '/';
-				result[totlen] = '\0';
-			}
-			else {
-				add_sep = true;
-			}
-			totlen += WM_keymap_item_to_string(kmi, compact, &result[totlen], result_len - totlen);
-		}
-	}
-
-	return totlen;
-}
-
-int WM_modalkeymap_operator_items_to_string(
-        wmOperatorType *ot, const int propvalue, const bool compact,
-        char *result, const int result_len)
-{
-	return WM_modalkeymap_items_to_string(ot->modalkeymap, propvalue, compact, result, result_len);
-}
-
-char *WM_modalkeymap_operator_items_to_string_buf(
-        wmOperatorType *ot, const int propvalue, const bool compact,
-        const int max_len, int *r_available_len, char **r_result)
-{
-	char *ret = *r_result;
-
-	if (*r_available_len > 1) {
-		int used_len = WM_modalkeymap_operator_items_to_string(
-		        ot, propvalue, compact, ret, min_ii(*r_available_len, max_len)) + 1;
-
-		*r_available_len -= used_len;
-		*r_result += used_len;
-		if (*r_available_len == 0) {
-			(*r_result)--;  /* So that *result keeps pointing on a valid char, we'll stay on it anyway. */
-		}
-	}
-	else {
-		*ret = '\0';
-	}
-
-	return ret;
-}
-
-static wmKeyMapItem *wm_keymap_item_find_in_keymap(
-        wmKeyMap *keymap, const char *opname,
-        IDProperty *properties, const bool is_strict,
-        const struct wmKeyMapItemFind_Params *params)
-{
-	for (wmKeyMapItem *kmi = keymap->items.first; kmi; kmi = kmi->next) {
-		/* skip disabled keymap items [T38447] */
-		if (kmi->flag & KMI_INACTIVE) {
-			continue;
-		}
-
-		bool kmi_match = false;
-
-		if (STREQ(kmi->idname, opname)) {
-			if (properties) {
-				/* example of debugging keymaps */
+    wmKeyMap *km, const int propvalue, const bool compact, char *result, const int result_len)
+{
+  int totlen = 0;
+  bool add_sep = false;
+
+  if (km) {
+    wmKeyMapItem *kmi;
+
+    /* Find all shortcuts related to that propvalue! */
+    for (kmi = WM_modalkeymap_find_propvalue(km, propvalue); kmi && totlen < (result_len - 2);
+         kmi = wm_modalkeymap_find_propvalue_iter(km, kmi, propvalue)) {
+      if (add_sep) {
+        result[totlen++] = '/';
+        result[totlen] = '\0';
+      }
+      else {
+        add_sep = true;
+      }
+      totlen += WM_keymap_item_to_string(kmi, compact, &result[totlen], result_len - totlen);
+    }
+  }
+
+  return totlen;
+}
+
+int WM_modalkeymap_operator_items_to_string(wmOperatorType *ot,
+                                            const int propvalue,
+                                            const bool compact,
+                                            char *result,
+                                            const int result_len)
+{
+  return WM_modalkeymap_items_to_string(ot->modalkeymap, propvalue, compact, result, result_len);
+}
+
+char *WM_modalkeymap_operator_items_to_string_buf(wmOperatorType *ot,
+                                                  const int propvalue,
+                                                  const bool compact,
+                                                  const int max_len,
+                                                  int *r_available_len,
+                                                  char **r_result)
+{
+  char *ret = *r_result;
+
+  if (*r_available_len > 1) {
+    int used_len = WM_modalkeymap_operator_items_to_string(
+                       ot, propvalue, compact, ret, min_ii(*r_available_len, max_len)) +
+                   1;
+
+    *r_available_len -= used_len;
+    *r_result += used_len;
+    if (*r_available_len == 0) {
+      (*r_result)--; /* So that *result keeps pointing on a valid char, we'll stay on it anyway. */
+    }
+  }
+  else {
+    *ret = '\0';
+  }
+
+  return ret;
+}
+
+static wmKeyMapItem *wm_keymap_item_find_in_keymap(wmKeyMap *keymap,
+                                                   const char *opname,
+                                                   IDProperty *properties,
+                                                   const bool is_strict,
+                                                   const struct wmKeyMapItemFind_Params *params)
+{
+  for (wmKeyMapItem *kmi = keymap->items.first; kmi; kmi = kmi->next) {
+    /* skip disabled keymap items [T38447] */
+    if (kmi->flag & KMI_INACTIVE) {
+      continue;
+    }
+
+    bool kmi_match = false;
+
+    if (STREQ(kmi->idname, opname)) {
+      if (properties) {
+        /* example of debugging keymaps */
 #if 0
-				if (kmi->ptr) {
-					if (STREQ("MESH_OT_rip_move", opname)) {
-						printf("OPERATOR\n");
-						IDP_print(properties);
-						printf("KEYMAP\n");
-						IDP_print(kmi->ptr->data);
-					}
-				}
+        if (kmi->ptr) {
+          if (STREQ("MESH_OT_rip_move", opname)) {
+            printf("OPERATOR\n");
+            IDP_print(properties);
+            printf("KEYMAP\n");
+            IDP_print(kmi->ptr->data);
+          }
+        }
 #endif
 
-				if (kmi->ptr && IDP_EqualsProperties_ex(properties, kmi->ptr->data, is_strict)) {
-					kmi_match = true;
-				}
-				/* Debug only, helps spotting mismatches between menu entries and shortcuts! */
-				else if (G.debug & G_DEBUG_WM) {
-					if (is_strict && kmi->ptr) {
-						wmOperatorType *ot = WM_operatortype_find(opname, true);
-						if (ot) {
-							/* make a copy of the properties and set unset ones to their default values. */
-							PointerRNA opptr;
-							IDProperty *properties_default = IDP_CopyProperty(kmi->ptr->data);
-
-							RNA_pointer_create(NULL, ot->srna, properties_default, &opptr);
-							WM_operator_properties_default(&opptr, true);
-
-							if (IDP_EqualsProperties_ex(properties, properties_default, is_strict)) {
-								char kmi_str[128];
-								WM_keymap_item_to_string(kmi, false, kmi_str, sizeof(kmi_str));
-								/* Note gievn properties could come from other things than menu entry... */
-								printf("%s: Some set values in menu entry match default op values, "
-								       "this might not be desired!\n", opname);
-								printf("\tkm: '%s', kmi: '%s'\n", keymap->idname, kmi_str);
+        if (kmi->ptr && IDP_EqualsProperties_ex(properties, kmi->ptr->data, is_strict)) {
+          kmi_match = true;
+        }
+        /* Debug only, helps spotting mismatches between menu entries and shortcuts! */
+        else if (G.debug & G_DEBUG_WM) {
+          if (is_strict && kmi->ptr) {
+            wmOperatorType *ot = WM_operatortype_find(opname, true);
+            if (ot) {
+              /* make a copy of the properties and set unset ones to their default values. */
+              PointerRNA opptr;
+              IDProperty *properties_default = IDP_CopyProperty(kmi->ptr->data);
+
+              RNA_pointer_create(NULL, ot->srna, properties_default, &opptr);
+              WM_operator_properties_default(&opptr, true);
+
+              if (IDP_EqualsProperties_ex(properties, properties_default, is_strict)) {
+                char kmi_str[128];
+                WM_keymap_item_to_string(kmi, false, kmi_str, sizeof(kmi_str));
+                /* Note gievn properties could come from other things than menu entry... */
+                printf(
+                    "%s: Some set values in menu entry match default op values, "
+                    "this might not be desired!\n",
+                    opname);
+                printf("\tkm: '%s', kmi: '%s'\n", keymap->idname, kmi_str);
 #ifndef NDEBUG
-#ifdef WITH_PYTHON
-								printf("OPERATOR\n");
-								IDP_print(properties);
-								printf("KEYMAP\n");
-								IDP_print(kmi->ptr->data);
-#endif
+#  ifdef WITH_PYTHON
+                printf("OPERATOR\n");
+                IDP_print(properties);
+                printf("KEYMAP\n");
+                IDP_print(kmi->ptr->data);
+#  endif
 #endif
-								printf("\n");
-							}
-
-							IDP_FreeProperty(properties_default);
-							MEM_freeN(properties_default);
-						}
-					}
-				}
-			}
-			else {
-				kmi_match = true;
-			}
-
-			if (kmi_match) {
-				if ((params == NULL) || params->filter_fn(keymap, kmi, params->user_data)) {
-					return kmi;
-				}
-			}
-		}
-	}
-	return NULL;
-}
-
-static wmKeyMapItem *wm_keymap_item_find_handlers(
-        const bContext *C, ListBase *handlers, const char *opname, int UNUSED(opcontext),
-        IDProperty *properties, const bool is_strict,
-        const struct wmKeyMapItemFind_Params *params,
-        wmKeyMap **r_keymap)
-{
-	wmWindowManager *wm = CTX_wm_manager(C);
-
-	/* find keymap item in handlers */
-	LISTBASE_FOREACH (wmEventHandler *, handler_base, handlers) {
-		if (handler_base->type == WM_HANDLER_TYPE_KEYMAP) {
-			wmEventHandler_Keymap *handler = (wmEventHandler_Keymap *)handler_base;
-			wmKeyMap *keymap = WM_event_get_keymap_from_handler(wm, handler);
-			if (keymap && WM_keymap_poll((bContext *)C, keymap)) {
-				wmKeyMapItem *kmi = wm_keymap_item_find_in_keymap(
-				        keymap, opname, properties, is_strict, params);
-				if (kmi != NULL) {
-					if (r_keymap) {
-						*r_keymap = keymap;
-					}
-					return kmi;
-				}
-			}
-		}
-	}
-	/* ensure un-initialized keymap is never used */
-	if (r_keymap) {
-		*r_keymap = NULL;
-	}
-	return NULL;
-}
-
-static wmKeyMapItem *wm_keymap_item_find_props(
-        const bContext *C, const char *opname, int opcontext,
-        IDProperty *properties, const bool is_strict,
-        const struct wmKeyMapItemFind_Params *params,
-        wmKeyMap **r_keymap)
-{
-	wmWindow *win = CTX_wm_window(C);
-	ScrArea *sa = CTX_wm_area(C);
-	ARegion *ar = CTX_wm_region(C);
-	wmKeyMapItem *found = NULL;
-
-	/* look into multiple handler lists to find the item */
-	if (win) {
-		found = wm_keymap_item_find_handlers(
-		        C, &win->modalhandlers, opname, opcontext, properties, is_strict, params, r_keymap);
-		if (found == NULL) {
-			found = wm_keymap_item_find_handlers(
-			        C, &win->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
-		}
-	}
-
-	if (sa && found == NULL) {
-		found = wm_keymap_item_find_handlers(C, &sa->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
-	}
-
-	if (found == NULL) {
-		if (ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) {
-			if (sa) {
-				if (!(ar && ar->regiontype == RGN_TYPE_WINDOW)) {
-					ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
-				}
-
-				if (ar) {
-					found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
-				}
-			}
-		}
-		else if (ELEM(opcontext, WM_OP_EXEC_REGION_CHANNELS, WM_OP_INVOKE_REGION_CHANNELS)) {
-			if (!(ar && ar->regiontype == RGN_TYPE_CHANNELS)) {
-				ar = BKE_area_find_region_type(sa, RGN_TYPE_CHANNELS);
-			}
-
-			if (ar) {
-				found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
-			}
-		}
-		else if (ELEM(opcontext, WM_OP_EXEC_REGION_PREVIEW, WM_OP_INVOKE_REGION_PREVIEW)) {
-			if (!(ar && ar->regiontype == RGN_TYPE_PREVIEW)) {
-				ar = BKE_area_find_region_type(sa, RGN_TYPE_PREVIEW);
-			}
-
-			if (ar) {
-				found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
-			}
-		}
-		else {
-			if (ar) {
-				found = wm_keymap_item_find_handlers(C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
-			}
-		}
-	}
-
-	return found;
-}
-
-static wmKeyMapItem *wm_keymap_item_find(
-        const bContext *C, const char *opname, int opcontext,
-        IDProperty *properties, bool is_strict,
-        const struct wmKeyMapItemFind_Params *params,
-        wmKeyMap **r_keymap)
-{
-	wmKeyMapItem *found;
-
-	/* XXX Hack! Macro operators in menu entry have their whole props defined, which is not the case for
-	 *     relevant keymap entries. Could be good to check and harmonize this, but for now always
-	 *     compare non-strict in this case.
-	 */
-	wmOperatorType *ot = WM_operatortype_find(opname, true);
-	if (ot) {
-		is_strict = is_strict && ((ot->flag & OPTYPE_MACRO) == 0);
-	}
-
-	found = wm_keymap_item_find_props(C, opname, opcontext, properties, is_strict, params, r_keymap);
-
-	/* This block is *only* useful in one case: when op uses an enum menu in its prop member
-	 * (then, we want to rerun a comparison with that 'prop' unset). Note this remains brittle,
-	 * since now any enum prop may be used in UI (specified by name), ot->prop is not so much used...
-	 * Otherwise:
-	 *     * If non-strict, unset properties always match set ones in IDP_EqualsProperties_ex.
-	 *     * If strict, unset properties never match set ones in IDP_EqualsProperties_ex,
-	 *       and we do not want that to change (else we get things like T41757)!
-	 * ...so in either case, re-running a comparison with unset props set to default is useless.
-	 */
-	if (!found && properties) {
-		if (ot && ot->prop) {  /* XXX Shall we also check ot->prop is actually an enum? */
-			/* make a copy of the properties and unset the 'ot->prop' one if set. */
-			PointerRNA opptr;
-			IDProperty *properties_temp = IDP_CopyProperty(properties);
-
-			RNA_pointer_create(NULL, ot->srna, properties_temp, &opptr);
-
-			if (RNA_property_is_set(&opptr, ot->prop)) {
-				/* for operator that has enum menu, unset it so its value does not affect comparison result */
-				RNA_property_unset(&opptr, ot->prop);
-
-				found = wm_keymap_item_find_props(C, opname, opcontext, properties_temp, is_strict, params, r_keymap);
-			}
-
-			IDP_FreeProperty(properties_temp);
-			MEM_freeN(properties_temp);
-		}
-	}
-
-	/* Debug only, helps spotting mismatches between menu entries and shortcuts! */
-	if (G.debug & G_DEBUG_WM) {
-		if (!found && is_strict && properties) {
-			wmKeyMap *km;
-			wmKeyMapItem *kmi;
-			if (ot) {
-				/* make a copy of the properties and set unset ones to their default values. */
-				PointerRNA opptr;
-				IDProperty *properties_default = IDP_CopyProperty(properties);
-
-				RNA_pointer_create(NULL, ot->srna, properties_default, &opptr);
-				WM_operator_properties_default(&opptr, true);
-
-				kmi = wm_keymap_item_find_props(C, opname, opcontext, properties_default, is_strict, params, &km);
-				if (kmi) {
-					char kmi_str[128];
-					WM_keymap_item_to_string(kmi, false, kmi_str, sizeof(kmi_str));
-					printf("%s: Some set values in keymap entry match default op values, "
-					       "this might not be desired!\n", opname);
-					printf("\tkm: '%s', kmi: '%s'\n", km->idname, kmi_str);
+                printf("\n");
+              }
+
+              IDP_FreeProperty(properties_default);
+              MEM_freeN(properties_default);
+            }
+          }
+        }
+      }
+      else {
+        kmi_match = true;
+      }
+
+      if (kmi_match) {
+        if ((params == NULL) || params->filter_fn(keymap, kmi, params->user_data)) {
+          return kmi;
+        }
+      }
+    }
+  }
+  return NULL;
+}
+
+static wmKeyMapItem *wm_keymap_item_find_handlers(const bContext *C,
+                                                  ListBase *handlers,
+                                                  const char *opname,
+                                                  int UNUSED(opcontext),
+                                                  IDProperty *properties,
+                                                  const bool is_strict,
+                                                  const struct wmKeyMapItemFind_Params *params,
+                                                  wmKeyMap **r_keymap)
+{
+  wmWindowManager *wm = CTX_wm_manager(C);
+
+  /* find keymap item in handlers */
+  LISTBASE_FOREACH (wmEventHandler *, handler_base, handlers) {
+    if (handler_base->type == WM_HANDLER_TYPE_KEYMAP) {
+      wmEventHandler_Keymap *handler = (wmEventHandler_Keymap *)handler_base;
+      wmKeyMap *keymap = WM_event_get_keymap_from_handler(wm, handler);
+      if (keymap && WM_keymap_poll((bContext *)C, keymap)) {
+        wmKeyMapItem *kmi = wm_keymap_item_find_in_keymap(
+            keymap, opname, properties, is_strict, params);
+        if (kmi != NULL) {
+          if (r_keymap) {
+            *r_keymap = keymap;
+          }
+          return kmi;
+        }
+      }
+    }
+  }
+  /* ensure un-initialized keymap is never used */
+  if (r_keymap) {
+    *r_keymap = NULL;
+  }
+  return NULL;
+}
+
+static wmKeyMapItem *wm_keymap_item_find_props(const bContext *C,
+                                               const char *opname,
+                                               int opcontext,
+                                               IDProperty *properties,
+                                               const bool is_strict,
+                                               const struct wmKeyMapItemFind_Params *params,
+                                               wmKeyMap **r_keymap)
+{
+  wmWindow *win = CTX_wm_window(C);
+  ScrArea *sa = CTX_wm_area(C);
+  ARegion *ar = CTX_wm_region(C);
+  wmKeyMapItem *found = NULL;
+
+  /* look into multiple handler lists to find the item */
+  if (win) {
+    found = wm_keymap_item_find_handlers(
+        C, &win->modalhandlers, opname, opcontext, properties, is_strict, params, r_keymap);
+    if (found == NULL) {
+      found = wm_keymap_item_find_handlers(
+          C, &win->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
+    }
+  }
+
+  if (sa && found == NULL) {
+    found = wm_keymap_item_find_handlers(
+        C, &sa->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
+  }
+
+  if (found == NULL) {
+    if (ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) {
+      if (sa) {
+        if (!(ar && ar->regiontype == RGN_TYPE_WINDOW)) {
+          ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
+        }
+
+        if (ar) {
+          found = wm_keymap_item_find_handlers(
+              C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
+        }
+      }
+    }
+    else if (ELEM(opcontext, WM_OP_EXEC_REGION_CHANNELS, WM_OP_INVOKE_REGION_CHANNELS)) {
+      if (!(ar && ar->regiontype == RGN_TYPE_CHANNELS)) {
+        ar = BKE_area_find_region_type(sa, RGN_TYPE_CHANNELS);
+      }
+
+      if (ar) {
+        found = wm_keymap_item_find_handlers(
+            C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
+      }
+    }
+    else if (ELEM(opcontext, WM_OP_EXEC_REGION_PREVIEW, WM_OP_INVOKE_REGION_PREVIEW)) {
+      if (!(ar && ar->regiontype == RGN_TYPE_PREVIEW)) {
+        ar = BKE_area_find_region_type(sa, RGN_TYPE_PREVIEW);
+      }
+
+      if (ar) {
+        found = wm_keymap_item_find_handlers(
+            C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
+      }
+    }
+    else {
+      if (ar) {
+        found = wm_keymap_item_find_handlers(
+            C, &ar->handlers, opname, opcontext, properties, is_strict, params, r_keymap);
+      }
+    }
+  }
+
+  return found;
+}
+
+static wmKeyMapItem *wm_keymap_item_find(const bContext *C,
+                                         const char *opname,
+                                         int opcontext,
+                                         IDProperty *properties,
+                                         bool is_strict,
+                                         const struct wmKeyMapItemFind_Params *params,
+                                         wmKeyMap **r_keymap)
+{
+  wmKeyMapItem *found;
+
+  /* XXX Hack! Macro operators in menu entry have their whole props defined, which is not the case for
+   *     relevant keymap entries. Could be good to check and harmonize this, but for now always
+   *     compare non-strict in this case.
+   */
+  wmOperatorType *ot = WM_operatortype_find(opname, true);
+  if (ot) {
+    is_strict = is_strict && ((ot->flag & OPTYPE_MACRO) == 0);
+  }
+
+  found = wm_keymap_item_find_props(C, opname, opcontext, properties, is_strict, params, r_keymap);
+
+  /* This block is *only* useful in one case: when op uses an enum menu in its prop member
+   * (then, we want to rerun a comparison with that 'prop' unset). Note this remains brittle,
+   * since now any enum prop may be used in UI (specified by name), ot->prop is not so much used...
+   * Otherwise:
+   *     * If non-strict, unset properties always match set ones in IDP_EqualsProperties_ex.
+   *     * If strict, unset properties never match set ones in IDP_EqualsProperties_ex,
+   *       and we do not want that to change (else we get things like T41757)!
+   * ...so in either case, re-running a comparison with unset props set to default is useless.
+   */
+  if (!found && properties) {
+    if (ot && ot->prop) { /* XXX Shall we also check ot->prop is actually an enum? */
+      /* make a copy of the properties and unset the 'ot->prop' one if set. */
+      PointerRNA opptr;
+      IDProperty *properties_temp = IDP_CopyProperty(properties);
+
+      RNA_pointer_create(NULL, ot->srna, properties_temp, &opptr);
+
+      if (RNA_property_is_set(&opptr, ot->prop)) {
+        /* for operator that has enum menu, unset it so its value does not affect comparison result */
+        RNA_property_unset(&opptr, ot->prop);
+
+        found = wm_keymap_item_find_props(
+            C, opname, opcontext, properties_temp, is_strict, params, r_keymap);
+      }
+
+      IDP_FreeProperty(properties_temp);
+      MEM_freeN(properties_temp);
+    }
+  }
+
+  /* Debug only, helps spotting mismatches between menu entries and shortcuts! */
+  if (G.debug & G_DEBUG_WM) {
+    if (!found && is_strict && properties) {
+      wmKeyMap *km;
+      wmKeyMapItem *kmi;
+      if (ot) {
+        /* make a copy of the properties and set unset ones to their default values. */
+        PointerRNA opptr;
+        IDProperty *properties_default = IDP_CopyProperty(properties);
+
+        RNA_pointer_create(NULL, ot->srna, properties_default, &opptr);
+        WM_operator_properties_default(&opptr, true);
+
+        kmi = wm_keymap_item_find_props(
+            C, opname, opcontext, properties_default, is_strict, params, &km);
+        if (kmi) {
+          char kmi_str[128];
+          WM_keymap_item_to_string(kmi, false, kmi_str, sizeof(kmi_str));
+          printf(
+              "%s: Some set values in keymap entry match default op values, "
+              "this might not be desired!\n",
+              opname);
+          printf("\tkm: '%s', kmi: '%s'\n", km->idname, kmi_str);
 #ifndef NDEBUG
-#ifdef WITH_PYTHON
-					printf("OPERATOR\n");
-					IDP_print(properties);
-					printf("KEYMAP\n");
-					IDP_print(kmi->ptr->data);
-#endif
+#  ifdef WITH_PYTHON
+          printf("OPERATOR\n");
+          IDP_print(properties);
+          printf("KEYMAP\n");
+          IDP_print(kmi->ptr->data);
+#  endif
 #endif
-					printf("\n");
-				}
+          printf("\n");
+        }
 
-				IDP_FreeProperty(properties_default);
-				MEM_freeN(properties_default);
-			}
-		}
-	}
+        IDP_FreeProperty(properties_default);
+        MEM_freeN(properties_default);
+      }
+    }
+  }
 
-	return found;
+  return found;
 }
 
-static bool kmi_filter_is_visible(const wmKeyMap *UNUSED(km), const wmKeyMapItem *kmi, void *UNUSED(user_data))
+static bool kmi_filter_is_visible(const wmKeyMap *UNUSED(km),
+                                  const wmKeyMapItem *kmi,
+                                  void *UNUSED(user_data))
 {
-	return ((WM_key_event_string(kmi->type, false)[0] != '\0') &&
-	        (IS_EVENT_ACTIONZONE(kmi->type) == false));
+  return ((WM_key_event_string(kmi->type, false)[0] != '\0') &&
+          (IS_EVENT_ACTIONZONE(kmi->type) == false));
 }
 
-char *WM_key_event_operator_string(
-        const bContext *C, const char *opname, int opcontext,
-        IDProperty *properties, const bool is_strict,
-        char *result, const int result_len)
+char *WM_key_event_operator_string(const bContext *C,
+                                   const char *opname,
+                                   int opcontext,
+                                   IDProperty *properties,
+                                   const bool is_strict,
+                                   char *result,
+                                   const int result_len)
 {
-	wmKeyMapItem *kmi = wm_keymap_item_find(
-	        C, opname, opcontext, properties, is_strict,
-	        &(struct wmKeyMapItemFind_Params){
-	            .filter_fn = kmi_filter_is_visible,
-	            .user_data = NULL,
-	        },
-	        NULL);
-	if (kmi) {
-		WM_keymap_item_to_string(kmi, false, result, result_len);
-		return result;
-	}
+  wmKeyMapItem *kmi = wm_keymap_item_find(C,
+                                          opname,
+                                          opcontext,
+                                          properties,
+                                          is_strict,
+                                          &(struct wmKeyMapItemFind_Params){
+                                              .filter_fn = kmi_filter_is_visible,
+                                              .user_data = NULL,
+                                          },
+                                          NULL);
+  if (kmi) {
+    WM_keymap_item_to_string(kmi, false, result, result_len);
+    return result;
+  }
 
-	return NULL;
+  return NULL;
 }
 
-static bool kmi_filter_is_visible_type_mask(const wmKeyMap *km, const wmKeyMapItem *kmi, void *user_data)
+static bool kmi_filter_is_visible_type_mask(const wmKeyMap *km,
+                                            const wmKeyMapItem *kmi,
+                                            void *user_data)
 {
-	short *mask_pair = user_data;
-	return ((WM_event_type_mask_test(kmi->type, mask_pair[0]) == true) &&
-	        (WM_event_type_mask_test(kmi->type, mask_pair[1]) == false) &&
-	        kmi_filter_is_visible(km, kmi, user_data));
+  short *mask_pair = user_data;
+  return ((WM_event_type_mask_test(kmi->type, mask_pair[0]) == true) &&
+          (WM_event_type_mask_test(kmi->type, mask_pair[1]) == false) &&
+          kmi_filter_is_visible(km, kmi, user_data));
 }
 
 /**
  * \param include_mask, exclude_mask: Event types to include/exclude when looking up keys (#eEventType_Mask).
  */
-wmKeyMapItem *WM_key_event_operator(
-        const bContext *C, const char *opname, int opcontext, IDProperty *properties,
-        const short include_mask, const short exclude_mask,
-        wmKeyMap **r_keymap)
-{
-	short user_data_mask[2] = {include_mask, exclude_mask};
-	bool use_mask = (include_mask != EVT_TYPE_MASK_ALL) || (exclude_mask != 0);
-	return wm_keymap_item_find(
-	        C, opname, opcontext, properties, true,
-	        &(struct wmKeyMapItemFind_Params){
-	            .filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible,
-	            .user_data = use_mask ? user_data_mask : NULL,
-	        },
-	        r_keymap);
+wmKeyMapItem *WM_key_event_operator(const bContext *C,
+                                    const char *opname,
+                                    int opcontext,
+                                    IDProperty *properties,
+                                    const short include_mask,
+                                    const short exclude_mask,
+                                    wmKeyMap **r_keymap)
+{
+  short user_data_mask[2] = {include_mask, exclude_mask};
+  bool use_mask = (include_mask != EVT_TYPE_MASK_ALL) || (exclude_mask != 0);
+  return wm_keymap_item_find(
+      C,
+      opname,
+      opcontext,
+      properties,
+      true,
+      &(struct wmKeyMapItemFind_Params){
+          .filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible,
+          .user_data = use_mask ? user_data_mask : NULL,
+      },
+      r_keymap);
+}
+
+wmKeyMapItem *WM_key_event_operator_from_keymap(wmKeyMap *keymap,
+                                                const char *opname,
+                                                IDProperty *properties,
+                                                const short include_mask,
+                                                const short exclude_mask)
+{
+  short user_data_mask[2] = {include_mask, exclude_mask};
+  bool use_mask = (include_mask != EVT_TYPE_MASK_ALL) || (exclude_mask != 0);
+  return wm_keymap_item_find_in_keymap(
+      keymap,
+      opname,
+      properties,
+      true,
+      &(struct wmKeyMapItemFind_Params){
+          .filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible,
+          .user_data = use_mask ? user_data_mask : NULL,
+      });
 }
 
-wmKeyMapItem *WM_key_event_operator_from_keymap(
-        wmKeyMap *keymap, const char *opname, IDProperty *properties,
-        const short include_mask, const short exclude_mask)
-{
-	short user_data_mask[2] = {include_mask, exclude_mask};
-	bool use_mask = (include_mask != EVT_TYPE_MASK_ALL) || (exclude_mask != 0);
-	return wm_keymap_item_find_in_keymap(
-	        keymap, opname, properties, true,
-	        &(struct wmKeyMapItemFind_Params){
-	            .filter_fn = use_mask ? kmi_filter_is_visible_type_mask : kmi_filter_is_visible,
-	            .user_data = use_mask ? user_data_mask : NULL,
-	        });
-}
-
-
 bool WM_keymap_item_compare(wmKeyMapItem *k1, wmKeyMapItem *k2)
 {
-	int k1type, k2type;
+  int k1type, k2type;
 
-	if (k1->flag & KMI_INACTIVE || k2->flag & KMI_INACTIVE) {
-		return 0;
-	}
+  if (k1->flag & KMI_INACTIVE || k2->flag & KMI_INACTIVE) {
+    return 0;
+  }
 
-	/* take event mapping into account */
-	k1type = WM_userdef_event_map(k1->type);
-	k2type = WM_userdef_event_map(k2->type);
+  /* take event mapping into account */
+  k1type = WM_userdef_event_map(k1->type);
+  k2type = WM_userdef_event_map(k2->type);
 
-	if (k1type != KM_ANY && k2type != KM_ANY && k1type != k2type) {
-		return 0;
-	}
+  if (k1type != KM_ANY && k2type != KM_ANY && k1type != k2type) {
+    return 0;
+  }
 
-	if (k1->val != KM_ANY && k2->val != KM_ANY) {
-		/* take click, press, release conflict into account */
-		if (k1->val == KM_CLICK && ELEM(k2->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0) {
-			return 0;
-		}
-		if (k2->val == KM_CLICK && ELEM(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0) {
-			return 0;
-		}
-		if (k1->val != k2->val) {
-			return 0;
-		}
-	}
+  if (k1->val != KM_ANY && k2->val != KM_ANY) {
+    /* take click, press, release conflict into account */
+    if (k1->val == KM_CLICK && ELEM(k2->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0) {
+      return 0;
+    }
+    if (k2->val == KM_CLICK && ELEM(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0) {
+      return 0;
+    }
+    if (k1->val != k2->val) {
+      return 0;
+    }
+  }
 
-	if (k1->shift != KM_ANY && k2->shift != KM_ANY && k1->shift != k2->shift) {
-		return 0;
-	}
+  if (k1->shift != KM_ANY && k2->shift != KM_ANY && k1->shift != k2->shift) {
+    return 0;
+  }
 
-	if (k1->ctrl != KM_ANY && k2->ctrl != KM_ANY && k1->ctrl != k2->ctrl) {
-		return 0;
-	}
+  if (k1->ctrl != KM_ANY && k2->ctrl != KM_ANY && k1->ctrl != k2->ctrl) {
+    return 0;
+  }
 
-	if (k1->alt != KM_ANY && k2->alt != KM_ANY && k1->alt != k2->alt) {
-		return 0;
-	}
+  if (k1->alt != KM_ANY && k2->alt != KM_ANY && k1->alt != k2->alt) {
+    return 0;
+  }
 
-	if (k1->oskey != KM_ANY && k2->oskey != KM_ANY && k1->oskey != k2->oskey) {
-		return 0;
-	}
+  if (k1->oskey != KM_ANY && k2->oskey != KM_ANY && k1->oskey != k2->oskey) {
+    return 0;
+  }
 
-	if (k1->keymodifier != k2->keymodifier) {
-		return 0;
-	}
+  if (k1->keymodifier != k2->keymodifier) {
+    return 0;
+  }
 
-	return 1;
+  return 1;
 }
 
 /************************* Update Final Configuration *************************
@@ -1571,171 +1641,170 @@ bool WM_keymap_item_compare(wmKeyMapItem *k1, wmKeyMapItem *k2)
 
 /* so operator removal can trigger update */
 enum {
-	WM_KEYMAP_UPDATE_RECONFIGURE    = (1 << 0),
+  WM_KEYMAP_UPDATE_RECONFIGURE = (1 << 0),
 
-	/* ensure all wmKeyMap have their operator types validated after removing an operator */
-	WM_KEYMAP_UPDATE_OPERATORTYPE   = (1 << 1),
+  /* ensure all wmKeyMap have their operator types validated after removing an operator */
+  WM_KEYMAP_UPDATE_OPERATORTYPE = (1 << 1),
 };
 
 static char wm_keymap_update_flag = 0;
 
 void WM_keyconfig_update_tag(wmKeyMap *km, wmKeyMapItem *kmi)
 {
-	/* quick tag to do delayed keymap updates */
-	wm_keymap_update_flag |= WM_KEYMAP_UPDATE_RECONFIGURE;
+  /* quick tag to do delayed keymap updates */
+  wm_keymap_update_flag |= WM_KEYMAP_UPDATE_RECONFIGURE;
 
-	if (km) {
-		km->flag |= KEYMAP_UPDATE;
-	}
-	if (kmi) {
-		kmi->flag |= KMI_UPDATE;
-	}
+  if (km) {
+    km->flag |= KEYMAP_UPDATE;
+  }
+  if (kmi) {
+    kmi->flag |= KMI_UPDATE;
+  }
 }
 
 void WM_keyconfig_update_operatortype(void)
 {
-	wm_keymap_update_flag |= WM_KEYMAP_UPDATE_OPERATORTYPE;
+  wm_keymap_update_flag |= WM_KEYMAP_UPDATE_OPERATORTYPE;
 }
 
 static bool wm_keymap_test_and_clear_update(wmKeyMap *km)
 {
-	wmKeyMapItem *kmi;
-	int update;
+  wmKeyMapItem *kmi;
+  int update;
 
-	update = (km->flag & KEYMAP_UPDATE);
-	km->flag &= ~KEYMAP_UPDATE;
+  update = (km->flag & KEYMAP_UPDATE);
+  km->flag &= ~KEYMAP_UPDATE;
 
-	for (kmi = km->items.first; kmi; kmi = kmi->next) {
-		update = update || (kmi->flag & KMI_UPDATE);
-		kmi->flag &= ~KMI_UPDATE;
-	}
+  for (kmi = km->items.first; kmi; kmi = kmi->next) {
+    update = update || (kmi->flag & KMI_UPDATE);
+    kmi->flag &= ~KMI_UPDATE;
+  }
 
-	return (update != 0);
+  return (update != 0);
 }
 
 static wmKeyMap *wm_keymap_preset(wmWindowManager *wm, wmKeyMap *km)
 {
-	wmKeyConfig *keyconf = WM_keyconfig_active(wm);
-	wmKeyMap *keymap;
+  wmKeyConfig *keyconf = WM_keyconfig_active(wm);
+  wmKeyMap *keymap;
 
-	keymap = WM_keymap_list_find(&keyconf->keymaps, km->idname, km->spaceid, km->regionid);
-	if (!keymap && wm->defaultconf) {
-		keymap = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, km->spaceid, km->regionid);
-	}
+  keymap = WM_keymap_list_find(&keyconf->keymaps, km->idname, km->spaceid, km->regionid);
+  if (!keymap && wm->defaultconf) {
+    keymap = WM_keymap_list_find(&wm->defaultconf->keymaps, km->idname, km->spaceid, km->regionid);
+  }
 
-	return keymap;
+  return keymap;
 }
 
 void WM_keyconfig_update(wmWindowManager *wm)
 {
-	wmKeyMap *km, *defaultmap, *addonmap, *usermap, *kmn;
-	wmKeyMapItem *kmi;
-	wmKeyMapDiffItem *kmdi;
-	bool compat_update = false;
-
-	if (G.background) {
-		return;
-	}
-
-	if (wm_keymap_update_flag == 0) {
-		return;
-	}
-
-	if (wm_keymap_update_flag & WM_KEYMAP_UPDATE_OPERATORTYPE) {
-		/* an operatortype has been removed, this wont happen often
-		 * but when it does we have to check _every_ keymap item */
-		wmKeyConfig *kc;
-
-		ListBase *keymaps_lb[] = {
-		    &U.user_keymaps,
-		    &wm->userconf->keymaps,
-		    &wm->defaultconf->keymaps,
-		    &wm->addonconf->keymaps,
-		    NULL,
-		};
-
-		int i;
-
-		for (i = 0; keymaps_lb[i]; i++) {
-			wm_keyconfig_properties_update_ot(keymaps_lb[i]);
-		}
-
-		for (kc = wm->keyconfigs.first; kc; kc = kc->next) {
-			wm_keyconfig_properties_update_ot(&kc->keymaps);
-		}
-
-		wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_OPERATORTYPE;
-	}
-
-
-	if (wm_keymap_update_flag == 0) {
-		return;
-	}
-
-	/* update operator properties for non-modal user keymaps */
-	for (km = U.user_keymaps.first; km; km = km->next) {
-		if ((km->flag & KEYMAP_MODAL) == 0) {
-			for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {
-				if (kmdi->add_item) {
-					wm_keymap_item_properties_set(kmdi->add_item);
-				}
-				if (kmdi->remove_item) {
-					wm_keymap_item_properties_set(kmdi->remove_item);
-				}
-			}
-
-			for (kmi = km->items.first; kmi; kmi = kmi->next) {
-				wm_keymap_item_properties_set(kmi);
-			}
-		}
-	}
-
-	/* update U.user_keymaps with user key configuration changes */
-	for (km = wm->userconf->keymaps.first; km; km = km->next) {
-		/* only diff if the user keymap was modified */
-		if (wm_keymap_test_and_clear_update(km)) {
-			/* find keymaps */
-			defaultmap = wm_keymap_preset(wm, km);
-			addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
-
-			/* diff */
-			if (defaultmap) {
-				wm_keymap_diff_update(&U.user_keymaps, defaultmap, addonmap, km);
-			}
-		}
-	}
-
-	/* create user key configuration from preset + addon + user preferences */
-	for (km = wm->defaultconf->keymaps.first; km; km = km->next) {
-		/* find keymaps */
-		defaultmap = wm_keymap_preset(wm, km);
-		addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
-		usermap = WM_keymap_list_find(&U.user_keymaps, km->idname, km->spaceid, km->regionid);
-
-		wm_user_modal_keymap_set_items(wm, defaultmap);
-
-		/* add */
-		kmn = wm_keymap_patch_update(&wm->userconf->keymaps, defaultmap, addonmap, usermap);
-
-		if (kmn) {
-			kmn->modal_items = km->modal_items;
-			kmn->poll = km->poll;
-			kmn->poll_modal_item = km->poll_modal_item;
-		}
-
-		/* in case of old non-diff keymaps, force extra update to create diffs */
-		compat_update = compat_update || (usermap && !(usermap->flag & KEYMAP_DIFF));
-
-	}
-
-	wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_RECONFIGURE;
-
-	BLI_assert(wm_keymap_update_flag == 0);
-
-	if (compat_update) {
-		WM_keyconfig_update_tag(NULL, NULL);
-		WM_keyconfig_update(wm);
-	}
+  wmKeyMap *km, *defaultmap, *addonmap, *usermap, *kmn;
+  wmKeyMapItem *kmi;
+  wmKeyMapDiffItem *kmdi;
+  bool compat_update = false;
+
+  if (G.background) {
+    return;
+  }
+
+  if (wm_keymap_update_flag == 0) {
+    return;
+  }
+
+  if (wm_keymap_update_flag & WM_KEYMAP_UPDATE_OPERATORTYPE) {
+    /* an operatortype has been removed, this wont happen often
+     * but when it does we have to check _every_ keymap item */
+    wmKeyConfig *kc;
+
+    ListBase *keymaps_lb[] = {
+        &U.user_keymaps,
+        &wm->userconf->keymaps,
+        &wm->defaultconf->keymaps,
+        &wm->addonconf->keymaps,
+        NULL,
+    };
+
+    int i;
+
+    for (i = 0; keymaps_lb[i]; i++) {
+      wm_keyconfig_properties_update_ot(keymaps_lb[i]);
+    }
+
+    for (kc = wm->keyconfigs.first; kc; kc = kc->next) {
+      wm_keyconfig_properties_update_ot(&kc->keymaps);
+    }
+
+    wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_OPERATORTYPE;
+  }
+
+  if (wm_keymap_update_flag == 0) {
+    return;
+  }
+
+  /* update operator properties for non-modal user keymaps */
+  for (km = U.user_keymaps.first; km; km = km->next) {
+    if ((km->flag & KEYMAP_MODAL) == 0) {
+      for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {
+        if (kmdi->add_item) {
+          wm_keymap_item_properties_set(kmdi->add_item);
+        }
+        if (kmdi->remove_item) {
+          wm_keymap_item_properties_set(kmdi->remove_item);
+        }
+      }
+
+      for (kmi = km->items.first; kmi; kmi = kmi->next) {
+        wm_keymap_item_properties_set(kmi);
+      }
+    }
+  }
+
+  /* update U.user_keymaps with user key configuration changes */
+  for (km = wm->userconf->keymaps.first; km; km = km->next) {
+    /* only diff if the user keymap was modified */
+    if (wm_keymap_test_and_clear_update(km)) {
+      /* find keymaps */
+      defaultmap = wm_keymap_preset(wm, km);
+      addonmap = WM_keymap_list_find(
+          &wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
+
+      /* diff */
+      if (defaultmap) {
+        wm_keymap_diff_update(&U.user_keymaps, defaultmap, addonmap, km);
+      }
+    }
+  }
+
+  /* create user key configuration from preset + addon + user preferences */
+  for (km = wm->defaultconf->keymaps.first; km; km = km->next) {
+    /* find keymaps */
+    defaultmap = wm_keymap_preset(wm, km);
+    addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, km->idname, km->spaceid, km->regionid);
+    usermap = WM_keymap_list_find(&U.user_keymaps, km->idname, km->spaceid, km->regionid);
+
+    wm_user_modal_keymap_set_items(wm, defaultmap);
+
+    /* add */
+    kmn = wm_keymap_patch_update(&wm->userconf->keymaps, defaultmap, addonmap, usermap);
+
+    if (kmn) {
+      kmn->modal_items = km->modal_items;
+      kmn->poll = km->poll;
+      kmn->poll_modal_item = km->poll_modal_item;
+    }
+
+    /* in case of old non-diff keymaps, force extra update to create diffs */
+    compat_update = compat_update || (usermap && !(usermap->flag & KEYMAP_DIFF));
+  }
+
+  wm_keymap_update_flag &= ~WM_KEYMAP_UPDATE_RECONFIGURE;
+
+  BLI_assert(wm_keymap_update_flag == 0);
+
+  if (compat_update) {
+    WM_keyconfig_update_tag(NULL, NULL);
+    WM_keyconfig_update(wm);
+  }
 }
 
 /********************************* Event Handling *****************************
@@ -1745,20 +1814,21 @@ void WM_keyconfig_update(wmWindowManager *wm)
 
 wmKeyMap *WM_keymap_active(wmWindowManager *wm, wmKeyMap *keymap)
 {
-	wmKeyMap *km;
+  wmKeyMap *km;
 
-	if (!keymap) {
-		return NULL;
-	}
+  if (!keymap) {
+    return NULL;
+  }
 
-	/* first user defined keymaps */
-	km = WM_keymap_list_find(&wm->userconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
+  /* first user defined keymaps */
+  km = WM_keymap_list_find(
+      &wm->userconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
 
-	if (km) {
-		return km;
-	}
+  if (km) {
+    return km;
+  }
 
-	return keymap;
+  return keymap;
 }
 
 /******************************* Keymap Editor ********************************
@@ -1766,95 +1836,97 @@ wmKeyMap *WM_keymap_active(wmWindowManager *wm, wmKeyMap *keymap)
 
 void WM_keymap_restore_item_to_default(bContext *C, wmKeyMap *keymap, wmKeyMapItem *kmi)
 {
-	wmWindowManager *wm = CTX_wm_manager(C);
-	wmKeyMap *defaultmap, *addonmap;
-	wmKeyMapItem *orig;
-
-	if (!keymap) {
-		return;
-	}
-
-	/* construct default keymap from preset + addons */
-	defaultmap = wm_keymap_preset(wm, keymap);
-	addonmap = WM_keymap_list_find(&wm->addonconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
-
-	if (addonmap) {
-		defaultmap = wm_keymap_copy(defaultmap);
-		wm_keymap_addon_add(defaultmap, addonmap);
-	}
-
-	/* find original item */
-	orig = WM_keymap_item_find_id(defaultmap, kmi->id);
-
-	if (orig) {
-		/* restore to original */
-		if (!STREQ(orig->idname, kmi->idname)) {
-			BLI_strncpy(kmi->idname, orig->idname, sizeof(kmi->idname));
-			WM_keymap_properties_reset(kmi, NULL);
-		}
-
-		if (orig->properties) {
-			if (kmi->properties) {
-				IDP_FreeProperty(kmi->properties);
-				MEM_freeN(kmi->properties);
-				kmi->properties = NULL;
-			}
-
-			kmi->properties = IDP_CopyProperty(orig->properties);
-			kmi->ptr->data = kmi->properties;
-		}
-
-		kmi->propvalue = orig->propvalue;
-		kmi->type = orig->type;
-		kmi->val = orig->val;
-		kmi->shift = orig->shift;
-		kmi->ctrl = orig->ctrl;
-		kmi->alt = orig->alt;
-		kmi->oskey = orig->oskey;
-		kmi->keymodifier = orig->keymodifier;
-		kmi->maptype = orig->maptype;
-
-		WM_keyconfig_update_tag(keymap, kmi);
-	}
-
-	/* free temporary keymap */
-	if (addonmap) {
-		WM_keymap_clear(defaultmap);
-		MEM_freeN(defaultmap);
-	}
+  wmWindowManager *wm = CTX_wm_manager(C);
+  wmKeyMap *defaultmap, *addonmap;
+  wmKeyMapItem *orig;
+
+  if (!keymap) {
+    return;
+  }
+
+  /* construct default keymap from preset + addons */
+  defaultmap = wm_keymap_preset(wm, keymap);
+  addonmap = WM_keymap_list_find(
+      &wm->addonconf->keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
+
+  if (addonmap) {
+    defaultmap = wm_keymap_copy(defaultmap);
+    wm_keymap_addon_add(defaultmap, addonmap);
+  }
+
+  /* find original item */
+  orig = WM_keymap_item_find_id(defaultmap, kmi->id);
+
+  if (orig) {
+    /* restore to original */
+    if (!STREQ(orig->idname, kmi->idname)) {
+      BLI_strncpy(kmi->idname, orig->idname, sizeof(kmi->idname));
+      WM_keymap_properties_reset(kmi, NULL);
+    }
+
+    if (orig->properties) {
+      if (kmi->properties) {
+        IDP_FreeProperty(kmi->properties);
+        MEM_freeN(kmi->properties);
+        kmi->properties = NULL;
+      }
+
+      kmi->properties = IDP_CopyProperty(orig->properties);
+      kmi->ptr->data = kmi->properties;
+    }
+
+    kmi->propvalue = orig->propvalue;
+    kmi->type = orig->type;
+    kmi->val = orig->val;
+    kmi->shift = orig->shift;
+    kmi->ctrl = orig->ctrl;
+    kmi->alt = orig->alt;
+    kmi->oskey = orig->oskey;
+    kmi->keymodifier = orig->keymodifier;
+    kmi->maptype = orig->maptype;
+
+    WM_keyconfig_update_tag(keymap, kmi);
+  }
+
+  /* free temporary keymap */
+  if (addonmap) {
+    WM_keymap_clear(defaultmap);
+    MEM_freeN(defaultmap);
+  }
 }
 
 void WM_keymap_restore_to_default(wmKeyMap *keymap, bContext *C)
 {
-	wmWindowManager *wm = CTX_wm_manager(C);
-	wmKeyMap *usermap;
+  wmWindowManager *wm = CTX_wm_manager(C);
+  wmKeyMap *usermap;
 
-	/* remove keymap from U.user_keymaps and update */
-	usermap = WM_keymap_list_find(&U.user_keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
+  /* remove keymap from U.user_keymaps and update */
+  usermap = WM_keymap_list_find(
+      &U.user_keymaps, keymap->idname, keymap->spaceid, keymap->regionid);
 
-	if (usermap) {
-		WM_keymap_clear(usermap);
-		BLI_freelinkN(&U.user_keymaps, usermap);
+  if (usermap) {
+    WM_keymap_clear(usermap);
+    BLI_freelinkN(&U.user_keymaps, usermap);
 
-		WM_keyconfig_update_tag(NULL, NULL);
-		WM_keyconfig_update(wm);
-	}
+    WM_keyconfig_update_tag(NULL, NULL);
+    WM_keyconfig_update(wm);
+  }
 }
 
 wmKeyMapItem *WM_keymap_item_find_id(wmKeyMap *keymap, int id)
 {
-	wmKeyMapItem *kmi;
+  wmKeyMapItem *kmi;
 
-	for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
-		if (kmi->id == id) {
-			return kmi;
-		}
-	}
+  for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
+    if (kmi->id == id) {
+      return kmi;
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
 
 const char *WM_bool_as_string(bool test)
 {
-	return test ? IFACE_("ON") : IFACE_("OFF");
+  return test ? IFACE_("ON") : IFACE_("OFF");
 }