Fix errors from conflicts in last merge

Handled merge conflicts wrong apparently. When checking changes before
committing, everything seemed fine...

1 files changed, 83 insertions, 468 deletions

diff --git a/source/blender/windowmanager/intern/wm_event_system.c b/source/blender/windowmanager/intern/wm_event_system.c
index ebcdef47eee..4b525189368 100644
--- a/source/blender/windowmanager/intern/wm_event_system.c
+++ b/source/blender/windowmanager/intern/wm_event_system.c
@@ -1,4 +1,4 @@
-/*
+/*
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
@@ -70,7 +70,6 @@
 #include "RNA_access.h"
 
 #include "UI_interface.h"
-#include "UI_view2d.h"
 
 #include "PIL_time.h"
 
@@ -84,8 +83,6 @@
 #include "wm_event_system.h"
 #include "wm_event_types.h"
 
-#include "RNA_enum_types.h"
-
 #include "DEG_depsgraph.h"
 #include "DEG_depsgraph_query.h"
 
@@ -104,7 +101,6 @@
 #define USE_GIZMO_MOUSE_PRIORITY_HACK
 
 static void wm_notifier_clear(wmNotifier *note);
-static void update_tablet_data(wmWindow *win, wmEvent *event);
 
 static int wm_operator_call_internal(bContext *C,
                                      wmOperatorType *ot,
@@ -114,6 +110,8 @@ static int wm_operator_call_internal(bContext *C,
                                      const bool poll_only,
                                      wmEvent *event);
 
+static bool wm_operator_check_locked_interface(bContext *C, wmOperatorType *ot);
+
 /* -------------------------------------------------------------------- */
 /** \name Event Management
  * \{ */
@@ -126,14 +124,6 @@ wmEvent *wm_event_add_ex(wmWindow *win,
 
   *event = *event_to_add;
 
-  update_tablet_data(win, event);
-
-  if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) {
-    /* We could have a preference to support relative tablet motion (we can't detect that). */
-    event->is_motion_absolute = ((event->tablet_data != NULL) &&
-                                 (event->tablet_data->Active != GHOST_kTabletModeNone));
-  }
-
   if (event_to_add_after == NULL) {
     BLI_addtail(&win->queue, event);
   }
@@ -177,10 +167,6 @@ void wm_event_free(wmEvent *event)
     }
   }
 
-  if (event->tablet_data) {
-    MEM_freeN((void *)event->tablet_data);
-  }
-
   MEM_freeN(event);
 }
 
@@ -195,9 +181,6 @@ void wm_event_free_all(wmWindow *win)
 
 void wm_event_init_from_window(wmWindow *win, wmEvent *event)
 {
-  /* make sure we don't copy any owned pointers */
-  BLI_assert(win->eventstate->tablet_data == NULL);
-
   *event = *(win->eventstate);
 }
 
@@ -716,16 +699,6 @@ void WM_report_banners_cancel(Main *bmain)
   WM_event_remove_timer(wm, NULL, wm->reports.reporttimer);
 }
 
-bool WM_event_is_last_mousemove(const wmEvent *event)
-{
-  while ((event = event->next)) {
-    if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) {
-      return false;
-    }
-  }
-  return true;
-}
-
 #ifdef WITH_INPUT_NDOF
 void WM_ndof_deadzone_set(float deadzone)
 {
@@ -1239,105 +1212,6 @@ static void wm_region_mouse_co(bContext *C, wmEvent *event)
   }
 }
 
