isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-30 20:01:00 -05:00
Code Issues Packages Projects Releases Wiki Activity
c390f70edc
mutter/src/wayland/meta-wayland-cursor-surface.c

403 lines
14 KiB
C
Raw Normal View History

wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
/*
* Wayland Support
*
* Copyright (C) 2015 Red Hat, Inc.
*
* 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"
Clean up include macros mess The order and way include macros were structured was chaotic, with no real common thread between files. Try to tidy up the mess with some common scheme, to make things look less messy.
2018-07-10 04:36:24 -04:00
#include "wayland/meta-wayland-cursor-surface.h"
Put logical monitor grid lookup API in MetaMonitorManager Don't falsely assume the screen has anything to do with the monitor grid, and thus move the related API to MetaMonitorManager. https://bugzilla.gnome.org/show_bug.cgi?id=777732
2016-11-29 21:49:00 -05:00
#include "backends/meta-backend-private.h"
monitor-manager: Move logical monitor into its own file https://bugzilla.gnome.org/show_bug.cgi?id=777732
2016-12-12 21:37:11 -05:00
#include "backends/meta-logical-monitor.h"
Clean up include macros mess The order and way include macros were structured was chaotic, with no real common thread between files. Try to tidy up the mess with some common scheme, to make things look less messy.
2018-07-10 04:36:24 -04:00
#include "cogl/cogl.h"
cursor-renderer: Track cursor position using floats To be able to render the pointer cursor sprite at sub-(logical)-pixel positions, track the pointer position using floats instead of ints. This also requires users of the cursor sprite rect to deal with floating points, when e.g. finding the logical monitor etc. https://bugzilla.gnome.org/show_bug.cgi?id=765011
2017-06-08 10:13:16 -04:00
#include "core/boxes-private.h"
wayland: Add wl_surface backed cursor sprite implementation This removes the last use of the non-abstract form of MetaCursorSprite usage. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-30 06:03:31 -04:00
#include "wayland/meta-cursor-sprite-wayland.h"
Clean up include macros mess The order and way include macros were structured was chaotic, with no real common thread between files. Try to tidy up the mess with some common scheme, to make things look less messy.
2018-07-10 04:36:24 -04:00
#include "wayland/meta-wayland-buffer.h"
wayland: Send presentation feedbacks to cursors This commit assumes that cursor surfaces work in a "mailbox" fashion. If they are painted multiple times before a successful flip, all commits but the last get discarded, and the last commit gets presented after the flip succeeds. This is more or less how it works in the atomic backend, and also more or less how it works in other backends, with the exception that the cursor painting might fail without any way of knowing. This assumption is still better than unconditionally discarding all cursor surface feedbacks as if the cursor painting always fails. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1484>
2021-02-02 08:51:34 -05:00
#include "wayland/meta-wayland-presentation-time-private.h"
Clean up include macros mess The order and way include macros were structured was chaotic, with no real common thread between files. Try to tidy up the mess with some common scheme, to make things look less messy.
2018-07-10 04:36:24 -04:00
#include "wayland/meta-wayland-private.h"
#include "wayland/meta-xwayland.h"
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
typedef struct _MetaWaylandCursorSurfacePrivate MetaWaylandCursorSurfacePrivate;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
struct _MetaWaylandCursorSurfacePrivate
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
{
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
int hot_x;
int hot_y;
wayland: Add wl_surface backed cursor sprite implementation This removes the last use of the non-abstract form of MetaCursorSprite usage. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-30 06:03:31 -04:00
MetaCursorSpriteWayland *cursor_sprite;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
MetaCursorRenderer *cursor_renderer;
MetaWaylandBuffer *buffer;
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
struct wl_list frame_callbacks;
gulong cursor_painted_handler_id;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
};
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
G_DEFINE_TYPE_WITH_PRIVATE (MetaWaylandCursorSurface,
meta_wayland_cursor_surface,
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
META_TYPE_WAYLAND_SURFACE_ROLE)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
static void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
update_cursor_sprite_texture (MetaWaylandCursorSurface *cursor_surface)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (META_WAYLAND_SURFACE_ROLE (cursor_surface));
wayland: Add wl_surface backed cursor sprite implementation This removes the last use of the non-abstract form of MetaCursorSprite usage. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-30 06:03:31 -04:00
MetaCursorSprite *cursor_sprite = META_CURSOR_SPRITE (priv->cursor_sprite);
wayland: Move surface texture ownership to MetaWaylandSurface Prior to this commit, MetaWaylandSurface held a reference to MetaWaylandBuffer, who owned the texture drawn by the surface. When switching buffer, the texture change with it. This is problematic when dealing with SHM buffer damage management, as when having one texture per buffer, damaged regions uploaded to one, will not follow along to the next one attached. It also wasted GPU memory as there would be one texture per buffer, instead of one one texture per surface. Instead, move the texture ownership to MetaWaylandSurface, and have the SHM buffer damage management update the surface texture. This ensures damage is processed properly, and that we won't end up with stale texture content when doing partial texture uploads. If the same SHM buffer is attached to multiple surfaces, each surface will get their own copy, and damage is tracked and uploaded separately. Non-SHM types of buffers still has their own texture reference, as the texture is just a representation of the GPU memory associated with the buffer. When such a buffer is attached to a surface, instead the surface just gets a reference to that texture, instead of a separately allocated one. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 05:46:48 -05:00
CoglTexture *texture;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland/cursor-surface: Remove unnecessary NULL check The priv->cursor_sprite is created on init() and destroyed on dispose() so it will never be NULL when updating the cursor sprite texture. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-30 05:59:22 -04:00
if (!priv->cursor_renderer)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
return;
wayland: Move surface texture ownership to MetaWaylandSurface Prior to this commit, MetaWaylandSurface held a reference to MetaWaylandBuffer, who owned the texture drawn by the surface. When switching buffer, the texture change with it. This is problematic when dealing with SHM buffer damage management, as when having one texture per buffer, damaged regions uploaded to one, will not follow along to the next one attached. It also wasted GPU memory as there would be one texture per buffer, instead of one one texture per surface. Instead, move the texture ownership to MetaWaylandSurface, and have the SHM buffer damage management update the surface texture. This ensures damage is processed properly, and that we won't end up with stale texture content when doing partial texture uploads. If the same SHM buffer is attached to multiple surfaces, each surface will get their own copy, and damage is tracked and uploaded separately. Non-SHM types of buffers still has their own texture reference, as the texture is just a representation of the GPU memory associated with the buffer. When such a buffer is attached to a surface, instead the surface just gets a reference to that texture, instead of a separately allocated one. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 05:46:48 -05:00
texture = meta_wayland_surface_get_texture (surface);
if (texture)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
meta_cursor_sprite_set_texture (cursor_sprite,
wayland: Move surface texture ownership to MetaWaylandSurface Prior to this commit, MetaWaylandSurface held a reference to MetaWaylandBuffer, who owned the texture drawn by the surface. When switching buffer, the texture change with it. This is problematic when dealing with SHM buffer damage management, as when having one texture per buffer, damaged regions uploaded to one, will not follow along to the next one attached. It also wasted GPU memory as there would be one texture per buffer, instead of one one texture per surface. Instead, move the texture ownership to MetaWaylandSurface, and have the SHM buffer damage management update the surface texture. This ensures damage is processed properly, and that we won't end up with stale texture content when doing partial texture uploads. If the same SHM buffer is attached to multiple surfaces, each surface will get their own copy, and damage is tracked and uploaded separately. Non-SHM types of buffers still has their own texture reference, as the texture is just a representation of the GPU memory associated with the buffer. When such a buffer is attached to a surface, instead the surface just gets a reference to that texture, instead of a separately allocated one. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 05:46:48 -05:00
texture,
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
priv->hot_x * surface->scale,
priv->hot_y * surface->scale);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
else
{
meta_cursor_sprite_set_texture (cursor_sprite, NULL, 0, 0);
}
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
meta_cursor_renderer_force_update (priv->cursor_renderer);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
static void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
cursor_sprite_prepare_at (MetaCursorSprite *cursor_sprite,
backends: Add argument for best scale on MetaCursorSprite::prepare-at Instead of letting implementations poke backend internals from various places, give that information right away. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-07-10 06:25:12 -04:00
float best_scale,
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
int x,
int y,
MetaWaylandCursorSurface *cursor_surface)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandSurfaceRole *role = META_WAYLAND_SURFACE_ROLE (cursor_surface);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
MetaWaylandSurface *surface = meta_wayland_surface_role_get_surface (role);
if (!meta_xwayland_is_xwayland_surface (surface))
{
Put logical monitor grid lookup API in MetaMonitorManager Don't falsely assume the screen has anything to do with the monitor grid, and thus move the related API to MetaMonitorManager. https://bugzilla.gnome.org/show_bug.cgi?id=777732
2016-11-29 21:49:00 -05:00
MetaBackend *backend = meta_get_backend ();
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
logical-monitor: Make scale a float To support fractional scaling, the logical monitor scale must be stored as a float. No other functional changes is part of this commit. https://bugzilla.gnome.org/show_bug.cgi?id=765011
2017-05-25 04:12:51 -04:00
MetaLogicalMonitor *logical_monitor;
Rename MetaMonitorInfo MetaLogicalMonitor In preparation for further refactorizations, rename the MetaMonitorInfo struct to MetaLogicalMonitor. Eventually, part of MetaLogicalMonitor will be split into a MetaMonitor type. https://bugzilla.gnome.org/show_bug.cgi?id=777732
2016-11-25 01:31:38 -05:00
Put logical monitor grid lookup API in MetaMonitorManager Don't falsely assume the screen has anything to do with the monitor grid, and thus move the related API to MetaMonitorManager. https://bugzilla.gnome.org/show_bug.cgi?id=777732
2016-11-29 21:49:00 -05:00
logical_monitor =
meta_monitor_manager_get_logical_monitor_at (monitor_manager, x, y);
Rename MetaMonitorInfo MetaLogicalMonitor In preparation for further refactorizations, rename the MetaMonitorInfo struct to MetaLogicalMonitor. Eventually, part of MetaLogicalMonitor will be split into a MetaMonitor type. https://bugzilla.gnome.org/show_bug.cgi?id=777732
2016-11-25 01:31:38 -05:00
if (logical_monitor)
{
float texture_scale;
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 05:10:52 -05:00
if (meta_is_stage_views_scaled ())
texture_scale = 1.0 / surface->scale;
else
logical-monitor: Make scale a float To support fractional scaling, the logical monitor scale must be stored as a float. No other functional changes is part of this commit. https://bugzilla.gnome.org/show_bug.cgi?id=765011
2017-05-25 04:12:51 -04:00
texture_scale = (meta_logical_monitor_get_scale (logical_monitor) /
surface->scale);
Add support for scaled logical monitor framebuffers This commit adds support for rendering onto enlarged per logical monitor framebuffers, using the scaled clutter stage views, for HiDPI enabled logical monitors. This works by scaling the mode of the monitors in a logical monitors by the scale, no longer relying on scaling the window actors and window geometry for making windows have the correct size on HiDPI monitors. It is disabled by default, as in automatically created configurations will still use the old mode. This is partly because Xwayland clients will not yet work good enough to make it feasible. To enable, add the 'scale-monitor-framebuffer' keyword to the org.gnome.mutter.experimental-features gsettings array. It is still possible to specify the mode via the new D-Bus API, which has been adapted. The adaptations to the D-Bus API means the caller need to be aware of how to position logical monitors on the stage grid. This depends on the 'layout-mode' property that is used (see the DisplayConfig D-Bus documentation). https://bugzilla.gnome.org/show_bug.cgi?id=777732
2017-02-24 05:10:52 -05:00
Rename MetaMonitorInfo MetaLogicalMonitor In preparation for further refactorizations, rename the MetaMonitorInfo struct to MetaLogicalMonitor. Eventually, part of MetaLogicalMonitor will be split into a MetaMonitor type. https://bugzilla.gnome.org/show_bug.cgi?id=777732
2016-11-25 01:31:38 -05:00
meta_cursor_sprite_set_texture_scale (cursor_sprite, texture_scale);
wayland/cursor-surface: Pass buffer-transform to cursor sprite This was previously forgotten, effectively disabling pre-rotated hardware cursors. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/344>
2022-06-22 08:03:41 -04:00
meta_cursor_sprite_set_texture_transform (cursor_sprite,
surface->buffer_transform);
Rename MetaMonitorInfo MetaLogicalMonitor In preparation for further refactorizations, rename the MetaMonitorInfo struct to MetaLogicalMonitor. Eventually, part of MetaLogicalMonitor will be split into a MetaMonitor type. https://bugzilla.gnome.org/show_bug.cgi?id=777732
2016-11-25 01:31:38 -05:00
}
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
meta_wayland_surface_update_outputs (surface);
}
static void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_assigned (MetaWaylandSurfaceRole *surface_role)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurface *cursor_surface =
META_WAYLAND_CURSOR_SURFACE (surface_role);
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
wl_list_insert_list (&priv->frame_callbacks,
wayland: Drive frame callbacks from stage updates Don't tie frame callbacks to actor painting, as it may end up in situations where we miss sending frame callbacks when we should have. An example of this is when a surface is partially off screen, and then reports damage that is fully off screen. When this happen, we are likely not to repaint anything, thus we won't send any frame callbacks even though it's "suitable" for rendering again, as the surface is not on a separate workspace or fully obscured. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/817 Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/1152 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1218
2020-04-27 09:43:19 -04:00
&surface->unassigned.pending_frame_callback_list);
wl_list_init (&surface->unassigned.pending_frame_callback_list);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
static void
wayland/surface-role: Rename commit() vfunc apply_state() The vfunc is not called when a surface commits its state, but when the state is applied. Make this clearer by changing the name to "apply_state" (and "pre_apply_state"). https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-11 05:20:44 -04:00
meta_wayland_cursor_surface_pre_apply_state (MetaWaylandSurfaceRole *surface_role,
MetaWaylandSurfaceState *pending)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurface *cursor_surface =
META_WAYLAND_CURSOR_SURFACE (surface_role);
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
if (pending->newly_attached && priv->buffer)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland/surface: Overhaul handling of buffer use count Move the use count from a separate MetaWaylandBufferRef struct to the MetaWaylandBuffer class, and remove the former. The buffer use count is now incremented already in meta_wayland_surface_commit, since the Wayland protocol defines the buffer to be in use by the compositor at that point. If the buffer attachment ends up being dropped again before it is applied to the surface state (e.g. because another buffer is committed to a synchronized sub-surface before the parent surface is committed), the use count is now decremented, and a buffer release event is sent if the use count drops to 0. Buffer release events were previously incorrectly not sent under these circumstances. Test case: Run the weston-subsurfaces demo with the -r1 and/or -t1 command line parameter. Resize the window. Before this change, weston-subsurfaces would freeze or abort after a few resize operations, because mutter failed to send release events and the client ran out of usable buffers. v2: * Handle NULL priv->buffer_ref in meta_wayland_cursor_surface_apply_state. v3: * Remove MetaWaylandBufferRef altogether, move the use count tracking to MetaWaylandBuffer itself. Much simpler, and doesn't run into lifetime issues when mutter shuts down. v4: * Warn if use count isn't 0 in meta_wayland_buffer_finalize. * Keep pending_buffer_resource_destroyed for attached but not yet committed buffers. If the client attaches a buffer and then destroys it before commit, we ignore the buffer attachement, same as before this MR. v5: * Rebase on top of new commit which splits up surface->texture. * MetaWaylandSurfaceState::buffer can only be non-NULL if ::newly_attached is TRUE, simplify accordingly. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1880>
2022-06-22 12:43:11 -04:00
meta_wayland_buffer_dec_use_count (priv->buffer);
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
g_clear_object (&priv->buffer);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
}
static void
wayland/surface-role: Rename commit() vfunc apply_state() The vfunc is not called when a surface commits its state, but when the state is applied. Make this clearer by changing the name to "apply_state" (and "pre_apply_state"). https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-11 05:20:44 -04:00
meta_wayland_cursor_surface_apply_state (MetaWaylandSurfaceRole *surface_role,
MetaWaylandSurfaceState *pending)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurface *cursor_surface =
META_WAYLAND_CURSOR_SURFACE (surface_role);
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland/surface: Overhaul handling of buffer use count Move the use count from a separate MetaWaylandBufferRef struct to the MetaWaylandBuffer class, and remove the former. The buffer use count is now incremented already in meta_wayland_surface_commit, since the Wayland protocol defines the buffer to be in use by the compositor at that point. If the buffer attachment ends up being dropped again before it is applied to the surface state (e.g. because another buffer is committed to a synchronized sub-surface before the parent surface is committed), the use count is now decremented, and a buffer release event is sent if the use count drops to 0. Buffer release events were previously incorrectly not sent under these circumstances. Test case: Run the weston-subsurfaces demo with the -r1 and/or -t1 command line parameter. Resize the window. Before this change, weston-subsurfaces would freeze or abort after a few resize operations, because mutter failed to send release events and the client ran out of usable buffers. v2: * Handle NULL priv->buffer_ref in meta_wayland_cursor_surface_apply_state. v3: * Remove MetaWaylandBufferRef altogether, move the use count tracking to MetaWaylandBuffer itself. Much simpler, and doesn't run into lifetime issues when mutter shuts down. v4: * Warn if use count isn't 0 in meta_wayland_buffer_finalize. * Keep pending_buffer_resource_destroyed for attached but not yet committed buffers. If the client attaches a buffer and then destroys it before commit, we ignore the buffer attachement, same as before this MR. v5: * Rebase on top of new commit which splits up surface->texture. * MetaWaylandSurfaceState::buffer can only be non-NULL if ::newly_attached is TRUE, simplify accordingly. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1880>
2022-06-22 12:43:11 -04:00
if (pending->buffer)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland/surface: Overhaul handling of buffer use count Move the use count from a separate MetaWaylandBufferRef struct to the MetaWaylandBuffer class, and remove the former. The buffer use count is now incremented already in meta_wayland_surface_commit, since the Wayland protocol defines the buffer to be in use by the compositor at that point. If the buffer attachment ends up being dropped again before it is applied to the surface state (e.g. because another buffer is committed to a synchronized sub-surface before the parent surface is committed), the use count is now decremented, and a buffer release event is sent if the use count drops to 0. Buffer release events were previously incorrectly not sent under these circumstances. Test case: Run the weston-subsurfaces demo with the -r1 and/or -t1 command line parameter. Resize the window. Before this change, weston-subsurfaces would freeze or abort after a few resize operations, because mutter failed to send release events and the client ran out of usable buffers. v2: * Handle NULL priv->buffer_ref in meta_wayland_cursor_surface_apply_state. v3: * Remove MetaWaylandBufferRef altogether, move the use count tracking to MetaWaylandBuffer itself. Much simpler, and doesn't run into lifetime issues when mutter shuts down. v4: * Warn if use count isn't 0 in meta_wayland_buffer_finalize. * Keep pending_buffer_resource_destroyed for attached but not yet committed buffers. If the client attaches a buffer and then destroys it before commit, we ignore the buffer attachement, same as before this MR. v5: * Rebase on top of new commit which splits up surface->texture. * MetaWaylandSurfaceState::buffer can only be non-NULL if ::newly_attached is TRUE, simplify accordingly. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1880>
2022-06-22 12:43:11 -04:00
priv->buffer = g_object_ref (pending->buffer);
meta_wayland_buffer_inc_use_count (priv->buffer);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
wl_list_insert_list (&priv->frame_callbacks,
&pending->frame_callback_list);
wl_list_init (&pending->frame_callback_list);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Move surface texture ownership to MetaWaylandSurface Prior to this commit, MetaWaylandSurface held a reference to MetaWaylandBuffer, who owned the texture drawn by the surface. When switching buffer, the texture change with it. This is problematic when dealing with SHM buffer damage management, as when having one texture per buffer, damaged regions uploaded to one, will not follow along to the next one attached. It also wasted GPU memory as there would be one texture per buffer, instead of one one texture per surface. Instead, move the texture ownership to MetaWaylandSurface, and have the SHM buffer damage management update the surface texture. This ensures damage is processed properly, and that we won't end up with stale texture content when doing partial texture uploads. If the same SHM buffer is attached to multiple surfaces, each surface will get their own copy, and damage is tracked and uploaded separately. Non-SHM types of buffers still has their own texture reference, as the texture is just a representation of the GPU memory associated with the buffer. When such a buffer is attached to a surface, instead the surface just gets a reference to that texture, instead of a separately allocated one. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/199
2019-02-08 05:46:48 -05:00
if (pending->newly_attached &&
wayland/cursor-surface: Update sprite when attaching NULL Attaching a NULL buffer should hide the cursor sprite. In these cases, we we'll have neither surface nor buffer damage, so also update when we just attached a NULL buffer. Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/630
2019-06-07 09:51:45 -04:00
((!cairo_region_is_empty (pending->surface_damage) ||
!cairo_region_is_empty (pending->buffer_damage)) ||
!priv->buffer))
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
update_cursor_sprite_texture (META_WAYLAND_CURSOR_SURFACE (surface_role));
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
static gboolean
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_is_on_logical_monitor (MetaWaylandSurfaceRole *role,
MetaLogicalMonitor *logical_monitor)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (role);
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurface *cursor_surface =
META_WAYLAND_CURSOR_SURFACE (surface->role);
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Move away from meta_cursor_renderer_get_position() Fetch the cursor renderer device, and query its position instead. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-07-13 07:34:59 -04:00
ClutterInputDevice *device;
Replace ClutterPoint by graphene_point_t Remove the tests for ClutterPoint since it's corresponding code moved to private ClutterStage methods. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 09:53:44 -05:00
graphene_point_t point;
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 10:23:04 -05:00
graphene_rect_t logical_monitor_rect;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Handle NULL cursor renderer finding the outputs of a cursor role Having a cursor role with a NULL renderer is valid state, and even desirable on tablets (eg. after proximity out). In those cases it should be interpreted as the cursor surface not being over any output. https://gitlab.gnome.org/GNOME/mutter/merge_requests/545
2019-04-18 13:21:36 -04:00
if (!priv->cursor_renderer)
return FALSE;
cursor-renderer: Track cursor position using floats To be able to render the pointer cursor sprite at sub-(logical)-pixel positions, track the pointer position using floats instead of ints. This also requires users of the cursor sprite rect to deal with floating points, when e.g. finding the logical monitor etc. https://bugzilla.gnome.org/show_bug.cgi?id=765011
2017-06-08 10:13:16 -04:00
logical_monitor_rect =
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 10:23:04 -05:00
meta_rectangle_to_graphene_rect (&logical_monitor->rect);
wayland: Use cursor position in logical monitor When using two monitors size by side with different scales, once the cursor moves from one output to another one, its size changes based on the scale of the given output. Changing the size of the cursor can cause the cursor area to change output again if the hotspot is not exactly at the top left corner of the area, causing the texture of the cursor to change, which will trigger another output change, so on and so forth causing continuous surface enter/leave event which flood the clients and eventually kill them. Change the logic to use only the actual cursor position to determine if its on the given logical monitor, so that it remains immune to scale changes induced by output scale differences. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/83
2018-03-23 08:05:12 -04:00
wayland: Move away from meta_cursor_renderer_get_position() Fetch the cursor renderer device, and query its position instead. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-07-13 07:34:59 -04:00
device = meta_cursor_renderer_get_input_device (priv->cursor_renderer);
clutter: Drop clutter_input_device_get_coords() method This is not device state anymore. It uses ClutterSeat API underneath, so let callers do that instead. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1403>
2020-11-18 09:49:02 -05:00
clutter_seat_query_state (clutter_input_device_get_seat (device),
device, NULL, &point, NULL);
wayland: Use cursor position in logical monitor When using two monitors size by side with different scales, once the cursor moves from one output to another one, its size changes based on the scale of the given output. Changing the size of the cursor can cause the cursor area to change output again if the hotspot is not exactly at the top left corner of the area, causing the texture of the cursor to change, which will trigger another output change, so on and so forth causing continuous surface enter/leave event which flood the clients and eventually kill them. Change the logic to use only the actual cursor position to determine if its on the given logical monitor, so that it remains immune to scale changes induced by output scale differences. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/83
2018-03-23 08:05:12 -04:00
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 10:23:04 -05:00
return graphene_rect_contains_point (&logical_monitor_rect, &point);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
static void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_dispose (GObject *object)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurface *cursor_surface =
META_WAYLAND_CURSOR_SURFACE (object);
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
MetaWaylandFrameCallback *cb, *next;
wl_list_for_each_safe (cb, next, &priv->frame_callbacks, link)
wl_resource_destroy (cb->resource);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
g_signal_handlers_disconnect_by_func (priv->cursor_sprite,
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
cursor_sprite_prepare_at, cursor_surface);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
g_clear_object (&priv->cursor_renderer);
backends: Replace MetaCursorSprite::prepare-at with in-place function Since this signal is in a hot path during input handling, it makes sense not to have this be a signal at all, currently most of the time spent in it is in GLib signal machinery itself. Replace it with a function/user data pair that are set on the sprite itself. Only the places that create an sprite are interested in hooking one ::prepare-at behavior per sprite, so we can do with a single pair. This makes meta_cursor_sprite_prepare_at() inexpensive enough. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1915>
2021-07-05 10:19:05 -04:00
if (priv->cursor_sprite)
{
meta_cursor_sprite_set_prepare_func (META_CURSOR_SPRITE (priv->cursor_sprite),
NULL, NULL);
g_clear_object (&priv->cursor_sprite);
}
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
if (priv->buffer)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland/surface: Overhaul handling of buffer use count Move the use count from a separate MetaWaylandBufferRef struct to the MetaWaylandBuffer class, and remove the former. The buffer use count is now incremented already in meta_wayland_surface_commit, since the Wayland protocol defines the buffer to be in use by the compositor at that point. If the buffer attachment ends up being dropped again before it is applied to the surface state (e.g. because another buffer is committed to a synchronized sub-surface before the parent surface is committed), the use count is now decremented, and a buffer release event is sent if the use count drops to 0. Buffer release events were previously incorrectly not sent under these circumstances. Test case: Run the weston-subsurfaces demo with the -r1 and/or -t1 command line parameter. Resize the window. Before this change, weston-subsurfaces would freeze or abort after a few resize operations, because mutter failed to send release events and the client ran out of usable buffers. v2: * Handle NULL priv->buffer_ref in meta_wayland_cursor_surface_apply_state. v3: * Remove MetaWaylandBufferRef altogether, move the use count tracking to MetaWaylandBuffer itself. Much simpler, and doesn't run into lifetime issues when mutter shuts down. v4: * Warn if use count isn't 0 in meta_wayland_buffer_finalize. * Keep pending_buffer_resource_destroyed for attached but not yet committed buffers. If the client attaches a buffer and then destroys it before commit, we ignore the buffer attachement, same as before this MR. v5: * Rebase on top of new commit which splits up surface->texture. * MetaWaylandSurfaceState::buffer can only be non-NULL if ::newly_attached is TRUE, simplify accordingly. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1880>
2022-06-22 12:43:11 -04:00
meta_wayland_buffer_dec_use_count (priv->buffer);
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
g_clear_object (&priv->buffer);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
G_OBJECT_CLASS (meta_wayland_cursor_surface_parent_class)->dispose (object);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
wayland/cursor-role: Increase buffer use count on construction We may be assigned multiple times, if the surface is assigned to be a cursor surface multiple times. Each time e.g. wl_pointer.set_cursor is called, we'll be assigned. While the role object exists, we'll handle buffer use count even when we are not actively assigned, thus we should only handle the initial assignment use count bump when constructing, so that we don't increase it when reassigned, where the wl_resource may already have been released. https://bugzilla.gnome.org/show_bug.cgi?id=770402
2016-08-25 05:38:45 -04:00
static void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_constructed (GObject *object)
wayland/cursor-role: Increase buffer use count on construction We may be assigned multiple times, if the surface is assigned to be a cursor surface multiple times. Each time e.g. wl_pointer.set_cursor is called, we'll be assigned. While the role object exists, we'll handle buffer use count even when we are not actively assigned, thus we should only handle the initial assignment use count bump when constructing, so that we don't increase it when reassigned, where the wl_resource may already have been released. https://bugzilla.gnome.org/show_bug.cgi?id=770402
2016-08-25 05:38:45 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurface *cursor_surface =
META_WAYLAND_CURSOR_SURFACE (object);
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland/cursor-role: Increase buffer use count on construction We may be assigned multiple times, if the surface is assigned to be a cursor surface multiple times. Each time e.g. wl_pointer.set_cursor is called, we'll be assigned. While the role object exists, we'll handle buffer use count even when we are not actively assigned, thus we should only handle the initial assignment use count bump when constructing, so that we don't increase it when reassigned, where the wl_resource may already have been released. https://bugzilla.gnome.org/show_bug.cgi?id=770402
2016-08-25 05:38:45 -04:00
MetaWaylandSurfaceRole *surface_role =
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
META_WAYLAND_SURFACE_ROLE (cursor_surface);
wayland/cursor-role: Increase buffer use count on construction We may be assigned multiple times, if the surface is assigned to be a cursor surface multiple times. Each time e.g. wl_pointer.set_cursor is called, we'll be assigned. While the role object exists, we'll handle buffer use count even when we are not actively assigned, thus we should only handle the initial assignment use count bump when constructing, so that we don't increase it when reassigned, where the wl_resource may already have been released. https://bugzilla.gnome.org/show_bug.cgi?id=770402
2016-08-25 05:38:45 -04:00
MetaWaylandSurface *surface =
meta_wayland_surface_role_get_surface (surface_role);
cursor-sprite: Register all cursor sprites with the cursor tracker This will later be used to invalidate GPU state when closing device nodes. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2147>
2021-11-15 08:24:53 -05:00
MetaWaylandCompositor *compositor = surface->compositor;
MetaBackend *backend = meta_context_get_backend (compositor->context);
MetaCursorTracker *cursor_tracker = meta_backend_get_cursor_tracker (backend);
wayland/cursor-role: Increase buffer use count on construction We may be assigned multiple times, if the surface is assigned to be a cursor surface multiple times. Each time e.g. wl_pointer.set_cursor is called, we'll be assigned. While the role object exists, we'll handle buffer use count even when we are not actively assigned, thus we should only handle the initial assignment use count bump when constructing, so that we don't increase it when reassigned, where the wl_resource may already have been released. https://bugzilla.gnome.org/show_bug.cgi?id=770402
2016-08-25 05:38:45 -04:00
MetaWaylandBuffer *buffer;
buffer = meta_wayland_surface_get_buffer (surface);
wayland/cursor-role: Handle premature wl_buffer destruction If a client would attach a buffer to a surface, commit, destroy the buffer and then later set the surface as a cursor, there will be no wl_buffer available to be used by the cursor role. Instead of dereferencing the non-existing wl_buffer resource, handle this situation by logging a warning and treating a prematurely destroyd wl_buffer as if no buffer had been attached. https://bugzilla.gnome.org/show_bug.cgi?id=770992
2016-09-07 04:23:25 -04:00
g_warn_if_fail (!buffer || buffer->resource);
if (buffer && buffer->resource)
wayland/cursor-role: Increase buffer use count on construction We may be assigned multiple times, if the surface is assigned to be a cursor surface multiple times. Each time e.g. wl_pointer.set_cursor is called, we'll be assigned. While the role object exists, we'll handle buffer use count even when we are not actively assigned, thus we should only handle the initial assignment use count bump when constructing, so that we don't increase it when reassigned, where the wl_resource may already have been released. https://bugzilla.gnome.org/show_bug.cgi?id=770402
2016-08-25 05:38:45 -04:00
{
wayland/surface: Overhaul handling of buffer use count Move the use count from a separate MetaWaylandBufferRef struct to the MetaWaylandBuffer class, and remove the former. The buffer use count is now incremented already in meta_wayland_surface_commit, since the Wayland protocol defines the buffer to be in use by the compositor at that point. If the buffer attachment ends up being dropped again before it is applied to the surface state (e.g. because another buffer is committed to a synchronized sub-surface before the parent surface is committed), the use count is now decremented, and a buffer release event is sent if the use count drops to 0. Buffer release events were previously incorrectly not sent under these circumstances. Test case: Run the weston-subsurfaces demo with the -r1 and/or -t1 command line parameter. Resize the window. Before this change, weston-subsurfaces would freeze or abort after a few resize operations, because mutter failed to send release events and the client ran out of usable buffers. v2: * Handle NULL priv->buffer_ref in meta_wayland_cursor_surface_apply_state. v3: * Remove MetaWaylandBufferRef altogether, move the use count tracking to MetaWaylandBuffer itself. Much simpler, and doesn't run into lifetime issues when mutter shuts down. v4: * Warn if use count isn't 0 in meta_wayland_buffer_finalize. * Keep pending_buffer_resource_destroyed for attached but not yet committed buffers. If the client attaches a buffer and then destroys it before commit, we ignore the buffer attachement, same as before this MR. v5: * Rebase on top of new commit which splits up surface->texture. * MetaWaylandSurfaceState::buffer can only be non-NULL if ::newly_attached is TRUE, simplify accordingly. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1880>
2022-06-22 12:43:11 -04:00
priv->buffer = g_object_ref (surface->buffer);
meta_wayland_buffer_inc_use_count (priv->buffer);
wayland/cursor-role: Increase buffer use count on construction We may be assigned multiple times, if the surface is assigned to be a cursor surface multiple times. Each time e.g. wl_pointer.set_cursor is called, we'll be assigned. While the role object exists, we'll handle buffer use count even when we are not actively assigned, thus we should only handle the initial assignment use count bump when constructing, so that we don't increase it when reassigned, where the wl_resource may already have been released. https://bugzilla.gnome.org/show_bug.cgi?id=770402
2016-08-25 05:38:45 -04:00
}
cursor-renderer/native: Fetch instead of pass wl_buffer when realizing This is the next step in centralizing the cursor sprite hw sprite realization paths. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-05-02 06:27:02 -04:00
cursor-sprite: Register all cursor sprites with the cursor tracker This will later be used to invalidate GPU state when closing device nodes. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2147>
2021-11-15 08:24:53 -05:00
priv->cursor_sprite = meta_cursor_sprite_wayland_new (surface,
cursor_tracker);
backends: Replace MetaCursorSprite::prepare-at with in-place function Since this signal is in a hot path during input handling, it makes sense not to have this be a signal at all, currently most of the time spent in it is in GLib signal machinery itself. Replace it with a function/user data pair that are set on the sprite itself. Only the places that create an sprite are interested in hooking one ::prepare-at behavior per sprite, so we can do with a single pair. This makes meta_cursor_sprite_prepare_at() inexpensive enough. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1915>
2021-07-05 10:19:05 -04:00
meta_cursor_sprite_set_prepare_func (META_CURSOR_SPRITE (priv->cursor_sprite),
(MetaCursorPrepareFunc) cursor_sprite_prepare_at,
cursor_surface);
wayland/cursor-role: Increase buffer use count on construction We may be assigned multiple times, if the surface is assigned to be a cursor surface multiple times. Each time e.g. wl_pointer.set_cursor is called, we'll be assigned. While the role object exists, we'll handle buffer use count even when we are not actively assigned, thus we should only handle the initial assignment use count bump when constructing, so that we don't increase it when reassigned, where the wl_resource may already have been released. https://bugzilla.gnome.org/show_bug.cgi?id=770402
2016-08-25 05:38:45 -04:00
}
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
static void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_init (MetaWaylandCursorSurface *role)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (role);
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
wl_list_init (&priv->frame_callbacks);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
static void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_class_init (MetaWaylandCursorSurfaceClass *klass)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
MetaWaylandSurfaceRoleClass *surface_role_class =
META_WAYLAND_SURFACE_ROLE_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
surface_role_class->assigned = meta_wayland_cursor_surface_assigned;
wayland/surface-role: Rename commit() vfunc apply_state() The vfunc is not called when a surface commits its state, but when the state is applied. Make this clearer by changing the name to "apply_state" (and "pre_apply_state"). https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-11 05:20:44 -04:00
surface_role_class->pre_apply_state =
meta_wayland_cursor_surface_pre_apply_state;
surface_role_class->apply_state = meta_wayland_cursor_surface_apply_state;
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
surface_role_class->is_on_logical_monitor =
meta_wayland_cursor_surface_is_on_logical_monitor;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
object_class->constructed = meta_wayland_cursor_surface_constructed;
object_class->dispose = meta_wayland_cursor_surface_dispose;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
MetaCursorSprite *
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_get_sprite (MetaWaylandCursorSurface *cursor_surface)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
wayland: Add wl_surface backed cursor sprite implementation This removes the last use of the non-abstract form of MetaCursorSprite usage. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-30 06:03:31 -04:00
return META_CURSOR_SPRITE (priv->cursor_sprite);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_set_hotspot (MetaWaylandCursorSurface *cursor_surface,
int hotspot_x,
int hotspot_y)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
if (priv->hot_x == hotspot_x &&
priv->hot_y == hotspot_y)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
return;
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
priv->hot_x = hotspot_x;
priv->hot_y = hotspot_y;
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
update_cursor_sprite_texture (cursor_surface);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_get_hotspot (MetaWaylandCursorSurface *cursor_surface,
int *hotspot_x,
int *hotspot_y)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
if (hotspot_x)
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
*hotspot_x = priv->hot_x;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
if (hotspot_y)
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
*hotspot_y = priv->hot_y;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
static void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
on_cursor_painted (MetaCursorRenderer *renderer,
MetaCursorSprite *displayed_sprite,
backend: Pass stage view to cursor-painted signal Will be used for presentation-time handling. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1484>
2021-02-02 08:49:56 -05:00
ClutterStageView *stage_view,
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurface *cursor_surface)
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
guint32 time = (guint32) (g_get_monotonic_time () / 1000);
wayland: Send presentation feedbacks to cursors This commit assumes that cursor surfaces work in a "mailbox" fashion. If they are painted multiple times before a successful flip, all commits but the last get discarded, and the last commit gets presented after the flip succeeds. This is more or less how it works in the atomic backend, and also more or less how it works in other backends, with the exception that the cursor painting might fail without any way of knowing. This assumption is still better than unconditionally discarding all cursor surface feedbacks as if the cursor painting always fails. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1484>
2021-02-02 08:51:34 -05:00
MetaBackend *backend = meta_get_backend ();
context: Make the context own MetaWaylandCompositor Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1861>
2021-03-03 16:00:05 -05:00
MetaContext *context = meta_backend_get_context (backend);
wayland: Send presentation feedbacks to cursors This commit assumes that cursor surfaces work in a "mailbox" fashion. If they are painted multiple times before a successful flip, all commits but the last get discarded, and the last commit gets presented after the flip succeeds. This is more or less how it works in the atomic backend, and also more or less how it works in other backends, with the exception that the cursor painting might fail without any way of knowing. This assumption is still better than unconditionally discarding all cursor surface feedbacks as if the cursor painting always fails. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1484>
2021-02-02 08:51:34 -05:00
MetaWaylandCompositor *compositor =
context: Make the context own MetaWaylandCompositor Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1861>
2021-03-03 16:00:05 -05:00
meta_context_get_wayland_compositor (context);
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
wayland: Add wl_surface backed cursor sprite implementation This removes the last use of the non-abstract form of MetaCursorSprite usage. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-30 06:03:31 -04:00
if (displayed_sprite != META_CURSOR_SPRITE (priv->cursor_sprite))
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
return;
while (!wl_list_empty (&priv->frame_callbacks))
{
MetaWaylandFrameCallback *callback =
wl_container_of (priv->frame_callbacks.next, callback, link);
wl_callback_send_done (callback->resource, time);
wl_resource_destroy (callback->resource);
}
wayland: Send presentation feedbacks to cursors This commit assumes that cursor surfaces work in a "mailbox" fashion. If they are painted multiple times before a successful flip, all commits but the last get discarded, and the last commit gets presented after the flip succeeds. This is more or less how it works in the atomic backend, and also more or less how it works in other backends, with the exception that the cursor painting might fail without any way of knowing. This assumption is still better than unconditionally discarding all cursor surface feedbacks as if the cursor painting always fails. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1484>
2021-02-02 08:51:34 -05:00
meta_wayland_presentation_time_cursor_painted (&compositor->presentation_time,
stage_view,
cursor_surface);
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
}
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
void
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_set_renderer (MetaWaylandCursorSurface *cursor_surface,
MetaCursorRenderer *renderer)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
if (priv->cursor_renderer == renderer)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
return;
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
if (priv->cursor_renderer)
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
{
cleanup: Use g_clear_signal_handler() where possible This is inspired by 98892391d764d1cf where the usage of `g_signal_handler_disconnect()` without resetting the corresponding handler id later resulted in a bug. Using `g_clear_signal_handler()` makes sure we avoid similar bugs and is almost always the better alternative. We use it for new code, let's clean up the old code to also use it. A further benefit is that it can get called even if the passed id is 0, allowing us to remove a lot of now unnessecary checks, and the fact that `g_clear_signal_handler()` checks for the right type size, forcing us to clean up all places where we used `guint` instead of `gulong`. No functional changes intended here and all changes should be trivial, thus bundled in one big commit. https://gitlab.gnome.org/GNOME/mutter/merge_requests/940
2019-11-15 19:25:52 -05:00
g_clear_signal_handler (&priv->cursor_painted_handler_id,
priv->cursor_renderer);
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
g_object_unref (priv->cursor_renderer);
}
if (renderer)
{
priv->cursor_painted_handler_id =
g_signal_connect_object (renderer, "cursor-painted",
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
G_CALLBACK (on_cursor_painted), cursor_surface, 0);
surface-role-cursor: Send frame callbacks for backend handled cursors For backend handled cursors, if nothing else changes on the clutter stage, we end up not sending out frame callbacks since clutter doesn't draw a new frame. To fix this, we'll keep cursor surfaces' frame callbacks separate from other surfaces' and trigger them from the new MetaCursorRenderer::cursor-painted signal which handles both software and hardware cursors. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-08-16 12:21:46 -04:00
g_object_ref (renderer);
}
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
priv->cursor_renderer = renderer;
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
update_cursor_sprite_texture (cursor_surface);
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
MetaCursorRenderer *
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
meta_wayland_cursor_surface_get_renderer (MetaWaylandCursorSurface *cursor_surface)
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
{
wayland: Rename cursor role types Rename the two cursor role types according to the convention used by the other roles. This means that MetaWaylandSurfaceRoleCursor was renamed to MetaWaylandCursorSurface, and MetaWaylandSurfaceRoleTabletCursor was renamed to MetaWaylandTabletCursorSurface. The corresponding filenames were renamed accordingly too. https://gitlab.gnome.org/GNOME/mutter/issues/77
2018-04-19 15:51:31 -04:00
MetaWaylandCursorSurfacePrivate *priv =
meta_wayland_cursor_surface_get_instance_private (cursor_surface);
wayland: Make additional data in MetaWaylandSurfaceRoleCursor private This will help subclassing it.
2016-05-12 09:53:07 -04:00
return priv->cursor_renderer;
wayland: Refactor MetaWaylandSurfaceRoleCursor Move into a standalone meta-wayland-surface-role-cursor.[ch], and make generic enough to work for pointe and additional (eg. tablet) cursors. Most notably, the sprite is now kept completely internal to the cursor role, and updates are routed through the given MetaCursorRenderer (which may be the default one for the pointer, or something else). The way cursor updates after cursor surface destruction has also been reworked, the pointer will just keep track of the last cursor surface, so older surfaces being destroyed don't trigger pointer rechecks/updates.
2015-10-21 10:36:44 -04:00
}
Reference in New Issue Copy Permalink