archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Fix errors from conflicts in last merge

Browse Source 
Handled merge conflicts wrong apparently. When checking changes before
committing, everything seemed fine...
This commit is contained in:
Julian Eisel
2020-02-04 20:21:30 +01:00
parent e4605cb155
commit 15bb6e63e8
1 changed files with 83 additions and 468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

551
source/blender/windowmanager/intern/wm_event_system.c
View File

@@ -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)
void wm_tablet_data_from_ghost(const GHOST_TabletData *tablet_data, wmTabletData *wmtab)
{
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)
{
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);
}
/** \} */