Cleanup: use an array for wmEvent cursor position variables

Use arrays for wmEvent coordinates, this quiets warnings with GCC11.

- `x, y` -> `xy`.
- `prevx, prevy` -> `prev_xy`.
- `prevclickx, prevclicky` -> `prev_click_xy`.

There is still some cleanup such as using `copy_v2_v2_int()`,
this can be done separately.

Reviewed By: campbellbarton, Severin

Ref D12901

9 files changed, 134 insertions, 134 deletions

diff --git a/source/blender/windowmanager/intern/wm_dragdrop.c b/source/blender/windowmanager/intern/wm_dragdrop.c
index b76b1672543..0e51619b50a 100644
--- a/source/blender/windowmanager/intern/wm_dragdrop.c
+++ b/source/blender/windowmanager/intern/wm_dragdrop.c
@@ -311,7 +311,8 @@ static void wm_drop_operator_options(bContext *C, wmDrag *drag, const wmEvent *e
   const int winsize_y = WM_window_pixels_y(win);
 
   /* for multiwin drags, we only do this if mouse inside */
-  if (event->x < 0 || event->y < 0 || event->x > winsize_x || event->y > winsize_y) {
+  if (event->xy[0] < 0 || event->xy[1] < 0 || event->xy[0] > winsize_x ||
+      event->xy[1] > winsize_y) {
     return;
   }
 
@@ -650,8 +651,8 @@ void wm_drags_draw(bContext *C, wmWindow *win, rcti *rect)
   wmWindowManager *wm = CTX_wm_manager(C);
   const int winsize_y = WM_window_pixels_y(win);
 
-  int cursorx = win->eventstate->x;
-  int cursory = win->eventstate->y;
+  int cursorx = win->eventstate->xy[0];
+  int cursory = win->eventstate->xy[1];
   if (rect) {
     rect->xmin = rect->xmax = cursorx;
     rect->ymin = rect->ymax = cursory;
diff --git a/source/blender/windowmanager/intern/wm_draw.c b/source/blender/windowmanager/intern/wm_draw.c
index 328950cf8f9..b5e81528e2b 100644
--- a/source/blender/windowmanager/intern/wm_draw.c
+++ b/source/blender/windowmanager/intern/wm_draw.c
@@ -121,7 +121,7 @@ static void wm_paintcursor_draw(bContext *C, ScrArea *area, ARegion *region)
         pc->draw(C, x, y, pc->customdata);
       }
       else {
-        pc->draw(C, win->eventstate->x, win->eventstate->y, pc->customdata);
+        pc->draw(C, win->eventstate->xy[0], win->eventstate->xy[1], pc->customdata);
       }
 
       GPU_scissor_test(false);
diff --git a/source/blender/windowmanager/intern/wm_event_query.c b/source/blender/windowmanager/intern/wm_event_query.c
index 8b77c460be3..85abd8469fe 100644
--- a/source/blender/windowmanager/intern/wm_event_query.c
+++ b/source/blender/windowmanager/intern/wm_event_query.c
@@ -103,8 +103,8 @@ void WM_event_print(const wmEvent *event)
         event->oskey,
         event->keymodifier,
         event->is_repeat,
-        event->x,
-        event->y,
+        event->xy[0],
+        event->xy[1],
         event->ascii,
         BLI_str_utf8_size(event->utf8_buf),
         event->utf8_buf,
@@ -316,8 +316,8 @@ bool WM_event_drag_test_with_delta(const wmEvent *event, const int drag_delta[2]
 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,
+      prev_xy[0] - event->xy[0],
+      prev_xy[1] - event->xy[1],
   };
   return WM_event_drag_test_with_delta(event, drag_delta);
 }
@@ -476,7 +476,7 @@ bool WM_event_is_tablet(const struct wmEvent *event)
 
 int WM_event_absolute_delta_x(const struct wmEvent *event)
 {
-  int dx = event->x - event->prevx;
+  int dx = event->xy[0] - event->prev_xy[0];
 
   if (!event->is_direction_inverted) {
     dx = -dx;
@@ -487,7 +487,7 @@ int WM_event_absolute_delta_x(const struct wmEvent *event)
 
 int WM_event_absolute_delta_y(const struct wmEvent *event)
 {
-  int dy = event->y - event->prevy;
+  int dy = event->xy[1] - event->prev_xy[1];
 
   if (!event->is_direction_inverted) {
     dy = -dy;
diff --git a/source/blender/windowmanager/intern/wm_event_system.c b/source/blender/windowmanager/intern/wm_event_system.c
index dffbea64a30..54826649099 100644
--- a/source/blender/windowmanager/intern/wm_event_system.c
+++ b/source/blender/windowmanager/intern/wm_event_system.c
@@ -153,12 +153,12 @@ wmEvent *WM_event_add_simulate(wmWindow *win, const wmEvent *event_to_add)
   /* Logic for setting previous value is documented on the #wmEvent struct,
    * see #wm_event_add_ghostevent for the implementation of logic this follows. */
 
-  win->eventstate->x = event->x;
-  win->eventstate->y = event->y;
+  win->eventstate->xy[0] = event->xy[0];
+  win->eventstate->xy[1] = event->xy[1];
 
   if (event->type == MOUSEMOVE) {
-    win->eventstate->prevx = event->prevx = win->eventstate->x;
-    win->eventstate->prevy = event->prevy = win->eventstate->y;
+    win->eventstate->prev_xy[0] = event->prev_xy[0] = win->eventstate->xy[0];
+    win->eventstate->prev_xy[1] = event->prev_xy[1] = win->eventstate->xy[1];
   }
   else if (ISMOUSE_BUTTON(event->type) || ISKEYBOARD(event->type)) {
     win->eventstate->prevval = event->prevval = win->eventstate->val;
@@ -169,8 +169,7 @@ wmEvent *WM_event_add_simulate(wmWindow *win, const wmEvent *event_to_add)
 
     if (event->val == KM_PRESS) {
       if (event->is_repeat == false) {
-        win->eventstate->prevclickx = event->x;
-        win->eventstate->prevclicky = event->y;
+        copy_v2_v2_int(win->eventstate->prev_click_xy, event->xy);
       }
     }
   }
@@ -1285,8 +1284,8 @@ static void wm_region_mouse_co(bContext *C, wmEvent *event)
   ARegion *region = CTX_wm_region(C);
   if (region) {
     /* Compatibility convention. */
-    event->mval[0] = event->x - region->winrct.xmin;
-    event->mval[1] = event->y - region->winrct.ymin;
+    event->mval[0] = event->xy[0] - region->winrct.xmin;
+    event->mval[1] = event->xy[1] - region->winrct.ymin;
   }
   else {
     /* These values are invalid (avoid odd behavior by relying on old mval values). */
@@ -1422,10 +1421,10 @@ static int wm_operator_invoke(bContext *C,
           }
 
           if (region && region->regiontype == RGN_TYPE_WINDOW &&
-              BLI_rcti_isect_pt_v(&region->winrct, &event->x)) {
+              BLI_rcti_isect_pt_v(&region->winrct, event->xy)) {
             winrect = &region->winrct;
           }
-          else if (area && BLI_rcti_isect_pt_v(&area->totrct, &event->x)) {
+          else if (area && BLI_rcti_isect_pt_v(&area->totrct, event->xy)) {
             winrect = &area->totrct;
           }
 
@@ -1893,7 +1892,8 @@ static void wm_handler_op_context(bContext *C, wmEventHandler_Op *handler, const
       CTX_wm_area_set(C, area);
 
       if (op && (op->flag & OP_IS_MODAL_CURSOR_REGION)) {
-        region = BKE_area_find_region_xy(area, handler->context.region_type, event->x, event->y);
+        region = BKE_area_find_region_xy(
+            area, handler->context.region_type, event->xy[0], event->xy[1]);
         if (region) {
           handler->context.region = region;
         }
@@ -2491,7 +2491,8 @@ static int wm_handler_fileselect_do(bContext *C,
             wm_window_make_drawable(wm, ctx_win);
             /* Ensure correct cursor position, otherwise, popups may close immediately after
              * opening (UI_BLOCK_MOVEMOUSE_QUIT). */
-            wm_cursor_position_get(ctx_win, &ctx_win->eventstate->x, &ctx_win->eventstate->y);
+            wm_cursor_position_get(
+                ctx_win, &ctx_win->eventstate->xy[0], &ctx_win->eventstate->xy[1]);
             wm->winactive = ctx_win; /* Reports use this... */
             if (handler->context.win == win) {
               handler->context.win = NULL;
@@ -2811,7 +2812,7 @@ static int wm_handlers_do_gizmo_handler(bContext *C,
    * noticeable for the node editor - where dragging on a node should move it, see: T73212.
    * note we still allow for starting the gizmo drag outside, then travel 'inside' the node. */
   if (region->type->clip_gizmo_events_by_ui) {
-    if (UI_region_block_find_mouse_over(region, &event->x, true)) {
+    if (UI_region_block_find_mouse_over(region, &event->xy[0], true)) {
       if (gz != NULL && event->type != EVT_GIZMO_UPDATE) {
         if (restore_highlight_unless_activated == false) {
           WM_tooltip_clear(C, CTX_wm_window(C));
@@ -3172,16 +3173,16 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
     /* Test for CLICK_DRAG events. */
     if (wm_action_not_handled(action)) {
       if (win->event_queue_check_drag) {
-        if (WM_event_drag_test(event, &event->prevclickx)) {
+        if (WM_event_drag_test(event, event->prev_click_xy)) {
           win->event_queue_check_drag_handled = true;
 
-          int x = event->x;
-          int y = event->y;
+          int x = event->xy[0];
+          int y = event->xy[1];
           short val = event->val;
           short type = event->type;
 
-          event->x = event->prevclickx;
-          event->y = event->prevclicky;
+          event->xy[0] = event->prev_click_xy[0];
+          event->xy[1] = event->prev_click_xy[1];
           event->val = KM_CLICK_DRAG;
           event->type = event->prevtype;
 
@@ -3191,8 +3192,8 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
 
           event->val = val;
           event->type = type;
-          event->x = x;
-          event->y = y;
+          event->xy[0] = x;
+          event->xy[1] = y;
 
           win->event_queue_check_click = false;
           if (!wm_action_not_handled(action)) {
@@ -3230,18 +3231,18 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
         if (event->val == KM_RELEASE) {
           if (event->prevval == KM_PRESS) {
             if (win->event_queue_check_click == true) {
-              if (WM_event_drag_test(event, &event->prevclickx)) {
+              if (WM_event_drag_test(event, event->prev_click_xy)) {
                 win->event_queue_check_click = false;
                 win->event_queue_check_drag = false;
               }
               else {
                 /* Position is where the actual click happens, for more
                  * accurate selecting in case the mouse drifts a little. */
-                int x = event->x;
-                int y = event->y;
+                int x = event->xy[0];
+                int y = event->xy[1];
 
-                event->x = event->prevclickx;
-                event->y = event->prevclicky;
+                event->xy[0] = event->prev_click_xy[0];
+                event->xy[1] = event->prev_click_xy[1];
                 event->val = KM_CLICK;
 
                 CLOG_INFO(WM_LOG_HANDLERS, 1, "handling CLICK");
@@ -3249,8 +3250,8 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                 action |= wm_handlers_do_intern(C, win, event, handlers);
 
                 event->val = KM_RELEASE;
-                event->x = x;
-                event->y = y;
+                event->xy[0] = x;
+                event->xy[1] = y;
               }
             }
           }
@@ -3301,7 +3302,7 @@ static bool wm_event_inside_rect(const wmEvent *event, const rcti *rect)
   if (wm_event_always_pass(event)) {
     return true;
   }
-  if (BLI_rcti_isect_pt_v(rect, &event->x)) {
+  if (BLI_rcti_isect_pt_v(rect, event->xy)) {
     return true;
   }
   return false;
@@ -3312,7 +3313,7 @@ static bool wm_event_inside_region(const wmEvent *event, const ARegion *region)
   if (wm_event_always_pass(event)) {
     return true;
   }
-  return ED_region_contains_xy(region, &event->x);
+  return ED_region_contains_xy(region, event->xy);
 }
 
 static ScrArea *area_event_inside(bContext *C, const int xy[2])
@@ -3371,11 +3372,11 @@ static void wm_paintcursor_test(bContext *C, const wmEvent *event)
     }
 
     /* If previous position was not in current region, we have to set a temp new context. */
-    if (region == NULL || !BLI_rcti_isect_pt_v(&region->winrct, &event->prevx)) {
+    if (region == NULL || !BLI_rcti_isect_pt_v(&region->winrct, event->prev_xy)) {
       ScrArea *area = CTX_wm_area(C);
 
-      CTX_wm_area_set(C, area_event_inside(C, &event->prevx));
-      CTX_wm_region_set(C, region_event_inside(C, &event->prevx));
+      CTX_wm_area_set(C, area_event_inside(C, event->prev_xy));
+      CTX_wm_region_set(C, region_event_inside(C, event->prev_xy));
 
       wm_paintcursor_tag(C, wm->paintcursors.first, CTX_wm_region(C));
 
@@ -3637,15 +3638,15 @@ void wm_event_do_handlers(bContext *C)
       /* Clear tool-tip on mouse move. */
       if (screen->tool_tip && screen->tool_tip->exit_on_event) {
         if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) {
-          if (len_manhattan_v2v2_int(screen->tool_tip->event_xy, &event->x) > U.move_threshold) {
+          if (len_manhattan_v2v2_int(screen->tool_tip->event_xy, event->xy) > U.move_threshold) {
             WM_tooltip_clear(C, win);
           }
         }
       }
 
       /* We let modal handlers get active area/region, also wm_paintcursor_test needs it. */
-      CTX_wm_area_set(C, area_event_inside(C, &event->x));
-      CTX_wm_region_set(C, region_event_inside(C, &event->x));
+      CTX_wm_area_set(C, area_event_inside(C, event->xy));
+      CTX_wm_region_set(C, region_event_inside(C, event->xy));
 
       /* MVC demands to not draw in event handlers...
        * but we need to leave it for ogl selecting etc. */
@@ -3682,7 +3683,7 @@ void wm_event_do_handlers(bContext *C)
         if (event->type == MOUSEMOVE) {
           /* State variables in screen, cursors.
            * Also used in wm_draw.c, fails for modal handlers though. */
-          ED_screen_set_active_region(C, win, &event->x);
+          ED_screen_set_active_region(C, win, event->xy);
           /* For regions having custom cursors. */
           wm_paintcursor_test(C, event);
         }
@@ -3704,7 +3705,7 @@ void wm_event_do_handlers(bContext *C)
           /* Update azones if needed - done here because it needs to be independent from redraws.
            */
           if (area->flag & AREA_FLAG_ACTIONZONES_UPDATE) {
-            ED_area_azones_update(area, &event->x);
+            ED_area_azones_update(area, event->xy);
           }
 
           if (wm_event_inside_rect(event, &area->totrct)) {
@@ -3757,8 +3758,8 @@ void wm_event_do_handlers(bContext *C)
 
         if ((action & WM_HANDLER_BREAK) == 0) {
           /* Also some non-modal handlers need active area/region. */
-          CTX_wm_area_set(C, area_event_inside(C, &event->x));
-          CTX_wm_region_set(C, region_event_inside(C, &event->x));
+          CTX_wm_area_set(C, area_event_inside(C, event->xy));
+          CTX_wm_region_set(C, region_event_inside(C, event->xy));
 
           wm_region_mouse_co(C, event);
 
@@ -3787,8 +3788,8 @@ void wm_event_do_handlers(bContext *C)
       }
 
       /* Update previous mouse position for following events to use. */
-      win->eventstate->prevx = event->x;
-      win->eventstate->prevy = event->y;
+      win->eventstate->prev_xy[0] = event->xy[0];
+      win->eventstate->prev_xy[1] = event->xy[1];
 
       /* Unlink and free here, blender-quit then frees all. */
       BLI_remlink(&win->event_queue, event);
@@ -3798,10 +3799,10 @@ void wm_event_do_handlers(bContext *C)
     /* Only add mouse-move when the event queue was read entirely. */
     if (win->addmousemove && win->eventstate) {
       wmEvent tevent = *(win->eventstate);
-      // printf("adding MOUSEMOVE %d %d\n", tevent.x, tevent.y);
+      // printf("adding MOUSEMOVE %d %d\n", tevent.xy[0], tevent.xy[1]);
       tevent.type = MOUSEMOVE;
-      tevent.prevx = tevent.x;
-      tevent.prevy = tevent.y;
+      tevent.prev_xy[0] = tevent.xy[0];
+      tevent.prev_xy[1] = tevent.xy[1];
       tevent.is_repeat = false;
       wm_event_add(win, &tevent);
       win->addmousemove = 0;
@@ -4180,10 +4181,10 @@ wmEventHandler_Keymap *WM_event_add_keymap_handler_priority(ListBase *handlers,
 
 static bool event_or_prev_in_rect(const wmEvent *event, const rcti *rect)
 {
-  if (BLI_rcti_isect_pt(rect, event->x, event->y)) {
+  if (BLI_rcti_isect_pt(rect, event->xy[0], event->xy[1])) {
     return true;
   }
-  if (event->type == MOUSEMOVE && BLI_rcti_isect_pt(rect, event->prevx, event->prevy)) {
+  if (event->type == MOUSEMOVE && BLI_rcti_isect_pt(rect, event->prev_xy[0], event->prev_xy[1])) {
     return true;
   }
   return false;
@@ -4659,7 +4660,7 @@ static void attach_ndof_data(wmEvent *event, const GHOST_TEventNDOFMotionData *g
 /* Imperfect but probably usable... draw/enable drags to other windows. */
 static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *win, wmEvent *event)
 {
-  int mval[2] = {event->x, event->y};
+  int mval[2] = {event->xy[0], event->xy[1]};
 
   if (wm->windows.first == wm->windows.last) {
     return NULL;
@@ -4681,8 +4682,8 @@ static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *wi
 
     wmWindow *win_other = WM_window_find_under_cursor(wm, win, win, mval, mval);
     if (win_other) {
-      event->x = mval[0];
-      event->y = mval[1];
+      event->xy[0] = mval[0];
+      event->xy[1] = mval[1];
       return win_other;
     }
   }
@@ -4693,7 +4694,7 @@ static bool wm_event_is_double_click(const wmEvent *event)
 {
   if ((event->type == event->prevtype) && (event->prevval == KM_RELEASE) &&
       (event->val == KM_PRESS)) {
-    if (ISMOUSE(event->type) && WM_event_drag_test(event, &event->prevclickx)) {
+    if (ISMOUSE(event->type) && WM_event_drag_test(event, event->prev_click_xy)) {
       /* Pass. */
     }
     else {
@@ -4718,8 +4719,8 @@ static void wm_event_prev_values_set(wmEvent *event, wmEvent *event_state)
 static void wm_event_prev_click_set(wmEvent *event, wmEvent *event_state)
 {
   event->prevclicktime = event_state->prevclicktime = PIL_check_seconds_timer();
-  event->prevclickx = event_state->prevclickx = event_state->x;
-  event->prevclicky = event_state->prevclicky = event_state->y;
+  event->prev_click_xy[0] = event_state->prev_click_xy[0] = event_state->xy[1];
+  event->prev_click_xy[1] = event_state->prev_click_xy[1] = event_state->xy[1];
 }
 
 static wmEvent *wm_event_add_mousemove(wmWindow *win, const wmEvent *event)
@@ -4739,7 +4740,7 @@ static wmEvent *wm_event_add_mousemove(wmWindow *win, const wmEvent *event)
     event_last = win->eventstate;
   }
 
-  copy_v2_v2_int(&event_new->prevx, &event_last->x);
+  copy_v2_v2_int(event_new->prev_xy, event_last->xy);
   return event_new;
 }
 
@@ -4749,16 +4750,16 @@ static wmEvent *wm_event_add_trackpad(wmWindow *win, const wmEvent *event, int d
    * for painting with mouse moves, for navigation using the accumulated value is ok. */
   wmEvent *event_last = win->event_queue.last;
   if (event_last && event_last->type == event->type) {
-    deltax += event_last->x - event_last->prevx;
-    deltay += event_last->y - event_last->prevy;
+    deltax += event_last->xy[0] - event_last->prev_xy[0];
+    deltay += event_last->xy[1] - event_last->prev_xy[1];
 
     wm_event_free_last(win);
   }
 
-  /* Set prevx/prevy, the delta is computed from this in operators. */
+  /* Set prev_xy, the delta is computed from this in operators. */
   wmEvent *event_new = wm_event_add(win, event);
-  event_new->prevx = event_new->x - deltax;
-  event_new->prevy = event_new->y - deltay;
+  event_new->prev_xy[0] = event_new->xy[0] - deltax;
+  event_new->prev_xy[1] = event_new->xy[1] - deltay;
 
   return event_new;
 }
@@ -4827,14 +4828,14 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
     case GHOST_kEventCursorMove: {
       GHOST_TEventCursorData *cd = customdata;
 
-      copy_v2_v2_int(&event.x, &cd->x);
-      wm_stereo3d_mouse_offset_apply(win, &event.x);
+      copy_v2_v2_int(event.xy, &cd->x);
+      wm_stereo3d_mouse_offset_apply(win, &event.xy[0]);
       wm_tablet_data_from_ghost(&cd->tablet, &event.tablet);
 
       event.type = MOUSEMOVE;
       {
         wmEvent *event_new = wm_event_add_mousemove(win, &event);
-        copy_v2_v2_int(&event_state->x, &event_new->x);
+        copy_v2_v2_int(event_state->xy, event_new->xy);
         event_state->tablet.is_motion_absolute = event_new->tablet.is_motion_absolute;
       }
 
@@ -4848,11 +4849,11 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
         event_other.prevtype = event_other.type;
         event_other.prevval = event_other.val;
 
-        copy_v2_v2_int(&event_other.x, &event.x);
+        copy_v2_v2_int(event_other.xy, event.xy);
         event_other.type = MOUSEMOVE;
         {
           wmEvent *event_new = wm_event_add_mousemove(win_other, &event_other);
-          copy_v2_v2_int(&win_other->eventstate->x, &event_new->x);
+          copy_v2_v2_int(win_other->eventstate->xy, event_new->xy);
           win_other->eventstate->tablet.is_motion_absolute = event_new->tablet.is_motion_absolute;
         }
       }
@@ -4879,8 +4880,8 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
           break;
       }
 
-      event.x = event_state->x = pd->x;
-      event.y = event_state->y = pd->y;
+      event.xy[0] = event_state->xy[0] = pd->x;
+      event.xy[1] = event_state->xy[1] = pd->y;
       event.val = KM_NOTHING;
 
       /* The direction is inverted from the device due to system preferences. */
@@ -4947,7 +4948,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
         event_other.prevtype = event_other.type;
         event_other.prevval = event_other.val;
 
-        copy_v2_v2_int(&event_other.x, &event.x);
+        copy_v2_v2_int(event_other.xy, event.xy);
 
         event_other.type = event.type;
         event_other.val = event.val;
@@ -5125,7 +5126,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
       attach_ndof_data(&event, customdata);
       wm_event_add(win, &event);
 
-      CLOG_INFO(WM_LOG_HANDLERS, 1, "sending NDOF_MOTION, prev = %d %d", event.x, event.y);
+      CLOG_INFO(WM_LOG_HANDLERS, 1, "sending NDOF_MOTION, prev = %d %d", event.xy[0], event.xy[1]);
       break;
     }
 
diff --git a/source/blender/windowmanager/intern/wm_gesture.c b/source/blender/windowmanager/intern/wm_gesture.c
index ae2cdb5608c..ab971901a20 100644
--- a/source/blender/windowmanager/intern/wm_gesture.c
+++ b/source/blender/windowmanager/intern/wm_gesture.c
@@ -73,14 +73,14 @@ wmGesture *WM_gesture_new(wmWindow *window, const ARegion *region, const wmEvent
     rcti *rect = MEM_callocN(sizeof(rcti), "gesture rect new");
 
     gesture->customdata = rect;
-    rect->xmin = event->x - gesture->winrct.xmin;
-    rect->ymin = event->y - gesture->winrct.ymin;
+    rect->xmin = event->xy[0] - gesture->winrct.xmin;
+    rect->ymin = event->xy[1] - gesture->winrct.ymin;
     if (type == WM_GESTURE_CIRCLE) {
       /* caller is responsible for initializing 'xmax' to radius. */
     }
     else {
-      rect->xmax = event->x - gesture->winrct.xmin;
-      rect->ymax = event->y - gesture->winrct.ymin;
+      rect->xmax = event->xy[0] - gesture->winrct.xmin;
+      rect->ymax = event->xy[1] - gesture->winrct.ymin;
     }
   }
   else if (ELEM(type, WM_GESTURE_LINES, WM_GESTURE_LASSO)) {
@@ -88,8 +88,8 @@ wmGesture *WM_gesture_new(wmWindow *window, const ARegion *region, const wmEvent
     gesture->points_alloc = 1024;
     gesture->customdata = lasso = MEM_mallocN(sizeof(short[2]) * gesture->points_alloc,
                                               "lasso points");
-    lasso[0] = event->x - gesture->winrct.xmin;
-    lasso[1] = event->y - gesture->winrct.ymin;
+    lasso[0] = event->xy[0] - gesture->winrct.xmin;
+    lasso[1] = event->xy[1] - gesture->winrct.ymin;
     gesture->points = 1;
   }
 
diff --git a/source/blender/windowmanager/intern/wm_gesture_ops.c b/source/blender/windowmanager/intern/wm_gesture_ops.c
index 578699dda60..19b678d79d8 100644
--- a/source/blender/windowmanager/intern/wm_gesture_ops.c
+++ b/source/blender/windowmanager/intern/wm_gesture_ops.c
@@ -245,17 +245,17 @@ int WM_gesture_box_modal(bContext *C, wmOperator *op, const wmEvent *event)
     switch (event->type) {
       case MOUSEMOVE: {
         if (gesture->type == WM_GESTURE_CROSS_RECT && gesture->is_active == false) {
-          rect->xmin = rect->xmax = event->x - gesture->winrct.xmin;
-          rect->ymin = rect->ymax = event->y - gesture->winrct.ymin;
+          rect->xmin = rect->xmax = event->xy[0] - gesture->winrct.xmin;
+          rect->ymin = rect->ymax = event->xy[1] - gesture->winrct.ymin;
         }
         else if (gesture->move) {
           BLI_rcti_translate(rect,
-                             (event->x - gesture->winrct.xmin) - rect->xmax,
-                             (event->y - gesture->winrct.ymin) - rect->ymax);
+                             (event->xy[0] - gesture->winrct.xmin) - rect->xmax,
+                             (event->xy[1] - gesture->winrct.ymin) - rect->ymax);
         }
         else {
-          rect->xmax = event->x - gesture->winrct.xmin;
-          rect->ymax = event->y - gesture->winrct.ymin;
+          rect->xmax = event->xy[0] - gesture->winrct.xmin;
+          rect->ymax = event->xy[1] - gesture->winrct.ymin;
         }
         gesture_box_apply_rect(op);
 
@@ -365,8 +365,8 @@ int WM_gesture_circle_modal(bContext *C, wmOperator *op, const wmEvent *event)
 
   if (event->type == MOUSEMOVE) {
 
-    rect->xmin = event->x - gesture->winrct.xmin;
-    rect->ymin = event->y - gesture->winrct.ymin;
+    rect->xmin = event->xy[0] - gesture->winrct.xmin;
+    rect->ymin = event->xy[1] - gesture->winrct.ymin;
 
     wm_gesture_tag_redraw(win);
 
@@ -381,7 +381,7 @@ int WM_gesture_circle_modal(bContext *C, wmOperator *op, const wmEvent *event)
 
     switch (event->val) {
       case GESTURE_MODAL_CIRCLE_SIZE:
-        fac = 0.3f * (event->y - event->prevy);
+        fac = 0.3f * (event->xy[1] - event->prev_xy[1]);
         if (fac > 0) {
           rect->xmax += ceil(fac);
         }
@@ -500,8 +500,8 @@ static void gesture_tweak_modal(bContext *C, const wmEvent *event)
     case MOUSEMOVE:
     case INBETWEEN_MOUSEMOVE: {
 
-      rect->xmax = event->x - gesture->winrct.xmin;
-      rect->ymax = event->y - gesture->winrct.ymin;
+      rect->xmax = event->xy[0] - gesture->winrct.xmin;
+      rect->ymax = event->xy[1] - gesture->winrct.ymin;
 
       const int val = wm_gesture_evaluate(gesture, event);
       if (val != 0) {
@@ -510,8 +510,8 @@ static void gesture_tweak_modal(bContext *C, const wmEvent *event)
         wm_event_init_from_window(window, &tevent);
         /* We want to get coord from start of drag,
          * not from point where it becomes a tweak event, see T40549. */
-        tevent.x = rect->xmin + gesture->winrct.xmin;
-        tevent.y = rect->ymin + gesture->winrct.ymin;
+        tevent.xy[0] = rect->xmin + gesture->winrct.xmin;
+        tevent.xy[1] = rect->ymin + gesture->winrct.ymin;
         if (gesture->event_type == LEFTMOUSE) {
           tevent.type = EVT_TWEAK_L;
         }
@@ -696,8 +696,8 @@ int WM_gesture_lasso_modal(bContext *C, wmOperator *op, const wmEvent *event)
         {
           short(*lasso)[2] = gesture->customdata;
 
-          const int x = ((event->x - gesture->winrct.xmin) - lasso[gesture->points - 1][0]);
-          const int y = ((event->y - gesture->winrct.ymin) - lasso[gesture->points - 1][1]);
+          const int x = ((event->xy[0] - gesture->winrct.xmin) - lasso[gesture->points - 1][0]);
+          const int y = ((event->xy[1] - gesture->winrct.ymin) - lasso[gesture->points - 1][1]);
 
           /* move the lasso */
           if (gesture->move) {
@@ -709,8 +709,8 @@ int WM_gesture_lasso_modal(bContext *C, wmOperator *op, const wmEvent *event)
           /* Make a simple distance check to get a smoother lasso
            * add only when at least 2 pixels between this and previous location. */
           else if ((x * x + y * y) > pow2f(2.0f * UI_DPI_FAC)) {
-            lasso[gesture->points][0] = event->x - gesture->winrct.xmin;
-            lasso[gesture->points][1] = event->y - gesture->winrct.ymin;
+            lasso[gesture->points][0] = event->xy[0] - gesture->winrct.xmin;
+            lasso[gesture->points][1] = event->xy[1] - gesture->winrct.ymin;
             gesture->points++;
           }
         }
@@ -981,18 +981,18 @@ int WM_gesture_straightline_modal(bContext *C, wmOperator *op, const wmEvent *ev
     switch (event->type) {
       case MOUSEMOVE: {
         if (gesture->is_active == false) {
-          rect->xmin = rect->xmax = event->x - gesture->winrct.xmin;
-          rect->ymin = rect->ymax = event->y - gesture->winrct.ymin;
+          rect->xmin = rect->xmax = event->xy[0] - gesture->winrct.xmin;
+          rect->ymin = rect->ymax = event->xy[1] - gesture->winrct.ymin;
         }
         else if (gesture->move) {
           BLI_rcti_translate(rect,
-                             (event->x - gesture->winrct.xmin) - rect->xmax,
-                             (event->y - gesture->winrct.ymin) - rect->ymax);
+                             (event->xy[0] - gesture->winrct.xmin) - rect->xmax,
+                             (event->xy[1] - gesture->winrct.ymin) - rect->ymax);
           gesture_straightline_apply(C, op);
         }
         else {
-          rect->xmax = event->x - gesture->winrct.xmin;
-          rect->ymax = event->y - gesture->winrct.ymin;
+          rect->xmax = event->xy[0] - gesture->winrct.xmin;
+          rect->ymax = event->xy[1] - gesture->winrct.ymin;
           gesture_straightline_apply(C, op);
         }
 
@@ -1072,17 +1072,17 @@ int WM_gesture_straightline_oneshot_modal(bContext *C, wmOperator *op, const wmE
     switch (event->type) {
       case MOUSEMOVE: {
         if (gesture->is_active == false) {
-          rect->xmin = rect->xmax = event->x - gesture->winrct.xmin;
-          rect->ymin = rect->ymax = event->y - gesture->winrct.ymin;
+          rect->xmin = rect->xmax = event->xy[0] - gesture->winrct.xmin;
+          rect->ymin = rect->ymax = event->xy[1] - gesture->winrct.ymin;
         }
         else if (gesture->move) {
           BLI_rcti_translate(rect,
-                             (event->x - gesture->winrct.xmin) - rect->xmax,
-                             (event->y - gesture->winrct.ymin) - rect->ymax);
+                             (event->xy[0] - gesture->winrct.xmin) - rect->xmax,
+                             (event->xy[1] - gesture->winrct.ymin) - rect->ymax);
         }
         else {
-          rect->xmax = event->x - gesture->winrct.xmin;
-          rect->ymax = event->y - gesture->winrct.ymin;
+          rect->xmax = event->xy[0] - gesture->winrct.xmin;
+          rect->ymax = event->xy[1] - gesture->winrct.ymin;
         }
 
         if (gesture->use_snap) {
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index 0e58e1c0466..b6a4a3a94bf 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -2274,11 +2274,11 @@ static void radial_control_set_initial_mouse(RadialControl *rc, const wmEvent *e
   float d[2] = {0, 0};
   float zoom[2] = {1, 1};
 
-  rc->initial_mouse[0] = event->x;
-  rc->initial_mouse[1] = event->y;
+  rc->initial_mouse[0] = event->xy[0];
+  rc->initial_mouse[1] = event->xy[1];
 
-  rc->initial_co[0] = event->x;
-  rc->initial_co[1] = event->y;
+  rc->initial_co[0] = event->xy[0];
+  rc->initial_co[1] = event->xy[1];
 
   switch (rc->subtype) {
     case PROP_NONE:
@@ -2954,7 +2954,7 @@ static int radial_control_modal(bContext *C, wmOperator *op, const wmEvent *even
       if (!has_numInput) {
         if (rc->slow_mode) {
           if (rc->subtype == PROP_ANGLE) {
-            const float position[2] = {event->x, event->y};
+            const float position[2] = {event->xy[0], event->xy[1]};
 
             /* calculate the initial angle here first */
             delta[0] = rc->initial_mouse[0] - rc->slow_mouse[0];
@@ -2974,7 +2974,7 @@ static int radial_control_modal(bContext *C, wmOperator *op, const wmEvent *even
 
             dist = len_v2(delta);
 
-            delta[0] = event->x - rc->slow_mouse[0];
+            delta[0] = event->xy[0] - rc->slow_mouse[0];
 
             if (rc->zoom_prop) {
               delta[0] /= zoom[0];
@@ -2984,8 +2984,8 @@ static int radial_control_modal(bContext *C, wmOperator *op, const wmEvent *even
           }
         }
         else {
-          delta[0] = rc->initial_mouse[0] - event->x;
-          delta[1] = rc->initial_mouse[1] - event->y;
+          delta[0] = rc->initial_mouse[0] - event->xy[0];
+          delta[1] = rc->initial_mouse[1] - event->xy[1];
           if (rc->zoom_prop) {
             RNA_property_float_get_array(&rc->zoom_ptr, rc->zoom_prop, zoom);
             delta[0] /= zoom[0];
@@ -3052,8 +3052,8 @@ static int radial_control_modal(bContext *C, wmOperator *op, const wmEvent *even
     case EVT_LEFTSHIFTKEY:
     case EVT_RIGHTSHIFTKEY: {
       if (event->val == KM_PRESS) {
-        rc->slow_mouse[0] = event->x;
-        rc->slow_mouse[1] = event->y;
+        rc->slow_mouse[0] = event->xy[0];
+        rc->slow_mouse[1] = event->xy[1];
         rc->slow_mode = true;
         if (rc->subtype == PROP_ANGLE) {
           const float initial_position[2] = {UNPACK2(rc->initial_mouse)};
diff --git a/source/blender/windowmanager/intern/wm_tooltip.c b/source/blender/windowmanager/intern/wm_tooltip.c
index a9f0e01cfb5..3bcd122f08d 100644
--- a/source/blender/windowmanager/intern/wm_tooltip.c
+++ b/source/blender/windowmanager/intern/wm_tooltip.c
@@ -131,7 +131,7 @@ void WM_tooltip_init(bContext *C, wmWindow *win)
     CTX_wm_region_set(C, region_prev);
   }
 
-  copy_v2_v2_int(screen->tool_tip->event_xy, &win->eventstate->x);
+  copy_v2_v2_int(screen->tool_tip->event_xy, win->eventstate->xy);
   if (pass_prev != screen->tool_tip->pass) {
     /* The pass changed, add timer for next pass. */
     wmWindowManager *wm = CTX_wm_manager(C);
diff --git a/source/blender/windowmanager/intern/wm_window.c b/source/blender/windowmanager/intern/wm_window.c
index 2c92d4ac6f8..e8d626512ca 100644
--- a/source/blender/windowmanager/intern/wm_window.c
+++ b/source/blender/windowmanager/intern/wm_window.c
@@ -521,7 +521,7 @@ void WM_window_set_dpi(const wmWindow *win)
 static void wm_window_update_eventstate(wmWindow *win)
 {
   /* Update mouse position when a window is activated. */
-  wm_cursor_position_get(win, &win->eventstate->x, &win->eventstate->y);
+  wm_cursor_position_get(win, &win->eventstate->xy[0], &win->eventstate->xy[1]);
 }
 
 static void wm_window_ensure_eventstate(wmWindow *win)
@@ -990,8 +990,8 @@ void wm_cursor_position_to_ghost(wmWindow *win, int *x, int *y)
 void wm_cursor_position_get(wmWindow *win, int *r_x, int *r_y)
 {
   if (UNLIKELY(G.f & G_FLAG_EVENT_SIMULATE)) {
-    *r_x = win->eventstate->x;
-    *r_y = win->eventstate->y;
+    *r_x = win->eventstate->xy[0];
+    *r_y = win->eventstate->xy[1];
     return;
   }
   GHOST_GetCursorPosition(g_system, r_x, r_y);
@@ -1266,8 +1266,7 @@ static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr C_void_ptr
         wmEvent event;
         wm_event_init_from_window(win, &event);
         event.type = MOUSEMOVE;
-        event.prevx = event.x;
-        event.prevy = event.y;
+        copy_v2_v2_int(event.prev_xy, event.xy);
         event.is_repeat = false;
 
         wm_event_add(win, &event);
@@ -1398,8 +1397,7 @@ static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr C_void_ptr
 
         /* activate region */
         event.type = MOUSEMOVE;
-        event.prevx = event.x;
-        event.prevy = event.y;
+        copy_v2_v2_int(event.prev_xy, event.xy);
         event.is_repeat = false;
 
         /* No context change! C->wm->windrawable is drawable, or for area queues. */
@@ -2099,11 +2097,11 @@ void WM_cursor_warp(wmWindow *win, int x, int y)
     wm_cursor_position_to_ghost(win, &x, &y);
     GHOST_SetCursorPosition(g_system, x, y);
 
-    win->eventstate->prevx = oldx;
-    win->eventstate->prevy = oldy;
+    win->eventstate->prev_xy[0] = oldx;
+    win->eventstate->prev_xy[1] = oldy;
 
-    win->eventstate->x = oldx;
-    win->eventstate->y = oldy;
+    win->eventstate->xy[0] = oldx;
+    win->eventstate->xy[1] = oldy;
   }
 }