isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-27 18:40:40 -05:00
Code Issues Packages Projects Releases Wiki Activity
0b055fae2e
mutter/src/wayland/meta-wayland-seat.c

446 lines
12 KiB
C
Raw Normal View History

wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
/*
* Wayland Support
*
* Copyright (C) 2013 Intel Corporation
*
* 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 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include "config.h"
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 18:03:23 -05:00
#include <cogl/cogl-wayland-server.h>
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
#include <clutter/clutter.h>
#include <clutter/wayland/clutter-wayland-compositor.h>
#include <clutter/wayland/clutter-wayland-surface.h>
#include <linux/input.h>
#include <stdlib.h>
#include <string.h>
#include "meta-wayland-seat.h"
#include "meta-wayland-private.h"
#include "meta-wayland-keyboard.h"
#include "meta-wayland-pointer.h"
#include "meta-wayland-data-device.h"
#include "meta-window-actor-private.h"
#include "meta/meta-shaped-texture.h"
MetaShapedTexture: don't include private headers in public ones Private headers are not installed, so they can't be referenced from public ones. https://bugzilla.gnome.org/show_bug.cgi?id=705497
2013-08-16 08:23:40 -04:00
#include "meta-shaped-texture-private.h"
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 18:03:23 -05:00
#include "meta-wayland-stage.h"
Add MetaCursorTracker, a new helper for tracking the cursor sprite Under X, we need to use XFixes to watch the cursor changing, while on wayland, we're in charge of setting and painting the cursor. MetaCursorTracker provides the abstraction layer for gnome-shell, which can thus drop ShellXFixesCursor. In the future, it may grow the ability to watch for pointer position too, especially if CursorEvents are added to the next version of XInput2, and thus it would also replace the PointerWatcher we use for gnome-shell's magnifier. https://bugzilla.gnome.org/show_bug.cgi?id=705911
2013-08-13 06:57:41 -04:00
#include "meta-cursor-tracker-private.h"
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
#define DEFAULT_AXIS_STEP_DISTANCE wl_fixed_from_int (10)
static void
unbind_resource (struct wl_resource *resource)
{
wl_list_remove (wl_resource_get_link (resource));
}
static void
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
set_cursor_surface (MetaWaylandSeat *seat,
MetaWaylandSurface *surface)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
if (seat->cursor_surface == surface)
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
return;
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
if (seat->cursor_surface)
wl_list_remove (&seat->cursor_surface_destroy_listener.link);
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
seat->cursor_surface = surface;
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
if (seat->cursor_surface)
wl_resource_add_destroy_listener (seat->cursor_surface->resource,
&seat->cursor_surface_destroy_listener);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 18:03:23 -05:00
void
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
meta_wayland_seat_update_cursor_surface (MetaWaylandSeat *seat)
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 18:03:23 -05:00
{
Add MetaCursorTracker, a new helper for tracking the cursor sprite Under X, we need to use XFixes to watch the cursor changing, while on wayland, we're in charge of setting and painting the cursor. MetaCursorTracker provides the abstraction layer for gnome-shell, which can thus drop ShellXFixesCursor. In the future, it may grow the ability to watch for pointer position too, especially if CursorEvents are added to the next version of XInput2, and thus it would also replace the PointerWatcher we use for gnome-shell's magnifier. https://bugzilla.gnome.org/show_bug.cgi?id=705911
2013-08-13 06:57:41 -04:00
struct wl_resource *buffer;
if (seat->cursor_tracker == NULL)
return;
wayland: Simply store a MetaWaylandBuffer There's no need for the MetaWaylandBufferReference abstraction...
2014-02-01 17:45:51 -05:00
if (seat->cursor_surface && seat->cursor_surface->buffer)
buffer = seat->cursor_surface->buffer->resource;
wayland-surface: Properly allow setting the cursor to a NULL buffer
2013-11-25 16:03:25 -05:00
else
buffer = NULL;
cursor-tracker: Use a sync methodology for the cursor image Rather than have MetaWaylandSeat do all the state management itself, put the split between the root cursor and the window cursor in the cursor tracker itself. We'll expand this to add a "grab" cursor in the next commit, allowing us to force a cursor on grab operations.
2013-11-18 19:19:42 -05:00
meta_cursor_tracker_set_window_cursor (seat->cursor_tracker,
buffer,
seat->hotspot_x,
seat->hotspot_y);
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 18:03:23 -05:00
}
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
static void
pointer_set_cursor (struct wl_client *client,
struct wl_resource *resource,
uint32_t serial,
struct wl_resource *surface_resource,
int32_t x, int32_t y)
{
MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
MetaWaylandSurface *surface;
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
surface = (surface_resource ? wl_resource_get_user_data (surface_resource) : NULL);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
pointer/keyboard: Make sure not to get stale on client resources as well Both the pointer/keyboard resource and surface resource can be destroyed at any point in the destruction process, so we need to have destroy listeners on both. To make the code easier to follow, rename ->focus to ->focus_surface at the same time, and rearrange the code so that the two of them are always grouped together.
2014-02-18 18:00:26 -05:00
if (seat->pointer.focus_surface == NULL)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
return;
pointer/keyboard: Make sure not to get stale on client resources as well Both the pointer/keyboard resource and surface resource can be destroyed at any point in the destruction process, so we need to have destroy listeners on both. To make the code easier to follow, rename ->focus to ->focus_surface at the same time, and rearrange the code so that the two of them are always grouped together.
2014-02-18 18:00:26 -05:00
if (wl_resource_get_client (seat->pointer.focus_surface->resource) != client)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
return;
if (seat->pointer.focus_serial - serial > G_MAXUINT32 / 2)
return;
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 18:03:23 -05:00
seat->hotspot_x = x;
seat->hotspot_y = y;
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
set_cursor_surface (seat, surface);
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
meta_wayland_seat_update_cursor_surface (seat);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
static const struct wl_pointer_interface pointer_interface = {
pointer_set_cursor
};
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
static void
seat_get_pointer (struct wl_client *client,
struct wl_resource *resource,
uint32_t id)
{
MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
struct wl_resource *cr;
wayland: fix deprecation warnings Replace the deprecated APIs with the modern variants (which also give us full control on the versioning). Also, note that we only support version 2 of wl_seat. Version 3 is for multiple pointer/keyboards for a client, but we don't implement that yet. If a client requests version 3 of wl_seat or make a version 3 request, it will get a protocol error. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:03:37 -04:00
cr = wl_resource_create (client, &wl_pointer_interface,
wayland: use symbolic constants for interface version Replace magic numbers scattered around the code with proper macros collected in one header file. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:45:27 -04:00
MIN (META_WL_POINTER_VERSION, wl_resource_get_version (resource)), id);
wayland: fix deprecation warnings Replace the deprecated APIs with the modern variants (which also give us full control on the versioning). Also, note that we only support version 2 of wl_seat. Version 3 is for multiple pointer/keyboards for a client, but we don't implement that yet. If a client requests version 3 of wl_seat or make a version 3 request, it will get a protocol error. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:03:37 -04:00
wl_resource_set_implementation (cr, &pointer_interface, seat, unbind_resource);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wl_list_insert (&seat->pointer.resource_list, wl_resource_get_link (cr));
pointer/keyboard: Make sure not to get stale on client resources as well Both the pointer/keyboard resource and surface resource can be destroyed at any point in the destruction process, so we need to have destroy listeners on both. To make the code easier to follow, rename ->focus to ->focus_surface at the same time, and rearrange the code so that the two of them are always grouped together.
2014-02-18 18:00:26 -05:00
if (seat->pointer.focus_surface &&
wl_resource_get_client (seat->pointer.focus_surface->resource) == client)
meta_wayland_pointer_set_focus (&seat->pointer, seat->pointer.focus_surface);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
static void
seat_get_keyboard (struct wl_client *client,
struct wl_resource *resource,
uint32_t id)
{
MetaWaylandSeat *seat = wl_resource_get_user_data (resource);
struct wl_resource *cr;
wayland: fix deprecation warnings Replace the deprecated APIs with the modern variants (which also give us full control on the versioning). Also, note that we only support version 2 of wl_seat. Version 3 is for multiple pointer/keyboards for a client, but we don't implement that yet. If a client requests version 3 of wl_seat or make a version 3 request, it will get a protocol error. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:03:37 -04:00
cr = wl_resource_create (client, &wl_keyboard_interface,
wayland: use symbolic constants for interface version Replace magic numbers scattered around the code with proper macros collected in one header file. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:45:27 -04:00
MIN (META_WL_KEYBOARD_VERSION, wl_resource_get_version (resource)), id);
wayland: fix deprecation warnings Replace the deprecated APIs with the modern variants (which also give us full control on the versioning). Also, note that we only support version 2 of wl_seat. Version 3 is for multiple pointer/keyboards for a client, but we don't implement that yet. If a client requests version 3 of wl_seat or make a version 3 request, it will get a protocol error. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:03:37 -04:00
wl_resource_set_implementation (cr, NULL, seat, unbind_resource);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wl_list_insert (&seat->keyboard.resource_list, wl_resource_get_link (cr));
wl_keyboard_send_keymap (cr,
WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
seat->keyboard.xkb_info.keymap_fd,
seat->keyboard.xkb_info.keymap_size);
pointer/keyboard: Make sure not to get stale on client resources as well Both the pointer/keyboard resource and surface resource can be destroyed at any point in the destruction process, so we need to have destroy listeners on both. To make the code easier to follow, rename ->focus to ->focus_surface at the same time, and rearrange the code so that the two of them are always grouped together.
2014-02-18 18:00:26 -05:00
if (seat->keyboard.focus_surface &&
wl_resource_get_client (seat->keyboard.focus_surface->resource) == client)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
pointer/keyboard: Make sure not to get stale on client resources as well Both the pointer/keyboard resource and surface resource can be destroyed at any point in the destruction process, so we need to have destroy listeners on both. To make the code easier to follow, rename ->focus to ->focus_surface at the same time, and rearrange the code so that the two of them are always grouped together.
2014-02-18 18:00:26 -05:00
meta_wayland_keyboard_set_focus (&seat->keyboard, seat->keyboard.focus_surface);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
meta_wayland_data_device_set_keyboard_focus (seat);
}
}
static void
seat_get_touch (struct wl_client *client,
struct wl_resource *resource,
uint32_t id)
{
/* Touch not supported */
}
static const struct wl_seat_interface
seat_interface =
{
seat_get_pointer,
seat_get_keyboard,
seat_get_touch
};
static void
bind_seat (struct wl_client *client,
void *data,
guint32 version,
guint32 id)
{
MetaWaylandSeat *seat = data;
struct wl_resource *resource;
wayland: use symbolic constants for interface version Replace magic numbers scattered around the code with proper macros collected in one header file. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:45:27 -04:00
resource = wl_resource_create (client, &wl_seat_interface,
MIN (META_WL_SEAT_VERSION, version), id);
wayland: fix deprecation warnings Replace the deprecated APIs with the modern variants (which also give us full control on the versioning). Also, note that we only support version 2 of wl_seat. Version 3 is for multiple pointer/keyboards for a client, but we don't implement that yet. If a client requests version 3 of wl_seat or make a version 3 request, it will get a protocol error. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:03:37 -04:00
wl_resource_set_implementation (resource, &seat_interface, seat, unbind_resource);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wl_list_insert (&seat->base_resource_list, wl_resource_get_link (resource));
wl_seat_send_capabilities (resource,
WL_SEAT_CAPABILITY_POINTER |
WL_SEAT_CAPABILITY_KEYBOARD);
wayland: fix deprecation warnings Replace the deprecated APIs with the modern variants (which also give us full control on the versioning). Also, note that we only support version 2 of wl_seat. Version 3 is for multiple pointer/keyboards for a client, but we don't implement that yet. If a client requests version 3 of wl_seat or make a version 3 request, it will get a protocol error. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:03:37 -04:00
wayland: use symbolic constants for interface version Replace magic numbers scattered around the code with proper macros collected in one header file. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:45:27 -04:00
if (version >= META_WL_SEAT_HAS_NAME)
wayland: fix deprecation warnings Replace the deprecated APIs with the modern variants (which also give us full control on the versioning). Also, note that we only support version 2 of wl_seat. Version 3 is for multiple pointer/keyboards for a client, but we don't implement that yet. If a client requests version 3 of wl_seat or make a version 3 request, it will get a protocol error. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:03:37 -04:00
wl_seat_send_name (resource, "seat0");
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
static void
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
pointer_handle_cursor_surface_destroy (struct wl_listener *listener, void *data)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
MetaWaylandSeat *seat = wl_container_of (listener, seat, cursor_surface_destroy_listener);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
set_cursor_surface (seat, NULL);
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
meta_wayland_seat_update_cursor_surface (seat);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
MetaWaylandSeat *
wayland: Remove is_native from seat We can easily do this with a Clutter backend check instead...
2014-02-17 20:49:04 -05:00
meta_wayland_seat_new (struct wl_display *display)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
MetaWaylandSeat *seat = g_new0 (MetaWaylandSeat, 1);
seat->selection_data_source = NULL;
wl_list_init (&seat->base_resource_list);
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
wl_list_init (&seat->data_device_resource_list);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wayland: Remove is_native from seat We can easily do this with a Clutter backend check instead...
2014-02-17 20:49:04 -05:00
meta_wayland_pointer_init (&seat->pointer);
meta_wayland_keyboard_init (&seat->keyboard, display);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
seat->display = display;
seat->current_stage = 0;
wayland-seat: Rename sprite to cursor_surface
2014-02-01 17:55:03 -05:00
seat->cursor_surface = NULL;
seat->cursor_surface_destroy_listener.notify = pointer_handle_cursor_surface_destroy;
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
seat->hotspot_x = 16;
seat->hotspot_y = 16;
wayland: use symbolic constants for interface version Replace magic numbers scattered around the code with proper macros collected in one header file. https://bugzilla.gnome.org/show_bug.cgi?id=707851
2013-09-10 07:45:27 -04:00
wl_global_create (display, &wl_seat_interface, META_WL_SEAT_VERSION, seat, bind_seat);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
return seat;
}
static void
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
notify_motion (MetaWaylandSeat *seat,
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
const ClutterEvent *event)
{
MetaWaylandPointer *pointer = &seat->pointer;
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
meta_wayland_seat_repick (seat, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
pointer->grab->interface->motion (pointer->grab, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
static void
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
handle_motion_event (MetaWaylandSeat *seat,
const ClutterEvent *event)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
notify_motion (seat, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
static void
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
handle_button_event (MetaWaylandSeat *seat,
const ClutterEvent *event)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
MetaWaylandPointer *pointer = &seat->pointer;
wayland-seat: Fix updating the grab serial We shouldn't update the grab serial if we go from 2 buttons => 1.
2013-11-12 15:42:31 -05:00
gboolean implicit_grab;
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
notify_motion (seat, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wayland-seat: Fix updating the grab serial We shouldn't update the grab serial if we go from 2 buttons => 1.
2013-11-12 15:42:31 -05:00
implicit_grab = (event->type == CLUTTER_BUTTON_PRESS) && (pointer->button_count == 1);
if (implicit_grab)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
wayland: Drop raise on click too We'll handle this through GCD as well.
2013-10-16 00:06:45 -04:00
pointer->grab_button = clutter_event_get_button (event);
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
pointer->grab_time = clutter_event_get_time (event);
MetaWaylandSeat: don't use use events to count pressed buttons Use the modifier mask instead, as events can get lost if there is a clutter grab or if some other actor is capturing events. https://bugzilla.gnome.org/show_bug.cgi?id=706124
2013-08-16 06:13:26 -04:00
pointer->grab_x = pointer->x;
pointer->grab_y = pointer->y;
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
pointer->grab->interface->button (pointer->grab, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wayland-seat: Fix updating the grab serial We shouldn't update the grab serial if we go from 2 buttons => 1.
2013-11-12 15:42:31 -05:00
if (implicit_grab)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
pointer->grab_serial = wl_display_get_serial (seat->display);
}
static void
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
handle_scroll_event (MetaWaylandSeat *seat,
const ClutterEvent *event)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
enum wl_pointer_axis axis;
wl_fixed_t value;
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
notify_motion (seat, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
switch (clutter_event_get_scroll_direction (event))
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
case CLUTTER_SCROLL_UP:
axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
value = -DEFAULT_AXIS_STEP_DISTANCE;
break;
case CLUTTER_SCROLL_DOWN:
axis = WL_POINTER_AXIS_VERTICAL_SCROLL;
value = DEFAULT_AXIS_STEP_DISTANCE;
break;
case CLUTTER_SCROLL_LEFT:
axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
value = -DEFAULT_AXIS_STEP_DISTANCE;
break;
case CLUTTER_SCROLL_RIGHT:
axis = WL_POINTER_AXIS_HORIZONTAL_SCROLL;
value = DEFAULT_AXIS_STEP_DISTANCE;
break;
default:
return;
}
if (seat->pointer.focus_resource)
wl_pointer_send_axis (seat->pointer.focus_resource,
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
clutter_event_get_time (event),
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
axis,
value);
}
MetaWaylandSeat: don't use use events to count pressed buttons Use the modifier mask instead, as events can get lost if there is a clutter grab or if some other actor is capturing events. https://bugzilla.gnome.org/show_bug.cgi?id=706124
2013-08-16 06:13:26 -04:00
static int
count_buttons (const ClutterEvent *event)
{
static gint maskmap[5] =
{
CLUTTER_BUTTON1_MASK, CLUTTER_BUTTON2_MASK, CLUTTER_BUTTON3_MASK,
CLUTTER_BUTTON4_MASK, CLUTTER_BUTTON5_MASK
};
ClutterModifierType mod_mask;
int i, count;
mod_mask = clutter_event_get_state (event);
count = 0;
for (i = 0; i < 5; i++)
{
if (mod_mask & maskmap[i])
count++;
}
return count;
}
wayland: Update internal wayland state unconditionally Things like idle times and the cursor position need to be updated even if there's a mutter grab in effect. https://bugzilla.gnome.org/show_bug.cgi?id=712247
2013-11-13 15:41:29 -05:00
void
meta_wayland_seat_update_pointer (MetaWaylandSeat *seat,
const ClutterEvent *event)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
wayland: Update internal wayland state unconditionally Things like idle times and the cursor position need to be updated even if there's a mutter grab in effect. https://bugzilla.gnome.org/show_bug.cgi?id=712247
2013-11-13 15:41:29 -05:00
float x, y;
clutter_event_get_coords (event, &x, &y);
seat->pointer.x = wl_fixed_from_double (x);
seat->pointer.y = wl_fixed_from_double (y);
MetaWaylandSeat: don't use use events to count pressed buttons Use the modifier mask instead, as events can get lost if there is a clutter grab or if some other actor is capturing events. https://bugzilla.gnome.org/show_bug.cgi?id=706124
2013-08-16 06:13:26 -04:00
seat->pointer.button_count = count_buttons (event);
wayland: Move cursor tracker handling code to meta_wayland_seat_handle_event
2013-10-04 02:33:10 -04:00
if (seat->cursor_tracker)
{
meta_cursor_tracker_update_position (seat->cursor_tracker,
wl_fixed_to_int (seat->pointer.x),
wl_fixed_to_int (seat->pointer.y));
if (seat->pointer.current == NULL)
cursor-tracker: Use a sync methodology for the cursor image Rather than have MetaWaylandSeat do all the state management itself, put the split between the root cursor and the window cursor in the cursor tracker itself. We'll expand this to add a "grab" cursor in the next commit, allowing us to force a cursor on grab operations.
2013-11-18 19:19:42 -05:00
meta_cursor_tracker_unset_window_cursor (seat->cursor_tracker);
wayland: Move cursor tracker handling code to meta_wayland_seat_handle_event
2013-10-04 02:33:10 -04:00
}
wayland: Update internal wayland state unconditionally Things like idle times and the cursor position need to be updated even if there's a mutter grab in effect. https://bugzilla.gnome.org/show_bug.cgi?id=712247
2013-11-13 15:41:29 -05:00
}
wayland: Move cursor tracker handling code to meta_wayland_seat_handle_event
2013-10-04 02:33:10 -04:00
wayland: Update internal wayland state unconditionally Things like idle times and the cursor position need to be updated even if there's a mutter grab in effect. https://bugzilla.gnome.org/show_bug.cgi?id=712247
2013-11-13 15:41:29 -05:00
gboolean
meta_wayland_seat_handle_event (MetaWaylandSeat *seat,
const ClutterEvent *event)
{
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
switch (event->type)
{
case CLUTTER_MOTION:
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
handle_motion_event (seat, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
break;
case CLUTTER_BUTTON_PRESS:
case CLUTTER_BUTTON_RELEASE:
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
handle_button_event (seat, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
break;
case CLUTTER_KEY_PRESS:
case CLUTTER_KEY_RELEASE:
wayland: reimplement keyboard state handling properly We can't rely on clutter's xkb_state, because that's updated when events are pulled from the kernel, not when we see them. Instead, use the new clutter API to get the full modifier state from the event (which, as a side effect, also works when clutter is using the X11 backend for running nested). https://bugzilla.gnome.org/show_bug.cgi?id=706963
2013-09-04 09:01:11 -04:00
return meta_wayland_keyboard_handle_event (&seat->keyboard,
(const ClutterKeyEvent *) event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
case CLUTTER_SCROLL:
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
handle_scroll_event (seat, event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
break;
default:
break;
}
wayland: reimplement keyboard state handling properly We can't rely on clutter's xkb_state, because that's updated when events are pulled from the kernel, not when we see them. Instead, use the new clutter API to get the full modifier state from the event (which, as a side effect, also works when clutter is using the X11 backend for running nested). https://bugzilla.gnome.org/show_bug.cgi?id=706963
2013-09-04 09:01:11 -04:00
return FALSE;
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
/* The actor argument can be NULL in which case a Clutter pick will be
performed to determine the right actor. An actor should only be
passed if the repick is being performed due to an event in which
case Clutter will have already performed a pick so we can avoid
redundantly doing another one */
void
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
meta_wayland_seat_repick (MetaWaylandSeat *seat,
const ClutterEvent *for_event)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
ClutterActor *actor = NULL;
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
MetaWaylandPointer *pointer = &seat->pointer;
MetaWaylandSurface *surface = NULL;
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
if (for_event)
{
actor = clutter_event_get_source (for_event);
}
else if (seat->current_stage)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
ClutterStage *stage = CLUTTER_STAGE (seat->current_stage);
actor = clutter_stage_get_actor_at_pos (stage,
CLUTTER_PICK_REACTIVE,
wl_fixed_to_double (pointer->x),
wl_fixed_to_double (pointer->y));
}
if (actor)
seat->current_stage = clutter_actor_get_stage (actor);
else
seat->current_stage = NULL;
Fix the input region not working properly The input region was set on the shaped texture, but the shaped texture was never picked properly, as it was never set to be reactive. Move the pick implementation and reactivity to the MetaSurfaceActor, and update the code everywhere else to expect a MetaSurfaceActor.
2014-02-18 21:27:20 -05:00
if (META_IS_SURFACE_ACTOR (actor))
surface = meta_surface_actor_get_surface (META_SURFACE_ACTOR (actor));
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
MetaWaylandSeat: correct logic to set the current / focused surface The current surface refers to the surface right below the pointer (according to the pick performed by clutter), while the focus surface is the one receiving events. They can be out of sync in case of grabs, in which case we should keep trying to focus the current surface. https://bugzilla.gnome.org/show_bug.cgi?id=706077
2013-08-14 10:29:09 -04:00
pointer->current = surface;
pointer/keyboard: Make sure not to get stale on client resources as well Both the pointer/keyboard resource and surface resource can be destroyed at any point in the destruction process, so we need to have destroy listeners on both. To make the code easier to follow, rename ->focus to ->focus_surface at the same time, and rearrange the code so that the two of them are always grouped together.
2014-02-18 18:00:26 -05:00
if (surface != pointer->focus_surface)
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
{
const MetaWaylandPointerGrabInterface *interface =
pointer->grab->interface;
interface->focus (pointer->grab,
wayland: heavily refactor pointer grabs Grabs are now slice allocated structures that are handled by whoever starts the grab. They contain a generic grab structure with the interface and a backpointer to the MetaWaylandPointer. The grab interface has been changed to pass full clutter events, which allowed to remove the confusion between grab->focus and pointer->focus. Invidual grabs are now required to keep their focus, and choose whoever gets the events. https://bugzilla.gnome.org/show_bug.cgi?id=707863
2013-09-11 08:06:05 -04:00
surface, for_event);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
}
}
void
meta_wayland_seat_free (MetaWaylandSeat *seat)
{
wayland-seat: Fix pointer issues Moving the mouse over weston-terminal, we can see several issues: * it often updates late, or not at all * the attachment of the pointer sprite is wrong These are because we willy-nilly call seat_update_sprite all over the place, and often in wrong areas. Set up a set_pointer_surface helper method that will do the right thing for us in all cases, and call it on transitions.
2014-02-01 17:18:21 -05:00
set_cursor_surface (seat, NULL);
wayland: Add basic input support This copies the basic input support from the Clayland demo compositor. It adds a basic wl_seat implementation which can convert Clutter mouse events to Wayland events. For this to work all of the wayland surface actors need to be made reactive. The wayland keyboard input focus surface is updated whenever Mutter sees a FocusIn event so that it will stay in synch with whatever surface Mutter wants as the focus. Wayland surfaces don't get this event so for now it will just give them focus whenever they are clicked as a hack to test the code. Authored-by: Neil Roberts <neil@linux.intel.com> Authored-by: Giovanni Campagna <gcampagna@src.gnome.org>
2013-05-03 13:51:22 -04:00
meta_wayland_pointer_release (&seat->pointer);
meta_wayland_keyboard_release (&seat->keyboard);
g_slice_free (MetaWaylandSeat, seat);
}
Reference in New Issue Copy Permalink