-#if 1 /* may want to disable operator remembering previous state for testing */
-
-static bool operator_last_properties_init_impl(wmOperator *op, IDProperty *last_properties)
-{
-  bool changed = false;
-  IDPropertyTemplate val = {0};
-  IDProperty *replaceprops = IDP_New(IDP_GROUP, &val, "wmOperatorProperties");
-  PropertyRNA *iterprop;
-
-  CLOG_INFO(WM_LOG_OPERATORS, 1, "loading previous properties for '%s'", op->type->idname);
-
-  iterprop = RNA_struct_iterator_property(op->type->srna);
-
-  RNA_PROP_BEGIN (op->ptr, itemptr, iterprop) {
-    PropertyRNA *prop = itemptr.data;
-    if ((RNA_property_flag(prop) & PROP_SKIP_SAVE) == 0) {
-      if (!RNA_property_is_set(op->ptr, prop)) { /* don't override a setting already set */
-        const char *identifier = RNA_property_identifier(prop);
-        IDProperty *idp_src = IDP_GetPropertyFromGroup(last_properties, identifier);
-        if (idp_src) {
-          IDProperty *idp_dst = IDP_CopyProperty(idp_src);
-
-          /* note - in the future this may need to be done recursively,
-           * but for now RNA doesn't access nested operators */
-          idp_dst->flag |= IDP_FLAG_GHOST;
-
-          /* add to temporary group instead of immediate replace,
-           * because we are iterating over this group */
-          IDP_AddToGroup(replaceprops, idp_dst);
-          changed = true;
-        }
-      }
-    }
-  }
-  RNA_PROP_END;
-
-  IDP_MergeGroup(op->properties, replaceprops, true);
-  IDP_FreeProperty(replaceprops);
-  return changed;
-}
-
-bool WM_operator_last_properties_init(wmOperator *op)
-{
-  bool changed = false;
-  if (op->type->last_properties) {
-    changed |= operator_last_properties_init_impl(op, op->type->last_properties);
-    for (wmOperator *opm = op->macro.first; opm; opm = opm->next) {
-      IDProperty *idp_src = IDP_GetPropertyFromGroup(op->type->last_properties, opm->idname);
-      if (idp_src) {
-        changed |= operator_last_properties_init_impl(opm, idp_src);
-      }
-    }
-  }
-  return changed;
-}
-
-bool WM_operator_last_properties_store(wmOperator *op)
-{
-  if (op->type->last_properties) {
-    IDP_FreeProperty(op->type->last_properties);
-    op->type->last_properties = NULL;
-  }
-
-  if (op->properties) {
-    CLOG_INFO(WM_LOG_OPERATORS, 1, "storing properties for '%s'", op->type->idname);
-    op->type->last_properties = IDP_CopyProperty(op->properties);
-  }
-
-  if (op->macro.first != NULL) {
-    for (wmOperator *opm = op->macro.first; opm; opm = opm->next) {
-      if (opm->properties) {
-        if (op->type->last_properties == NULL) {
-          op->type->last_properties = IDP_New(
-              IDP_GROUP, &(IDPropertyTemplate){0}, "wmOperatorProperties");
-        }
-        IDProperty *idp_macro = IDP_CopyProperty(opm->properties);
-        STRNCPY(idp_macro->name, opm->type->idname);
-        IDP_ReplaceInGroup(op->type->last_properties, idp_macro);
-      }
-    }
-  }
-
-  return (op->type->last_properties != NULL);
-}
-
-#else
-
-bool WM_operator_last_properties_init(wmOperator *UNUSED(op))
-{
-  return false;
-}
-
-bool WM_operator_last_properties_store(wmOperator *UNUSED(op))
-{
-  return false;
-}
-
-#endif
-
 /**
  * Also used for exec when 'event' is NULL.
  */
@@ -1892,42 +1766,6 @@ void WM_event_remove_handlers(bContext *C, ListBase *handlers)
   }
 }
 
