static gboolean
meta_display_handle_event (MetaDisplay *display,
const ClutterEvent *event)
{
MetaWindow *window;
gboolean bypass_clutter = FALSE;
G_GNUC_UNUSED gboolean bypass_wayland = FALSE;
MetaGestureTracker *tracker;
ClutterEventSequence *sequence;
ClutterInputDevice *source;
sequence = clutter_event_get_event_sequence (event);
/* Set the pointer emulating sequence on touch begin, if eligible */
if (event->type == CLUTTER_TOUCH_BEGIN)
{
if (sequence_is_pointer_emulated (display, event))
{
/* This is the new pointer emulating sequence */
display->pointer_emulating_sequence = sequence;
}
else if (display->pointer_emulating_sequence == sequence)
{
/* This sequence was "pointer emulating" in a prior incarnation,
* but now it isn't. We unset the pointer emulating sequence at
* this point so the current sequence is not mistaken as pointer
* emulating, while we've ensured that it's been deemed
* "pointer emulating" throughout all of the event processing
* of the previous incarnation.
*/
display->pointer_emulating_sequence = NULL;
}
}
#ifdef HAVE_WAYLAND
MetaWaylandCompositor *compositor = NULL;
if (meta_is_wayland_compositor ())
{
compositor = meta_wayland_compositor_get_default ();
meta_wayland_compositor_update (compositor, event);
}
#endif
if (!display->current_pad_osd &&
(event->type == CLUTTER_PAD_BUTTON_PRESS ||
event->type == CLUTTER_PAD_BUTTON_RELEASE))
{
MetaBackend *backend = meta_get_backend ();
if (meta_input_settings_handle_pad_button (meta_backend_get_input_settings (backend),
clutter_event_get_source_device (event),
event->type == CLUTTER_PAD_BUTTON_PRESS,
event->pad_button.button))
{
bypass_wayland = bypass_clutter = TRUE;
goto out;
}
}
source = clutter_event_get_source_device (event);
if (source)
{
meta_backend_update_last_device (meta_get_backend (),
clutter_input_device_get_device_id (source));
}
#ifdef HAVE_WAYLAND
if (meta_is_wayland_compositor () && event->type == CLUTTER_MOTION)
{
MetaWaylandCompositor *compositor;
compositor = meta_wayland_compositor_get_default ();
if (meta_wayland_tablet_manager_consumes_event (compositor->tablet_manager, event))
{
meta_wayland_tablet_manager_update_cursor_position (compositor->tablet_manager, event);
}
else
{
MetaCursorTracker *tracker = meta_cursor_tracker_get_for_screen (NULL);
meta_cursor_tracker_update_position (tracker, event->motion.x, event->motion.y);
}
display->monitor_cache_invalidated = TRUE;
}
#endif
handle_idletime_for_event (event);
window = get_window_for_event (display, event);
display->current_time = event->any.time;
if (window && !window->override_redirect &&
(event->type == CLUTTER_KEY_PRESS ||
event->type == CLUTTER_BUTTON_PRESS ||
event->type == CLUTTER_TOUCH_BEGIN))
{
if (CurrentTime == display->current_time)
{
/* We can't use missing (i.e. invalid) timestamps to set user time,
* nor do we want to use them to sanity check other timestamps.
* See bug 313490 for more details.
*/
meta_warning ("Event has no timestamp! You may be using a broken "
"program such as xse. Please ask the authors of that "
"program to fix it.\n");
}
else
{
meta_window_set_user_time (window, display->current_time);
meta_display_sanity_check_timestamps (display, display->current_time);
}
}
tracker = meta_display_get_gesture_tracker (display);
if (meta_gesture_tracker_handle_event (tracker, event))
{
bypass_wayland = bypass_clutter = TRUE;
goto out;
}
if (display->event_route == META_EVENT_ROUTE_WINDOW_OP)
{
if (meta_window_handle_mouse_grab_op_event (window, event))
{
bypass_clutter = TRUE;
bypass_wayland = TRUE;
goto out;
}
}
/* For key events, it's important to enforce single-handling, or
* we can get into a confused state. So if a keybinding is
* handled (because it's one of our hot-keys, or because we are
* in a keyboard-grabbed mode like moving a window, we don't
* want to pass the key event to the compositor or Wayland at all.
*/
if (meta_keybindings_process_event (display, window, event))
{
bypass_clutter = TRUE;
bypass_wayland = TRUE;
goto out;
}
/* Do not pass keyboard events to Wayland if key focus is not on the
* stage in normal mode (e.g. during keynav in the panel)
*/
if (display->event_route == META_EVENT_ROUTE_NORMAL)
{
if (IS_KEY_EVENT (event) && !stage_has_key_focus ())
{
bypass_wayland = TRUE;
goto out;
}
}
if (display->current_pad_osd)
{
bypass_wayland = TRUE;
goto out;
}
if (window)
{
/* Events that are likely to trigger compositor gestures should
* be known to clutter so they can propagate along the hierarchy.
* Gesture-wise, there's two groups of events we should be getting
* here:
* - CLUTTER_TOUCH_* with a touch sequence that's not yet accepted
* by the gesture tracker, these might trigger gesture actions
* into recognition. Already accepted touch sequences are handled
* directly by meta_gesture_tracker_handle_event().
* - CLUTTER_TOUCHPAD_* events over windows. These can likewise
* trigger ::captured-event handlers along the way.
*/
bypass_clutter = !IS_GESTURE_EVENT (event);
meta_window_handle_ungrabbed_event (window, event);
/* This might start a grab op. If it does, then filter out the
* event, and if it doesn't, replay the event to release our
* own sync grab. */
if (display->event_route == META_EVENT_ROUTE_WINDOW_OP ||
display->event_route == META_EVENT_ROUTE_FRAME_BUTTON)
{
bypass_clutter = TRUE;
bypass_wayland = TRUE;
}
else
{
/* Only replay button press events, since that's where we
* have the synchronous grab. */
if (event->type == CLUTTER_BUTTON_PRESS)
{
MetaBackend *backend = meta_get_backend ();
if (META_IS_BACKEND_X11 (backend))
{
Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));
meta_verbose ("Allowing events time %u\n",
(unsigned int)event->button.time);
XIAllowEvents (xdisplay, clutter_event_get_device_id (event),
XIReplayDevice, event->button.time);
}
}
}
goto out;
}
out:
/* If the compositor has a grab, don't pass that through to Wayland */
if (display->event_route == META_EVENT_ROUTE_COMPOSITOR_GRAB)
bypass_wayland = TRUE;
/* If a Wayland client has a grab, don't pass that through to Clutter */
if (display->event_route == META_EVENT_ROUTE_WAYLAND_POPUP)
bypass_clutter = TRUE;
#ifdef HAVE_WAYLAND
if (compositor && !bypass_wayland)
{
if (meta_wayland_compositor_handle_event (compositor, event))
bypass_clutter = TRUE;
}
#endif
display->current_time = CurrentTime;
return bypass_clutter;
}
static gboolean
meta_display_handle_event (MetaDisplay *display,
const ClutterEvent *event)
{
MetaWindow *window;
gboolean bypass_clutter = FALSE;
G_GNUC_UNUSED gboolean bypass_wayland = FALSE;
MetaGestureTracker *tracker;
ClutterEventSequence *sequence;
sequence = clutter_event_get_event_sequence (event);
/* Set the pointer emulating sequence on touch begin, if eligible */
if (event->type == CLUTTER_TOUCH_BEGIN &&
!display->pointer_emulating_sequence &&
sequence_is_pointer_emulated (display, event))
display->pointer_emulating_sequence = sequence;
#ifdef HAVE_WAYLAND
MetaWaylandCompositor *compositor = NULL;
if (meta_is_wayland_compositor ())
{
compositor = meta_wayland_compositor_get_default ();
meta_wayland_compositor_update (compositor, event);
}
#endif
if (meta_is_wayland_compositor () && event->type == CLUTTER_MOTION)
{
MetaCursorTracker *tracker = meta_cursor_tracker_get_for_screen (NULL);
meta_cursor_tracker_update_position (tracker, event->motion.x, event->motion.y);
}
handle_idletime_for_event (event);
window = get_window_for_event (display, event);
display->current_time = event->any.time;
if (window && !window->override_redirect &&
(event->type == CLUTTER_KEY_PRESS ||
event->type == CLUTTER_BUTTON_PRESS ||
event->type == CLUTTER_TOUCH_BEGIN))
{
if (CurrentTime == display->current_time)
{
/* We can't use missing (i.e. invalid) timestamps to set user time,
* nor do we want to use them to sanity check other timestamps.
* See bug 313490 for more details.
*/
meta_warning ("Event has no timestamp! You may be using a broken "
"program such as xse. Please ask the authors of that "
"program to fix it.\n");
}
else
{
meta_window_set_user_time (window, display->current_time);
meta_display_sanity_check_timestamps (display, display->current_time);
}
}
tracker = meta_display_get_gesture_tracker (display);
if (meta_gesture_tracker_handle_event (tracker, event))
{
bypass_wayland = bypass_clutter = TRUE;
goto out;
}
if (display->event_route == META_EVENT_ROUTE_WINDOW_OP)
{
if (meta_window_handle_mouse_grab_op_event (window, event))
{
bypass_clutter = TRUE;
bypass_wayland = TRUE;
goto out;
}
}
/* For key events, it's important to enforce single-handling, or
* we can get into a confused state. So if a keybinding is
* handled (because it's one of our hot-keys, or because we are
* in a keyboard-grabbed mode like moving a window, we don't
* want to pass the key event to the compositor or Wayland at all.
*/
if (meta_keybindings_process_event (display, window, event))
{
bypass_clutter = TRUE;
bypass_wayland = TRUE;
goto out;
}
if (window)
{
if (!clutter_event_get_event_sequence (event))
{
/* Swallow all non-touch events on windows that come our way.
* Touch events that reach here aren't yet in an accepted state,
* so Clutter must see them to maybe trigger gestures into
* recognition.
*/
bypass_clutter = TRUE;
}
meta_window_handle_ungrabbed_event (window, event);
/* This might start a grab op. If it does, then filter out the
* event, and if it doesn't, replay the event to release our
* own sync grab. */
if (display->event_route == META_EVENT_ROUTE_WINDOW_OP)
{
bypass_clutter = TRUE;
bypass_wayland = TRUE;
}
else
{
/* Only replay button press events, since that's where we
* have the synchronous grab. */
if (event->type == CLUTTER_BUTTON_PRESS)
{
MetaBackend *backend = meta_get_backend ();
if (META_IS_BACKEND_X11 (backend))
{
Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));
meta_verbose ("Allowing events time %u\n",
(unsigned int)event->button.time);
XIAllowEvents (xdisplay, clutter_event_get_device_id (event),
XIReplayDevice, event->button.time);
}
}
}
goto out;
}
out:
/* If the compositor has a grab, don't pass that through to Wayland */
if (display->event_route == META_EVENT_ROUTE_COMPOSITOR_GRAB)
bypass_wayland = TRUE;
/* If a Wayland client has a grab, don't pass that through to Clutter */
if (display->event_route == META_EVENT_ROUTE_WAYLAND_POPUP)
bypass_clutter = TRUE;
#ifdef HAVE_WAYLAND
if (compositor && !bypass_wayland)
{
if (meta_wayland_compositor_handle_event (compositor, event))
bypass_clutter = TRUE;
}
#endif
/* Unset the pointer emulating sequence after its end event is processed */
if (event->type == CLUTTER_TOUCH_END &&
display->pointer_emulating_sequence == sequence)
display->pointer_emulating_sequence = NULL;
display->current_time = CurrentTime;
return bypass_clutter;
}
