[mutter/wip/wayland-clutter-events: 15/17] Move the motion event handling code to work in terms of Clutter events
- From: Neil Roberts <nroberts src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [mutter/wip/wayland-clutter-events: 15/17] Move the motion event handling code to work in terms of Clutter events
- Date: Thu, 5 Sep 2013 13:21:00 +0000 (UTC)
commit 4492845528c68a24e30c620feba5c4fb29e1e4e4
Author: Neil Roberts <neil linux intel com>
Date: Mon Sep 2 11:37:13 2013 +0100
Move the motion event handling code to work in terms of Clutter events
There is now a meta_display_handle_event alongside the
meta_display_handle_xevent function which handles events in terms of
Clutter events instead of X events. A Clutter event filter is
registered so that all Clutter events will pass through this function.
The motion event handling code from the X event version has been moved
into this new function and has been modified to use the details from
the Clutter event instead of the X event. This is a step towards
moving all of the code over and finally removing the
meta_display_handle_xevent function.
src/core/display-private.h | 6 +-
src/core/display.c | 476 +++++++++++++++++++++++++-------------------
src/core/window-private.h | 5 +-
src/core/window.c | 171 +++++-----------
4 files changed, 331 insertions(+), 327 deletions(-)
---
diff --git a/src/core/display-private.h b/src/core/display-private.h
index e049948..5be9999 100644
--- a/src/core/display-private.h
+++ b/src/core/display-private.h
@@ -39,6 +39,7 @@
#include "keybindings-private.h"
#include <meta/prefs.h>
#include <meta/barrier.h>
+#include <clutter/clutter.h>
#ifdef HAVE_STARTUP_NOTIFICATION
#include <libsn/sn.h>
@@ -188,7 +189,7 @@ struct _MetaDisplay
MetaWindow* autoraise_window;
/* Alt+click button grabs */
- unsigned int window_grab_modifiers;
+ ClutterModifierType window_grab_modifiers;
/* current window operation */
MetaGrabOp grab_op;
@@ -479,6 +480,9 @@ guint meta_display_get_above_tab_keycode (MetaDisplay *display);
gboolean meta_display_handle_xevent (MetaDisplay *display,
XEvent *event);
+gboolean meta_display_handle_event (MetaDisplay *display,
+ const ClutterEvent *event);
+
#ifdef HAVE_XI23
gboolean meta_display_process_barrier_event (MetaDisplay *display,
XIBarrierEvent *event);
diff --git a/src/core/display.c b/src/core/display.c
index f454c74..1aa483b 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -177,8 +177,10 @@ static void meta_spew_event (MetaDisplay *display,
XEvent *event);
#endif
-static gboolean event_callback (XEvent *event,
+static gboolean xevent_callback (XEvent *event,
gpointer data);
+static gboolean event_callback (const ClutterEvent *event,
+ gpointer data);
static Window event_get_modified_window (MetaDisplay *display,
XEvent *event);
static guint32 event_get_time (MetaDisplay *display,
@@ -604,8 +606,9 @@ meta_display_open (void)
/* Get events */
meta_ui_add_event_func (the_display->xdisplay,
- event_callback,
+ xevent_callback,
the_display);
+ clutter_event_add_filter (event_callback, the_display);
the_display->xids = g_hash_table_new (meta_unsigned_long_hash,
meta_unsigned_long_equal);
@@ -1125,8 +1128,9 @@ meta_display_close (MetaDisplay *display,
/* Stop caring about events */
meta_ui_remove_event_func (display->xdisplay,
- event_callback,
+ xevent_callback,
display);
+ clutter_event_remove_filter (event_callback, display);
/* Free all screens */
tmp = display->screens;
@@ -2386,7 +2390,6 @@ meta_display_handle_xevent (MetaDisplay *display,
if (input_event != NULL)
{
- XIDeviceEvent *device_event = (XIDeviceEvent *) input_event;
XIEnterEvent *enter_event = (XIEnterEvent *) input_event;
if (window && !window->override_redirect &&
@@ -2423,205 +2426,6 @@ meta_display_handle_xevent (MetaDisplay *display,
if (meta_display_process_key_event (display, window, (XIDeviceEvent *) input_event))
filter_out_event = bypass_compositor = TRUE;
break;
- case XI_ButtonPress:
- if (display->grab_op == META_GRAB_OP_COMPOSITOR)
- break;
-
- display->overlay_key_only_pressed = FALSE;
-
- if (device_event->detail == 4 || device_event->detail == 5)
- /* Scrollwheel event, do nothing and deliver event to compositor below */
- break;
-
- if ((window &&
- meta_grab_op_is_mouse (display->grab_op) &&
- display->grab_button != device_event->detail &&
- display->grab_window == window) ||
- grab_op_is_keyboard (display->grab_op))
- {
- meta_topic (META_DEBUG_WINDOW_OPS,
- "Ending grab op %u on window %s due to button press\n",
- display->grab_op,
- (display->grab_window ?
- display->grab_window->desc :
- "none"));
- if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
- {
- MetaScreen *screen;
- meta_topic (META_DEBUG_WINDOW_OPS,
- "Syncing to old stack positions.\n");
- screen =
- meta_display_screen_for_root (display, device_event->event);
-
- if (screen!=NULL)
- meta_stack_set_positions (screen->stack,
- display->grab_old_window_stacking);
- }
- meta_display_end_grab_op (display,
- device_event->time);
- }
- else if (window && display->grab_op == META_GRAB_OP_NONE)
- {
- gboolean begin_move = FALSE;
- unsigned int grab_mask;
- gboolean unmodified;
-
- grab_mask = display->window_grab_modifiers;
- if (g_getenv ("MUTTER_DEBUG_BUTTON_GRABS"))
- grab_mask |= ControlMask;
-
- /* Two possible sources of an unmodified event; one is a
- * client that's letting button presses pass through to the
- * frame, the other is our focus_window_grab on unmodified
- * button 1. So for all such events we focus the window.
- */
- unmodified = (device_event->mods.effective & grab_mask) == 0;
-
- if (unmodified ||
- device_event->detail == 1)
- {
- /* don't focus if frame received, will be lowered in
- * frames.c or special-cased if the click was on a
- * minimize/close button.
- */
- if (!frame_was_receiver)
- {
- if (meta_prefs_get_raise_on_click ())
- meta_window_raise (window);
- else
- meta_topic (META_DEBUG_FOCUS,
- "Not raising window on click due to don't-raise-on-click option\n");
-
- /* Don't focus panels--they must explicitly request focus.
- * See bug 160470
- */
- if (window->type != META_WINDOW_DOCK)
- {
- meta_topic (META_DEBUG_FOCUS,
- "Focusing %s due to unmodified button %u press (display.c)\n",
- window->desc, device_event->detail);
- meta_window_focus (window, device_event->time);
- }
- else
- /* However, do allow terminals to lose focus due to new
- * window mappings after the user clicks on a panel.
- */
- display->allow_terminal_deactivation = TRUE;
- }
-
- /* you can move on alt-click but not on
- * the click-to-focus
- */
- if (!unmodified)
- begin_move = TRUE;
- }
- else if (!unmodified && device_event->detail == meta_prefs_get_mouse_button_resize())
- {
- if (window->has_resize_func)
- {
- gboolean north, south;
- gboolean west, east;
- int root_x, root_y;
- MetaGrabOp op;
-
- meta_window_get_position (window, &root_x, &root_y);
-
- west = device_event->root_x < (root_x + 1 * window->rect.width / 3);
- east = device_event->root_x > (root_x + 2 * window->rect.width / 3);
- north = device_event->root_y < (root_y + 1 * window->rect.height / 3);
- south = device_event->root_y > (root_y + 2 * window->rect.height / 3);
-
- if (north && west)
- op = META_GRAB_OP_RESIZING_NW;
- else if (north && east)
- op = META_GRAB_OP_RESIZING_NE;
- else if (south && west)
- op = META_GRAB_OP_RESIZING_SW;
- else if (south && east)
- op = META_GRAB_OP_RESIZING_SE;
- else if (north)
- op = META_GRAB_OP_RESIZING_N;
- else if (west)
- op = META_GRAB_OP_RESIZING_W;
- else if (east)
- op = META_GRAB_OP_RESIZING_E;
- else if (south)
- op = META_GRAB_OP_RESIZING_S;
- else /* Middle region is no-op to avoid user triggering wrong action */
- op = META_GRAB_OP_NONE;
-
- if (op != META_GRAB_OP_NONE)
- meta_display_begin_grab_op (display,
- window->screen,
- window,
- op,
- TRUE,
- FALSE,
- device_event->detail,
- 0,
- device_event->time,
- device_event->root_x,
- device_event->root_y);
- }
- }
- else if (device_event->detail == meta_prefs_get_mouse_button_menu())
- {
- if (meta_prefs_get_raise_on_click ())
- meta_window_raise (window);
- meta_window_show_menu (window,
- device_event->root_x,
- device_event->root_y,
- device_event->detail,
- device_event->time);
- }
-
- if (!frame_was_receiver && unmodified)
- {
- /* This is from our synchronous grab since
- * it has no modifiers and was on the client window
- */
-
- meta_verbose ("Allowing events time %u\n",
- (unsigned int)device_event->time);
-
- XIAllowEvents (display->xdisplay, device_event->deviceid,
- XIReplayDevice, device_event->time);
- }
-
- if (begin_move && window->has_move_func)
- {
- meta_display_begin_grab_op (display,
- window->screen,
- window,
- META_GRAB_OP_MOVING,
- TRUE,
- FALSE,
- device_event->detail,
- 0,
- device_event->time,
- device_event->root_x,
- device_event->root_y);
- }
- }
- break;
- case XI_ButtonRelease:
- if (display->grab_op == META_GRAB_OP_COMPOSITOR)
- break;
-
- display->overlay_key_only_pressed = FALSE;
-
- if (display->grab_window == window &&
- meta_grab_op_is_mouse (display->grab_op))
- meta_window_handle_mouse_grab_op_event (window, device_event);
- break;
- case XI_Motion:
- if (display->grab_op == META_GRAB_OP_COMPOSITOR)
- break;
-
- if (display->grab_window == window &&
- meta_grab_op_is_mouse (display->grab_op))
- meta_window_handle_mouse_grab_op_event (window, device_event);
- break;
case XI_Enter:
if (display->grab_op == META_GRAB_OP_COMPOSITOR)
break;
@@ -3207,8 +3011,8 @@ meta_display_handle_xevent (MetaDisplay *display,
}
static gboolean
-event_callback (XEvent *event,
- gpointer data)
+xevent_callback (XEvent *event,
+ gpointer data)
{
MetaDisplay *display = data;
@@ -3232,6 +3036,268 @@ event_callback (XEvent *event,
return meta_display_handle_xevent (display, event);
}
+static MetaWindow *
+get_window_for_actor (ClutterActor *actor,
+ gboolean *frame_was_receiver)
+{
+ /* Look for any ancestor that is a MetaWindowActor to determine
+ which window the actor's event belongs to */
+
+ *frame_was_receiver = TRUE;
+
+ while (actor)
+ {
+ if (META_IS_WINDOW_ACTOR (actor))
+ return meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor));
+
+ /* If the frame is the receiver then the source will directly be
+ the MetaWindowActor, otherwise it will be a child of a
+ MetaWindowActor so if we make it here then the event isn't
+ referring to the frame. */
+ *frame_was_receiver = FALSE;
+
+ actor = clutter_actor_get_parent (actor);
+ }
+
+ return NULL;
+}
+
+gboolean
+meta_display_handle_event (MetaDisplay *display,
+ const ClutterEvent *event)
+{
+ MetaWindow *window;
+ gboolean frame_was_receiver;
+
+ window = get_window_for_actor (event->any.source, &frame_was_receiver);
+
+ switch (event->type)
+ {
+ case CLUTTER_BUTTON_PRESS:
+ if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+ break;
+
+ display->overlay_key_only_pressed = FALSE;
+
+ if ((window &&
+ meta_grab_op_is_mouse (display->grab_op) &&
+ display->grab_button != (int) event->button.button &&
+ display->grab_window == window) ||
+ grab_op_is_keyboard (display->grab_op))
+ {
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Ending grab op %u on window %s due to button press\n",
+ display->grab_op,
+ (display->grab_window ?
+ display->grab_window->desc :
+ "none"));
+ if (GRAB_OP_IS_WINDOW_SWITCH (display->grab_op))
+ {
+ meta_topic (META_DEBUG_WINDOW_OPS,
+ "Syncing to old stack positions.\n");
+
+ /* XXX: I'm not sure if this is the right thing to do.
+ The pre-Wayland code was only calling
+ meta_stack_set_positions if the modified window was a
+ root window */
+ if (CLUTTER_ACTOR (event->any.stage) == event->any.source &&
+ window &&
+ window->screen)
+ meta_stack_set_positions (window->screen->stack,
+ display->grab_old_window_stacking);
+ }
+ meta_display_end_grab_op (display,
+ event->any.time);
+ }
+ else if (window && display->grab_op == META_GRAB_OP_NONE)
+ {
+ gboolean begin_move = FALSE;
+ ClutterModifierType grab_mask;
+ gboolean unmodified;
+
+ grab_mask = display->window_grab_modifiers;
+ if (g_getenv ("MUTTER_DEBUG_BUTTON_GRABS"))
+ grab_mask |= CLUTTER_CONTROL_MASK;
+
+ /* Two possible sources of an unmodified event; one is a
+ * client that's letting button presses pass through to the
+ * frame, the other is our focus_window_grab on unmodified
+ * button 1. So for all such events we focus the window.
+ */
+ unmodified = (clutter_event_get_state (event) & grab_mask) == 0;
+
+ if (unmodified ||
+ event->button.button == 1)
+ {
+ /* don't focus if frame received, will be lowered in
+ * frames.c or special-cased if the click was on a
+ * minimize/close button.
+ */
+ if (!frame_was_receiver)
+ {
+ if (meta_prefs_get_raise_on_click ())
+ meta_window_raise (window);
+ else
+ meta_topic (META_DEBUG_FOCUS,
+ "Not raising window on click due "
+ "to don't-raise-on-click option\n");
+
+ /* Don't focus panels--they must explicitly request focus.
+ * See bug 160470
+ */
+ if (window->type != META_WINDOW_DOCK)
+ {
+ meta_topic (META_DEBUG_FOCUS,
+ "Focusing %s due to unmodified button %u "
+ "press (display.c)\n",
+ window->desc, event->button.button);
+ meta_window_focus (window, event->any.time);
+ }
+ else
+ /* However, do allow terminals to lose focus due to new
+ * window mappings after the user clicks on a panel.
+ */
+ display->allow_terminal_deactivation = TRUE;
+ }
+
+ /* you can move on alt-click but not on
+ * the click-to-focus
+ */
+ if (!unmodified)
+ begin_move = TRUE;
+ }
+ else if (!unmodified &&
+ ((int) event->button.button ==
+ meta_prefs_get_mouse_button_resize ()))
+ {
+ if (window->has_resize_func)
+ {
+ gboolean north, south;
+ gboolean west, east;
+ int root_x, root_y;
+ MetaGrabOp op;
+
+ meta_window_get_position (window, &root_x, &root_y);
+
+ west = (event->button.x <
+ (root_x + 1 * window->rect.width / 3));
+ east = (event->button.x >
+ (root_x + 2 * window->rect.width / 3));
+ north = (event->button.y <
+ (root_y + 1 * window->rect.height / 3));
+ south = (event->button.y >
+ (root_y + 2 * window->rect.height / 3));
+
+ if (north && west)
+ op = META_GRAB_OP_RESIZING_NW;
+ else if (north && east)
+ op = META_GRAB_OP_RESIZING_NE;
+ else if (south && west)
+ op = META_GRAB_OP_RESIZING_SW;
+ else if (south && east)
+ op = META_GRAB_OP_RESIZING_SE;
+ else if (north)
+ op = META_GRAB_OP_RESIZING_N;
+ else if (west)
+ op = META_GRAB_OP_RESIZING_W;
+ else if (east)
+ op = META_GRAB_OP_RESIZING_E;
+ else if (south)
+ op = META_GRAB_OP_RESIZING_S;
+ else
+ /* Middle region is no-op to avoid user triggering
+ wrong action */
+ op = META_GRAB_OP_NONE;
+
+ if (op != META_GRAB_OP_NONE)
+ meta_display_begin_grab_op (display,
+ window->screen,
+ window,
+ op,
+ TRUE,
+ FALSE,
+ event->button.button,
+ 0,
+ event->any.time,
+ event->button.x,
+ event->button.y);
+ }
+ }
+ else if ((int) event->button.button ==
+ meta_prefs_get_mouse_button_menu ())
+ {
+ if (meta_prefs_get_raise_on_click ())
+ meta_window_raise (window);
+ meta_window_show_menu (window,
+ event->button.x,
+ event->button.y,
+ event->button.button,
+ event->any.time);
+ }
+
+ if (!frame_was_receiver && unmodified)
+ {
+ /* This is from our synchronous grab since
+ * it has no modifiers and was on the client window
+ */
+
+ meta_verbose ("Allowing events time %u\n",
+ (unsigned int) event->any.time);
+
+ clutter_input_device_set_enabled (event->button.device, TRUE);
+ }
+
+ if (begin_move && window->has_move_func)
+ {
+ meta_display_begin_grab_op (display,
+ window->screen,
+ window,
+ META_GRAB_OP_MOVING,
+ TRUE,
+ FALSE,
+ event->button.button,
+ 0,
+ event->any.time,
+ event->button.x,
+ event->button.y);
+ }
+ }
+ break;
+ case CLUTTER_BUTTON_RELEASE:
+ if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+ break;
+
+ display->overlay_key_only_pressed = FALSE;
+
+ if (display->grab_window == window &&
+ meta_grab_op_is_mouse (display->grab_op))
+ meta_window_handle_mouse_grab_op_event (window, event);
+ break;
+ case CLUTTER_MOTION:
+ if (display->grab_op == META_GRAB_OP_COMPOSITOR)
+ break;
+
+ if (display->grab_window == window &&
+ meta_grab_op_is_mouse (display->grab_op))
+ meta_window_handle_mouse_grab_op_event (window, event);
+ break;
+
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+event_callback (const ClutterEvent *event,
+ gpointer data)
+{
+ MetaDisplay *display = data;
+
+ return meta_display_handle_event (display, event);
+}
+
/* Return the window this has to do with, if any, rather
* than the frame or root window that was selecting
* for substructure
diff --git a/src/core/window-private.h b/src/core/window-private.h
index 9504bca..fe672e5 100644
--- a/src/core/window-private.h
+++ b/src/core/window-private.h
@@ -44,6 +44,7 @@
#include <X11/Xutil.h>
#include <cairo.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <clutter/clutter.h>
#include "meta-wayland-types.h"
typedef struct _MetaWindowQueue MetaWindowQueue;
@@ -642,8 +643,8 @@ void meta_window_update_sync_request_counter (MetaWindow *window,
gint64 new_counter_value);
#endif /* HAVE_XSYNC */
-void meta_window_handle_mouse_grab_op_event (MetaWindow *window,
- XIDeviceEvent *xev);
+void meta_window_handle_mouse_grab_op_event (MetaWindow *window,
+ const ClutterEvent *event);
GList* meta_window_get_workspaces (MetaWindow *window);
diff --git a/src/core/window.c b/src/core/window.c
index 9505d28..bdc3788 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -63,6 +63,7 @@
#include <X11/extensions/Xcomposite.h>
#include "meta-wayland-private.h"
+#include "meta/compositor-mutter.h"
/* Windows that unmaximize to a size bigger than that fraction of the workarea
* will be scaled down to that size (while maintaining aspect ratio).
@@ -9892,96 +9893,20 @@ update_resize (MetaWindow *window,
g_get_current_time (&window->display->grab_last_moveresize_time);
}
-typedef struct
-{
- Window window;
- int count;
- guint32 last_time;
-} EventScannerData;
-
-static Bool
-find_last_time_predicate (Display *display,
- XEvent *ev,
- XPointer arg)
-{
- EventScannerData *esd = (void*) arg;
- XIEvent *xev;
-
- if (ev->type != GenericEvent)
- return False;
-
- /* We are peeking into events not yet handled by GDK,
- * Allocate cookie events here so we can handle XI2.
- *
- * GDK will handle later these events, and eventually
- * free the cookie data itself.
- */
- XGetEventData (display, &ev->xcookie);
- xev = (XIEvent *) ev->xcookie.data;
-
- if (xev->evtype != XI_Motion)
- return False;
-
- if (esd->window != ((XIDeviceEvent *) xev)->event)
- return False;
-
- esd->count += 1;
- esd->last_time = xev->time;
-
- return False;
-}
-
static gboolean
-check_use_this_motion_notify (MetaWindow *window,
- XIDeviceEvent *xev)
-{
- EventScannerData esd;
- XEvent useless;
-
- /* This code is copied from Owen's GDK code. */
-
- if (window->display->grab_motion_notify_time != 0)
- {
- /* == is really the right test, but I'm all for paranoia */
- if (window->display->grab_motion_notify_time <=
- xev->time)
- {
- meta_topic (META_DEBUG_RESIZING,
- "Arrived at event with time %u (waiting for %u), using it\n",
- (unsigned int)xev->time,
- window->display->grab_motion_notify_time);
- window->display->grab_motion_notify_time = 0;
- return TRUE;
- }
- else
- return FALSE; /* haven't reached the saved timestamp yet */
- }
-
- esd.window = xev->event;
- esd.count = 0;
- esd.last_time = 0;
-
- /* "useless" isn't filled in because the predicate never returns True */
- XCheckIfEvent (window->display->xdisplay,
- &useless,
- find_last_time_predicate,
- (XPointer) &esd);
-
- if (esd.count > 0)
- meta_topic (META_DEBUG_RESIZING,
- "Will skip %d motion events and use the event with time %u\n",
- esd.count, (unsigned int) esd.last_time);
-
- if (esd.last_time == 0)
- return TRUE;
- else
- {
- /* Save this timestamp, and ignore all motion notify
- * until we get to the one with this stamp.
- */
- window->display->grab_motion_notify_time = esd.last_time;
- return FALSE;
- }
+check_use_this_motion_notify (MetaWindow *window,
+ const ClutterEvent *event)
+{
+ /* XXX: Previously this code would walk through the X event queue
+ and filter out motion events that are followed by a later motion
+ event. There currently isn't any API to do the equivalent
+ procedure with the Clutter event queue so this function does
+ nothing. Clutter does its own motion event squashing so it may be
+ the case that this function isn't necessary. If it turns out that
+ we do need additional motion event squashing we could add some
+ extra API to the Clutter event queue and implement this function
+ properly. */
+ return TRUE;
}
static void
@@ -10055,15 +9980,21 @@ meta_window_update_sync_request_counter (MetaWindow *window,
#endif /* HAVE_XSYNC */
void
-meta_window_handle_mouse_grab_op_event (MetaWindow *window,
- XIDeviceEvent *xev)
+meta_window_handle_mouse_grab_op_event (MetaWindow *window,
+ const ClutterEvent *event)
{
- switch (xev->evtype)
+ gboolean is_window_root = (event->any.stage != NULL &&
+ window &&
+ window->screen &&
+ CLUTTER_ACTOR (event->any.stage) ==
+ meta_get_stage_for_screen (window->screen));
+
+ switch (event->type)
{
- case XI_ButtonRelease:
+ case CLUTTER_BUTTON_RELEASE:
meta_display_check_threshold_reached (window->display,
- xev->root_x,
- xev->root_y);
+ event->button.x,
+ event->button.y);
/* If the user was snap moving then ignore the button release
* because they may have let go of shift before releasing the
* mouse button and they almost certainly do not want a
@@ -10075,19 +10006,21 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window,
{
if (window->tile_mode != META_TILE_NONE)
meta_window_tile (window);
- else if (xev->root == window->screen->xroot)
+ else if (is_window_root)
update_move (window,
- xev->mods.effective & ShiftMask,
- xev->root_x,
- xev->root_y);
+ clutter_event_get_state (event) &
+ CLUTTER_SHIFT_MASK,
+ event->button.x,
+ event->button.y);
}
else if (meta_grab_op_is_resizing (window->display->grab_op))
{
- if (xev->root == window->screen->xroot)
+ if (is_window_root)
update_resize (window,
- xev->mods.effective & ShiftMask,
- xev->root_x,
- xev->root_y,
+ clutter_event_get_state (event) &
+ CLUTTER_SHIFT_MASK,
+ event->button.x,
+ event->button.y,
TRUE);
/* If a tiled window has been dragged free with a
@@ -10101,35 +10034,35 @@ meta_window_handle_mouse_grab_op_event (MetaWindow *window,
}
}
- meta_display_end_grab_op (window->display, xev->time);
+ meta_display_end_grab_op (window->display, event->any.time);
break;
- case XI_Motion:
+ case CLUTTER_MOTION:
meta_display_check_threshold_reached (window->display,
- xev->root_x,
- xev->root_y);
+ event->motion.x,
+ event->motion.y);
if (meta_grab_op_is_moving (window->display->grab_op))
{
- if (xev->root == window->screen->xroot)
+ if (is_window_root)
{
- if (check_use_this_motion_notify (window,
- xev))
+ if (check_use_this_motion_notify (window, event))
update_move (window,
- xev->mods.effective & ShiftMask,
- xev->root_x,
- xev->root_y);
+ clutter_event_get_state (event) &
+ CLUTTER_SHIFT_MASK,
+ event->motion.x,
+ event->motion.y);
}
}
else if (meta_grab_op_is_resizing (window->display->grab_op))
{
- if (xev->root == window->screen->xroot)
+ if (is_window_root)
{
- if (check_use_this_motion_notify (window,
- xev))
+ if (check_use_this_motion_notify (window, event))
update_resize (window,
- xev->mods.effective & ShiftMask,
- xev->root_x,
- xev->root_y,
+ clutter_event_get_state (event) &
+ CLUTTER_SHIFT_MASK,
+ event->motion.x,
+ event->motion.y,
FALSE);
}
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