-/* do userdef mappings */
-int WM_userdef_event_map(int kmitype)
-{
-  switch (kmitype) {
-    case WHEELOUTMOUSE:
-      return (U.uiflag & USER_WHEELZOOMDIR) ? WHEELUPMOUSE : WHEELDOWNMOUSE;
-    case WHEELINMOUSE:
-      return (U.uiflag & USER_WHEELZOOMDIR) ? WHEELDOWNMOUSE : WHEELUPMOUSE;
-  }
-
-  return kmitype;
-}
-
-/**
- * Use so we can check if 'wmEvent.type' is released in modal operators.
- *
- * An alternative would be to add a 'wmEvent.type_nokeymap'... or similar.
- */
-int WM_userdef_event_type_from_keymap_type(int kmitype)
-{
-  switch (kmitype) {
-    case EVT_TWEAK_L:
-      return LEFTMOUSE;
-    case EVT_TWEAK_M:
-      return MIDDLEMOUSE;
-    case EVT_TWEAK_R:
-      return RIGHTMOUSE;
-    case WHEELOUTMOUSE:
-      return (U.uiflag & USER_WHEELZOOMDIR) ? WHEELUPMOUSE : WHEELDOWNMOUSE;
-    case WHEELINMOUSE:
-      return (U.uiflag & USER_WHEELZOOMDIR) ? WHEELDOWNMOUSE : WHEELUPMOUSE;
-  }
-
-  return kmitype;
-}
-
 static bool wm_eventmatch(const wmEvent *winevent, const wmKeyMapItem *kmi)
 {
   if (kmi->flag & KMI_INACTIVE) {
@@ -1949,19 +1787,16 @@ static bool wm_eventmatch(const wmEvent *winevent, const wmKeyMapItem *kmi)
 
   if (kmitype != KM_ANY) {
     if (ELEM(kmitype, TABLET_STYLUS, TABLET_ERASER)) {
-      const wmTabletData *wmtab = winevent->tablet_data;
+      const wmTabletData *wmtab = &winevent->tablet;
 
-      if (wmtab == NULL) {
-        return false;
-      }
-      else if (winevent->type != LEFTMOUSE) {
+      if (winevent->type != LEFTMOUSE) {
         /* tablet events can occur on hover + keypress */
         return false;
       }
-      else if ((kmitype == TABLET_STYLUS) && (wmtab->Active != EVT_TABLET_STYLUS)) {
+      else if ((kmitype == TABLET_STYLUS) && (wmtab->active != EVT_TABLET_STYLUS)) {
         return false;
       }
-      else if ((kmitype == TABLET_ERASER) && (wmtab->Active != EVT_TABLET_ERASER)) {
+      else if ((kmitype == TABLET_ERASER) && (wmtab->active != EVT_TABLET_ERASER)) {
         return false;
       }
     }
@@ -2041,10 +1876,10 @@ static wmKeyMapItem *wm_eventmatch_modal_keymap_items(const wmKeyMap *keymap,
  *   This is done since we only want to use double click events to match key-map items,
  *   allowing modal functions to check for press/release events without having to interpret them.
  */
-static void wm_event_modalkeymap(const bContext *C,
-                                 wmOperator *op,
-                                 wmEvent *event,
-                                 bool *dbl_click_disabled)
+static void wm_event_modalkeymap_begin(const bContext *C,
+                                       wmOperator *op,
+                                       wmEvent *event,
+                                       bool *dbl_click_disabled)
 {
   BLI_assert(event->type != EVT_MODAL_MAP);
 
@@ -2097,25 +1932,13 @@ static void wm_event_modalkeymap(const bContext *C,
 }
 
 /**
- * Check whether operator is allowed to run in case interface is locked,
- * If interface is unlocked, will always return truth.
+ * Restore changes from #wm_event_modalkeymap_begin
+ *
+ * \warning bad hacking event system...
+ * better restore event type for checking of #KM_CLICK for example.
+ * Modal maps could use different method (ton).
  */
-static bool wm_operator_check_locked_interface(bContext *C, wmOperatorType *ot)
-{
-  wmWindowManager *wm = CTX_wm_manager(C);
-
-  if (wm->is_interface_locked) {
-    if ((ot->flag & OPTYPE_LOCK_BYPASS) == 0) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/* bad hacking event system... better restore event type for checking of KM_CLICK for example */
-/* XXX modal maps could use different method (ton) */
-static void wm_event_modalmap_end(wmEvent *event, bool dbl_click_disabled)
+static void wm_event_modalkeymap_end(wmEvent *event, bool dbl_click_disabled)
 {
   if (event->type == EVT_MODAL_MAP) {
     event->type = event->prevtype;
@@ -2134,7 +1957,8 @@ static int wm_handler_operator_call(bContext *C,
                                     ListBase *handlers,
                                     wmEventHandler *handler_base,
                                     wmEvent *event,
-                                    PointerRNA *properties)
+                                    PointerRNA *properties,
+                                    const char *kmi_idname)
 {
   int retval = OPERATOR_PASS_THROUGH;
 
@@ -2159,7 +1983,7 @@ static int wm_handler_operator_call(bContext *C,
 
       wm_handler_op_context(C, handler, event);
       wm_region_mouse_co(C, event);
-      wm_event_modalkeymap(C, op, event, &dbl_click_disabled);
+      wm_event_modalkeymap_begin(C, op, event, &dbl_click_disabled);
 
       if (ot->flag & OPTYPE_UNDO) {
         wm->op_undo_depth++;
@@ -2174,7 +1998,7 @@ static int wm_handler_operator_call(bContext *C,
        * the event, operator etc have all been freed. - campbell */
       if (CTX_wm_manager(C) == wm) {
 
-        wm_event_modalmap_end(event, dbl_click_disabled);
+        wm_event_modalkeymap_end(event, dbl_click_disabled);
 
         if (ot->flag & OPTYPE_UNDO) {
           wm->op_undo_depth--;
@@ -2236,7 +2060,7 @@ static int wm_handler_operator_call(bContext *C,
     }
   }
   else {
-    wmOperatorType *ot = WM_operatortype_find(event->keymap_idname, 0);
+    wmOperatorType *ot = WM_operatortype_find(kmi_idname, 0);
 
     if (ot && wm_operator_check_locked_interface(C, ot)) {
       bool use_last_properties = true;
@@ -2574,10 +2398,8 @@ static int wm_handlers_do_keymap_with_keymap_handler(
 
           PRINT("%s:     item matched '%s'\n", __func__, kmi->idname);
 
-          /* weak, but allows interactive callback to not use rawkey */
-          event->keymap_idname = kmi->idname;
-
-          action |= wm_handler_operator_call(C, handlers, &handler->head, event, kmi->ptr);
+          action |= wm_handler_operator_call(
+              C, handlers, &handler->head, event, kmi->ptr, kmi->idname);
 
           if (action & WM_HANDLER_BREAK) {
             /* not always_pass here, it denotes removed handler_base */
@@ -2631,13 +2453,11 @@ static int wm_handlers_do_keymap_with_gizmo_handler(
       if (wm_eventmatch(event, kmi)) {
         PRINT("%s:     item matched '%s'\n", __func__, kmi->idname);
 
-        /* weak, but allows interactive callback to not use rawkey */
-        event->keymap_idname = kmi->idname;
-
         CTX_wm_gizmo_group_set(C, gzgroup);
 
         /* handler->op is called later, we want keymap op to be triggered here */
-        action |= wm_handler_operator_call(C, handlers, &handler->head, event, kmi->ptr);
+        action |= wm_handler_operator_call(
+            C, handlers, &handler->head, event, kmi->ptr, kmi->idname);
 
         CTX_wm_gizmo_group_set(C, NULL);
 
@@ -2928,7 +2748,7 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
           }
         }
         else {
-          action |= wm_handler_operator_call(C, handlers, handler_base, event, NULL);
+          action |= wm_handler_operator_call(C, handlers, handler_base, event, NULL, NULL);
         }
       }
       else {
@@ -4037,91 +3857,6 @@ void WM_event_add_mousemove(const bContext *C)
   window->addmousemove = 1;
 }
 
-/* for modal callbacks, check configuration for how to interpret exit with tweaks  */
-bool WM_event_is_modal_tweak_exit(const wmEvent *event, int tweak_event)
-{
-  /* if the release-confirm userpref setting is enabled,
-   * tweak events can be canceled when mouse is released
-   */
-  if (U.flag & USER_RELEASECONFIRM) {
-    /* option on, so can exit with km-release */
-    if (event->val == KM_RELEASE) {
-      switch (tweak_event) {
-        case EVT_TWEAK_L:
-        case EVT_TWEAK_M:
-        case EVT_TWEAK_R:
-          return 1;
-      }
-    }
-    else {
-      /* if the initial event wasn't a tweak event then
-       * ignore USER_RELEASECONFIRM setting: see [#26756] */
-      if (ELEM(tweak_event, EVT_TWEAK_L, EVT_TWEAK_M, EVT_TWEAK_R) == 0) {
-        return 1;
-      }
-    }
-  }
-  else {
-    /* this is fine as long as not doing km-release, otherwise
-     * some items (i.e. markers) being tweaked may end up getting
-     * dropped all over
-     */
-    if (event->val != KM_RELEASE) {
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-bool WM_event_type_mask_test(const int event_type, const enum eEventType_Mask mask)
-{
-  /* Keyboard. */
-  if (mask & EVT_TYPE_MASK_KEYBOARD) {
-    if (ISKEYBOARD(event_type)) {
-      return true;
-    }
-  }
-  else if (mask & EVT_TYPE_MASK_KEYBOARD_MODIFIER) {
-    if (ISKEYMODIFIER(event_type)) {
-      return true;
-    }
-  }
-
-  /* Mouse. */
-  if (mask & EVT_TYPE_MASK_MOUSE) {
-    if (ISMOUSE(event_type)) {
-      return true;
-    }
-  }
-  else if (mask & EVT_TYPE_MASK_MOUSE_WHEEL) {
-    if (ISMOUSE_WHEEL(event_type)) {
-      return true;
-    }
-  }
-  else if (mask & EVT_TYPE_MASK_MOUSE_GESTURE) {
-    if (ISMOUSE_GESTURE(event_type)) {
-      return true;
-    }
-  }
-
-  /* Tweak. */
-  if (mask & EVT_TYPE_MASK_TWEAK) {
-    if (ISTWEAK(event_type)) {
-      return true;
-    }
-  }
-
-  /* Action Zone. */
-  if (mask & EVT_TYPE_MASK_ACTIONZONE) {
-    if (IS_EVENT_ACTIONZONE(event_type)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 /** \} */
 
 /* -------------------------------------------------------------------- */
@@ -4359,41 +4094,23 @@ static void wm_eventemulation(wmEvent *event, bool test_only)
   }
 }
 
-/* applies the global tablet pressure correction curve */
-float wm_pressure_curve(float pressure)
-{
-  if (U.pressure_threshold_max != 0.0f) {
-    pressure /= U.pressure_threshold_max;
-  }
-
-  CLAMP(pressure, 0.0f, 1.0f);
-
-  if (U.pressure_softness != 0.0f) {
-    pressure = powf(pressure, powf(4.0f, -U.pressure_softness));
-  }
-
-  return pressure;
-}
-
-/* adds customdata to event */
-static void update_tablet_data(wmWindow *win, wmEvent *event)
+void wm_tablet_data_from_ghost(const GHOST_TabletData *tablet_data, wmTabletData *wmtab)
 {
-  const GHOST_TabletData *td = GHOST_GetTabletData(win->ghostwin);
-
-  /* if there's tablet data from an active tablet device then add it */
-  if ((td != NULL) && td->Active != GHOST_kTabletModeNone) {
-    struct wmTabletData *wmtab = MEM_mallocN(sizeof(wmTabletData), "customdata tablet");
-
-    wmtab->Active = (int)td->Active;
-    wmtab->Pressure = wm_pressure_curve(td->Pressure);
-    wmtab->Xtilt = td->Xtilt;
-    wmtab->Ytilt = td->Ytilt;
-
-    event->tablet_data = wmtab;
-    // printf("%s: using tablet %.5f\n", __func__, wmtab->Pressure);
+  if ((tablet_data != NULL) && tablet_data->Active != GHOST_kTabletModeNone) {
+    wmtab->active = (int)tablet_data->Active;
+    wmtab->pressure = wm_pressure_curve(tablet_data->Pressure);
+    wmtab->x_tilt = tablet_data->Xtilt;
+    wmtab->y_tilt = tablet_data->Ytilt;
+    /* We could have a preference to support relative tablet motion (we can't detect that). */
+    wmtab->is_motion_absolute = true;
+    // printf("%s: using tablet %.5f\n", __func__, wmtab->pressure);
   }
   else {
-    event->tablet_data = NULL;
+    wmtab->active = EVT_TABLET_NONE;
+    wmtab->pressure = 1.0f;
+    wmtab->x_tilt = 0.0f;
+    wmtab->y_tilt = 0.0f;
+    wmtab->is_motion_absolute = false;
     // printf("%s: not using tablet\n", __func__);
   }
 }
@@ -4545,6 +4262,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
 
       copy_v2_v2_int(&event.x, &cd->x);
       wm_stereo3d_mouse_offset_apply(win, &event.x);
+      wm_tablet_data_from_ghost(&cd->tablet, &event.tablet);
 
       event.prevtype = event.type;
       event.prevval = event.val;
@@ -4552,7 +4270,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
       {
         wmEvent *event_new = wm_event_add_mousemove(win, &event);
         copy_v2_v2_int(&evt->x, &event_new->x);
-        evt->is_motion_absolute = event_new->is_motion_absolute;
+        evt->tablet.is_motion_absolute = event_new->tablet.is_motion_absolute;
       }
 
       /* also add to other window if event is there, this makes overdraws disappear nicely */
@@ -4570,7 +4288,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
         {
           wmEvent *event_new = wm_event_add_mousemove(owin, &oevent);
           copy_v2_v2_int(&oevt->x, &event_new->x);
-          oevt->is_motion_absolute = event_new->is_motion_absolute;
+          oevt->tablet.is_motion_absolute = event_new->tablet.is_motion_absolute;
         }
       }
 
@@ -4584,6 +4302,9 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
           pd->deltaX = -pd->deltaX;
           pd->deltaY = -pd->deltaY;
           break;
+        case GHOST_kTrackpadEventSmartMagnify:
+          event.type = MOUSESMARTZOOM;
+          break;
         case GHOST_kTrackpadEventRotate:
           event.type = MOUSEROTATE;
           break;
@@ -4634,6 +4355,9 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
         event.type = MIDDLEMOUSE;
       }
 
+      /* Get tablet data. */
+      wm_tablet_data_from_ghost(&bd->tablet, &event.tablet);
+
       wm_eventemulation(&event, false);
 
       /* copy previous state to prev event state (two old!) */
@@ -4644,17 +4368,6 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
       evt->val = event.val;
       evt->type = event.type;
 
-      if (win->active == 0) {
-        int cx, cy;
-
-        /* Entering window, update mouse pos.
-         * (ghost sends win-activate *after* the mouseclick in window!) */
-        wm_get_cursor_position(win, &cx, &cy);
-
-        event.x = evt->x = cx;
-        event.y = evt->y = cy;
-      }
-
       /* double click test */
       if (wm_event_is_double_click(&event, evt)) {
         CLOG_INFO(WM_LOG_HANDLERS, 1, "Send double click");
@@ -4675,6 +4388,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
         oevent.y = event.y;
         oevent.type = event.type;
         oevent.val = event.val;
+        oevent.tablet = event.tablet;
 
         wm_event_add(owin, &oevent);
       }
@@ -4941,6 +4655,29 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
 #endif
 }
 
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name WM Interface Locking
+ * \{ */
+
+/**
+ * Check whether operator is allowed to run in case interface is locked,
+ * If interface is unlocked, will always return truth.
+ */
+static bool wm_operator_check_locked_interface(bContext *C, wmOperatorType *ot)
+{
+  wmWindowManager *wm = CTX_wm_manager(C);
+
+  if (wm->is_interface_locked) {
+    if ((ot->flag & OPTYPE_LOCK_BYPASS) == 0) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 void WM_set_locked_interface(wmWindowManager *wm, bool lock)
 {
   /* This will prevent events from being handled while interface is locked
@@ -4962,96 +4699,12 @@ void WM_set_locked_interface(wmWindowManager *wm, bool lock)
   BKE_spacedata_draw_locks(lock);
 }
 
-#ifdef WITH_INPUT_NDOF
+/** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name NDOF Utility Functions
+/** \name Event / Keymap Matching API
  * \{ */
 
-void WM_event_ndof_pan_get(const wmNDOFMotionData *ndof, float r_pan[3], const bool use_zoom)
-{
-  int z_flag = use_zoom ? NDOF_ZOOM_INVERT : NDOF_PANZ_INVERT_AXIS;
-  r_pan[0] = ndof->tvec[0] * ((U.ndof_flag & NDOF_PANX_INVERT_AXIS) ? -1.0f : 1.0f);
-  r_pan[1] = ndof->tvec[1] * ((U.ndof_flag & NDOF_PANY_INVERT_AXIS) ? -1.0f : 1.0f);
-  r_pan[2] = ndof->tvec[2] * ((U.ndof_flag & z_flag) ? -1.0f : 1.0f);
-}
-
-void WM_event_ndof_rotate_get(const wmNDOFMotionData *ndof, float r_rot[3])
-{
-  r_rot[0] = ndof->rvec[0] * ((U.ndof_flag & NDOF_ROTX_INVERT_AXIS) ? -1.0f : 1.0f);
-  r_rot[1] = ndof->rvec[1] * ((U.ndof_flag & NDOF_ROTY_INVERT_AXIS) ? -1.0f : 1.0f);
-  r_rot[2] = ndof->rvec[2] * ((U.ndof_flag & NDOF_ROTZ_INVERT_AXIS) ? -1.0f : 1.0f);
-}
-
-float WM_event_ndof_to_axis_angle(const struct wmNDOFMotionData *ndof, float axis[3])
-{
-  float angle;
-  angle = normalize_v3_v3(axis, ndof->rvec);
-
-  axis[0] = axis[0] * ((U.ndof_flag & NDOF_ROTX_INVERT_AXIS) ? -1.0f : 1.0f);
-  axis[1] = axis[1] * ((U.ndof_flag & NDOF_ROTY_INVERT_AXIS) ? -1.0f : 1.0f);
-  axis[2] = axis[2] * ((U.ndof_flag & NDOF_ROTZ_INVERT_AXIS) ? -1.0f : 1.0f);
-
-  return ndof->dt * angle;
-}
-
-void WM_event_ndof_to_quat(const struct wmNDOFMotionData *ndof, float q[4])
-{
-  float axis[3];
-  float angle;
-
-  angle = WM_event_ndof_to_axis_angle(ndof, axis);
-  axis_angle_to_quat(q, axis, angle);
-}
-#endif /* WITH_INPUT_NDOF */
-
-/* if this is a tablet event, return tablet pressure and set *pen_flip
- * to 1 if the eraser tool is being used, 0 otherwise */
-float WM_event_tablet_data(const wmEvent *event, int *pen_flip, float tilt[2])
-{
-  int erasor = 0;
-  float pressure = 1;
-
-  if (tilt) {
-    zero_v2(tilt);
-  }
-
-  if (event->tablet_data) {
-    const wmTabletData *wmtab = event->tablet_data;
-
-    erasor = (wmtab->Active == EVT_TABLET_ERASER);
-    if (wmtab->Active != EVT_TABLET_NONE) {
-      pressure = wmtab->Pressure;
-      if (tilt) {
-        tilt[0] = wmtab->Xtilt;
-        tilt[1] = wmtab->Ytilt;
-      }
-    }
-  }
-
-  if (pen_flip) {
-    (*pen_flip) = erasor;
-  }
-
-  return pressure;
-}
-
-bool WM_event_is_tablet(const struct wmEvent *event)
-{
-  return (event->tablet_data) ? true : false;
-}
-
-#ifdef WITH_INPUT_IME
-/* most os using ctrl/oskey + space to switch ime, avoid added space */
-bool WM_event_is_ime_switch(const struct wmEvent *event)
-{
-  return event->val == KM_PRESS && event->type == SPACEKEY &&
-         (event->ctrl || event->oskey || event->shift || event->alt);
-}
-#endif
-
-/** \} */
-
 wmKeyMap *WM_event_get_keymap_from_handler(wmWindowManager *wm, wmEventHandler_Keymap *handler)
 {
   wmKeyMap *keymap;
@@ -5079,10 +4732,10 @@ wmKeyMapItem *WM_event_match_keymap_item(bContext *C, wmKeyMap *keymap, const wm
   return NULL;
 }
 
-static wmKeyMapItem *wm_kmi_from_event(bContext *C,
-                                       wmWindowManager *wm,
-                                       ListBase *handlers,
-                                       const wmEvent *event)
+wmKeyMapItem *WM_event_match_keymap_item_from_handlers(bContext *C,
+                                                       wmWindowManager *wm,
+                                                       ListBase *handlers,
+                                                       const wmEvent *event)
 {
   LISTBASE_FOREACH (wmEventHandler *, handler_base, handlers) {
     /* during this loop, ui handlers for nested menus can tag multiple handlers free */
@@ -5105,6 +4758,8 @@ static wmKeyMapItem *wm_kmi_from_event(bContext *C,
   return NULL;
 }
 
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Cursor Keymap Status
  *
@@ -5317,7 +4972,7 @@ void WM_window_cursor_keymap_status_refresh(bContext *C, wmWindow *win)
     wm_eventemulation(&test_event, true);
     wmKeyMapItem *kmi = NULL;
     for (int handler_index = 0; handler_index < ARRAY_SIZE(handlers); handler_index++) {
-      kmi = wm_kmi_from_event(C, wm, handlers[handler_index], &test_event);
+      kmi = WM_event_match_keymap_item_from_handlers(C, wm, handlers[handler_index], &test_event);
       if (kmi) {
         break;
       }
@@ -5413,43 +5068,3 @@ bool WM_window_modal_keymap_status_draw(bContext *UNUSED(C), wmWindow *win, uiLa
 }
 
 /** \} */
-
-/* -------------------------------------------------------------------- */
-/** \name Event Click/Drag Checks
- *
- * Values under this limit are detected as clicks.
- *
- * \{ */
-
-int WM_event_drag_threshold(const struct wmEvent *event)
-{
-  int drag_threshold;
-  if (WM_event_is_tablet(event)) {
-    drag_threshold = U.drag_threshold_tablet;
-  }
-  else if (ISMOUSE(event->prevtype)) {
-    drag_threshold = U.drag_threshold_mouse;
-  }
-  else {
-    /* Typically keyboard, could be NDOF button or other less common types. */
-    drag_threshold = U.drag_threshold;
-  }
-  return drag_threshold * U.dpi_fac;
-}
-
-bool WM_event_drag_test_with_delta(const wmEvent *event, const int drag_delta[2])
-{
-  const int drag_threshold = WM_event_drag_threshold(event);
-  return abs(drag_delta[0]) > drag_threshold || abs(drag_delta[1]) > drag_threshold;
-}
-
-bool WM_event_drag_test(const wmEvent *event, const int prev_xy[2])
-{
-  const int drag_delta[2] = {
-      prev_xy[0] - event->x,
-      prev_xy[1] - event->y,
-  };
-  return WM_event_drag_test_with_delta(event, drag_delta);
-}
-
-/** \} */