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

286 lines
8.3 KiB
C
Raw Normal View History

Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2014 Red Hat
*
* 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.
*
* Written by:
* Jasper St. Pierre <jstpierre@mecheye.net>
*/
#include "config.h"
#include "meta-cursor-renderer.h"
backend: Create the stage in the backend, rather than the compositor This allows creating the stage much earlier than it otherwise would have been. Our initialization sequence has always been a bit haphazard, with first the MetaBackend created, then the MetaDisplay, and inside of that, the MetaScreen and MetaCompositor. Refactor this out so that the MetaBackend creates the Clutter stage. Besides the clarity of early initialization, we now have much easier access to the stage, allowing us to use it for things such as key focus and beyond.
2014-08-13 19:46:32 -04:00
#include <meta/meta-backend.h>
#include <meta/util.h>
fix warning due implicit declaration of function error: implicit declaration of function .x = (int)roundf (priv->current_x - (hot_x * texture_scale)), ^ https://bugzilla.gnome.org/show_bug.cgi?id=765252
2016-04-19 05:33:14 -04:00
#include <math.h>
backend: Create the stage in the backend, rather than the compositor This allows creating the stage much earlier than it otherwise would have been. Our initialization sequence has always been a bit haphazard, with first the MetaBackend created, then the MetaDisplay, and inside of that, the MetaScreen and MetaCompositor. Refactor this out so that the MetaBackend creates the Clutter stage. Besides the clarity of early initialization, we now have much easier access to the stage, allowing us to use it for things such as key focus and beyond.
2014-08-13 19:46:32 -04:00
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
#include <cogl/cogl.h>
#include <clutter/clutter.h>
build: Introspect some more types While MetaStage, MetaWindowGroup and MetaDBusDisplayConfigSkeleton don't appear explicitly in the public API, their gtypes are still exposed via meta_get_stage_for_screen(), meta_get_*window_group_for_screen() and MetaMonitorManager's parent type. Newer versions of gjs will warn about undefined properties if it encounters a gtype without introspection information, so expose those types to shut up the warnings. https://bugzilla.gnome.org/show_bug.cgi?id=781471
2018-05-02 12:53:11 -04:00
#include "meta-stage-private.h"
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
struct _MetaCursorRendererPrivate
{
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
float current_x;
float current_y;
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
MetaCursorSprite *displayed_cursor;
backends: Allow multiple "SW" cursor overlays on the stage All the upper layers are prepared for multiple onscreen cursors, but this. All MetaCursorRenderers created would poke the same internal MetaOverlay in the stage. This will lead to multiple cursor renderers resorting to the "SW" rendering paths (as it can be seen with tablet support) to reuse the same overlay, thus leading to flickering when a different MetaCursorRenderer takes over the overlay. Fix this by allowing per-cursor-renderer overlays, their lifetime is attached to the cursor renderer, so is expected to be tear down if the relevant device (eg. tablet) disappears.
2016-05-02 07:49:13 -04:00
MetaOverlay *stage_overlay;
cursor: Correct switching between fallback and backend cursors When switching from the stage cursor to the native cursor, we forgot to repaint the stage to get rid of the old cursor. Fix this by having the abstract cursor renderer class track whether we're using the backend, rather than doing chain-up shenanigans.
2014-05-17 11:22:05 -04:00
gboolean handled_by_backend;
cursor-renderer: Add a cursor painted signal This signal allows interested parties to be notified of a new cursor frame being painted regardless of whether it's being painted by the backend directly or if it's a software rendered cursor frame handled by clutter. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-01-10 11:28:54 -05:00
guint post_paint_func_id;
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
};
typedef struct _MetaCursorRendererPrivate MetaCursorRendererPrivate;
cursor-renderer: Add a cursor painted signal This signal allows interested parties to be notified of a new cursor frame being painted regardless of whether it's being painted by the backend directly or if it's a software rendered cursor frame handled by clutter. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-01-10 11:28:54 -05:00
enum {
CURSOR_PAINTED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
G_DEFINE_TYPE_WITH_PRIVATE (MetaCursorRenderer, meta_cursor_renderer, G_TYPE_OBJECT);
cursor-renderer: Add a cursor painted signal This signal allows interested parties to be notified of a new cursor frame being painted regardless of whether it's being painted by the backend directly or if it's a software rendered cursor frame handled by clutter. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-01-10 11:28:54 -05:00
void
meta_cursor_renderer_emit_painted (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
{
g_signal_emit (renderer, signals[CURSOR_PAINTED], 0, cursor_sprite);
}
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
static void
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
queue_redraw (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
{
MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
backend: Create the stage in the backend, rather than the compositor This allows creating the stage much earlier than it otherwise would have been. Our initialization sequence has always been a bit haphazard, with first the MetaBackend created, then the MetaDisplay, and inside of that, the MetaScreen and MetaCompositor. Refactor this out so that the MetaBackend creates the Clutter stage. Besides the clarity of early initialization, we now have much easier access to the stage, allowing us to use it for things such as key focus and beyond.
2014-08-13 19:46:32 -04:00
MetaBackend *backend = meta_get_backend ();
ClutterActor *stage = meta_backend_get_stage (backend);
stage: Make the API take a CoglTexture MetaCursorReference doesn't really need to be part of the API.
2014-08-21 15:00:03 -04:00
CoglTexture *texture;
backends: Fix ClutterRect initialisations With Clang, these initialisations were warning about missing brackets. Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=791022
2017-11-30 07:59:08 -05:00
ClutterRect rect = CLUTTER_RECT_INIT_ZERO;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
if (cursor_sprite)
rect = meta_cursor_renderer_calculate_rect (renderer, cursor_sprite);
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
cursor-renderer: Kill a warning This can happen during early initialization. We should have a better initialization plan.
2014-04-22 14:43:46 -04:00
/* During early initialization, we can have no stage */
if (!stage)
return;
backends: Allow multiple "SW" cursor overlays on the stage All the upper layers are prepared for multiple onscreen cursors, but this. All MetaCursorRenderers created would poke the same internal MetaOverlay in the stage. This will lead to multiple cursor renderers resorting to the "SW" rendering paths (as it can be seen with tablet support) to reuse the same overlay, thus leading to flickering when a different MetaCursorRenderer takes over the overlay. Fix this by allowing per-cursor-renderer overlays, their lifetime is attached to the cursor renderer, so is expected to be tear down if the relevant device (eg. tablet) disappears.
2016-05-02 07:49:13 -04:00
if (!priv->stage_overlay)
priv->stage_overlay = meta_stage_create_cursor_overlay (META_STAGE (stage));
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
if (cursor_sprite && !priv->handled_by_backend)
texture = meta_cursor_sprite_get_cogl_texture (cursor_sprite);
cursor: Correct switching between fallback and backend cursors When switching from the stage cursor to the native cursor, we forgot to repaint the stage to get rid of the old cursor. Fix this by having the abstract cursor renderer class track whether we're using the backend, rather than doing chain-up shenanigans.
2014-05-17 11:22:05 -04:00
else
stage: Make the API take a CoglTexture MetaCursorReference doesn't really need to be part of the API.
2014-08-21 15:00:03 -04:00
texture = NULL;
backends: Allow multiple "SW" cursor overlays on the stage All the upper layers are prepared for multiple onscreen cursors, but this. All MetaCursorRenderers created would poke the same internal MetaOverlay in the stage. This will lead to multiple cursor renderers resorting to the "SW" rendering paths (as it can be seen with tablet support) to reuse the same overlay, thus leading to flickering when a different MetaCursorRenderer takes over the overlay. Fix this by allowing per-cursor-renderer overlays, their lifetime is attached to the cursor renderer, so is expected to be tear down if the relevant device (eg. tablet) disappears.
2016-05-02 07:49:13 -04:00
meta_stage_update_cursor_overlay (META_STAGE (stage), priv->stage_overlay,
texture, &rect);
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
}
cursor-renderer: Add a cursor painted signal This signal allows interested parties to be notified of a new cursor frame being painted regardless of whether it's being painted by the backend directly or if it's a software rendered cursor frame handled by clutter. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-01-10 11:28:54 -05:00
static gboolean
meta_cursor_renderer_post_paint (gpointer data)
{
MetaCursorRenderer *renderer = META_CURSOR_RENDERER (data);
MetaCursorRendererPrivate *priv =
meta_cursor_renderer_get_instance_private (renderer);
if (priv->displayed_cursor && !priv->handled_by_backend)
meta_cursor_renderer_emit_painted (renderer, priv->displayed_cursor);
return TRUE;
}
cursor: Correct switching between fallback and backend cursors When switching from the stage cursor to the native cursor, we forgot to repaint the stage to get rid of the old cursor. Fix this by having the abstract cursor renderer class track whether we're using the backend, rather than doing chain-up shenanigans.
2014-05-17 11:22:05 -04:00
static gboolean
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
meta_cursor_renderer_real_update_cursor (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
cursor-renderer: Rewrite HW cursors to be cleaner
2014-04-22 15:39:09 -04:00
{
backend: Realize cursor on default MetaCursorRenderer paths The cursor is realized on x11/native subclasses, but not if a base MetaCursorRenderer is created.
2015-10-22 08:43:46 -04:00
if (cursor_sprite)
meta_cursor_sprite_realize_texture (cursor_sprite);
cursor: Correct switching between fallback and backend cursors When switching from the stage cursor to the native cursor, we forgot to repaint the stage to get rid of the old cursor. Fix this by having the abstract cursor renderer class track whether we're using the backend, rather than doing chain-up shenanigans.
2014-05-17 11:22:05 -04:00
return FALSE;
backends: Add a native cursor renderer
2014-04-22 15:15:11 -04:00
}
cursor-renderer: Rewrite HW cursors to be cleaner
2014-04-22 15:39:09 -04:00
backends: Allow multiple "SW" cursor overlays on the stage All the upper layers are prepared for multiple onscreen cursors, but this. All MetaCursorRenderers created would poke the same internal MetaOverlay in the stage. This will lead to multiple cursor renderers resorting to the "SW" rendering paths (as it can be seen with tablet support) to reuse the same overlay, thus leading to flickering when a different MetaCursorRenderer takes over the overlay. Fix this by allowing per-cursor-renderer overlays, their lifetime is attached to the cursor renderer, so is expected to be tear down if the relevant device (eg. tablet) disappears.
2016-05-02 07:49:13 -04:00
static void
meta_cursor_renderer_finalize (GObject *object)
{
MetaCursorRenderer *renderer = META_CURSOR_RENDERER (object);
MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
MetaBackend *backend = meta_get_backend ();
ClutterActor *stage = meta_backend_get_stage (backend);
if (priv->stage_overlay)
meta_stage_remove_cursor_overlay (META_STAGE (stage), priv->stage_overlay);
cursor-renderer: Add a cursor painted signal This signal allows interested parties to be notified of a new cursor frame being painted regardless of whether it's being painted by the backend directly or if it's a software rendered cursor frame handled by clutter. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-01-10 11:28:54 -05:00
clutter_threads_remove_repaint_func (priv->post_paint_func_id);
backends: Allow multiple "SW" cursor overlays on the stage All the upper layers are prepared for multiple onscreen cursors, but this. All MetaCursorRenderers created would poke the same internal MetaOverlay in the stage. This will lead to multiple cursor renderers resorting to the "SW" rendering paths (as it can be seen with tablet support) to reuse the same overlay, thus leading to flickering when a different MetaCursorRenderer takes over the overlay. Fix this by allowing per-cursor-renderer overlays, their lifetime is attached to the cursor renderer, so is expected to be tear down if the relevant device (eg. tablet) disappears.
2016-05-02 07:49:13 -04:00
G_OBJECT_CLASS (meta_cursor_renderer_parent_class)->finalize (object);
}
backends: Add a native cursor renderer
2014-04-22 15:15:11 -04:00
static void
meta_cursor_renderer_class_init (MetaCursorRendererClass *klass)
{
backends: Allow multiple "SW" cursor overlays on the stage All the upper layers are prepared for multiple onscreen cursors, but this. All MetaCursorRenderers created would poke the same internal MetaOverlay in the stage. This will lead to multiple cursor renderers resorting to the "SW" rendering paths (as it can be seen with tablet support) to reuse the same overlay, thus leading to flickering when a different MetaCursorRenderer takes over the overlay. Fix this by allowing per-cursor-renderer overlays, their lifetime is attached to the cursor renderer, so is expected to be tear down if the relevant device (eg. tablet) disappears.
2016-05-02 07:49:13 -04:00
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = meta_cursor_renderer_finalize;
backends: Add a native cursor renderer
2014-04-22 15:15:11 -04:00
klass->update_cursor = meta_cursor_renderer_real_update_cursor;
cursor-renderer: Add a cursor painted signal This signal allows interested parties to be notified of a new cursor frame being painted regardless of whether it's being painted by the backend directly or if it's a software rendered cursor frame handled by clutter. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-01-10 11:28:54 -05:00
signals[CURSOR_PAINTED] = g_signal_new ("cursor-painted",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
backends: Add a native cursor renderer
2014-04-22 15:15:11 -04:00
}
static void
meta_cursor_renderer_init (MetaCursorRenderer *renderer)
{
cursor-renderer: Add a cursor painted signal This signal allows interested parties to be notified of a new cursor frame being painted regardless of whether it's being painted by the backend directly or if it's a software rendered cursor frame handled by clutter. https://bugzilla.gnome.org/show_bug.cgi?id=749913
2016-01-10 11:28:54 -05:00
MetaCursorRendererPrivate *priv =
meta_cursor_renderer_get_instance_private (renderer);
priv->post_paint_func_id =
clutter_threads_add_repaint_func_full (CLUTTER_REPAINT_FLAGS_POST_PAINT,
meta_cursor_renderer_post_paint,
renderer,
NULL);
cursor-renderer: Rewrite HW cursors to be cleaner
2014-04-22 15:39:09 -04:00
}
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
ClutterRect
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
meta_cursor_renderer_calculate_rect (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
{
MetaCursorRendererPrivate *priv =
meta_cursor_renderer_get_instance_private (renderer);
CoglTexture *texture;
int hot_x, hot_y;
int width, height;
float texture_scale;
texture = meta_cursor_sprite_get_cogl_texture (cursor_sprite);
if (!texture)
backends: Fix ClutterRect initialisations With Clang, these initialisations were warning about missing brackets. Signed-off-by: Philip Withnall <withnall@endlessm.com> https://bugzilla.gnome.org/show_bug.cgi?id=791022
2017-11-30 07:59:08 -05:00
return (ClutterRect) CLUTTER_RECT_INIT_ZERO;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
meta_cursor_sprite_get_hotspot (cursor_sprite, &hot_x, &hot_y);
texture_scale = meta_cursor_sprite_get_texture_scale (cursor_sprite);
width = cogl_texture_get_width (texture);
height = cogl_texture_get_height (texture);
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
return (ClutterRect) {
.origin = {
.x = priv->current_x - (hot_x * texture_scale),
.y = priv->current_y - (hot_y * texture_scale)
},
.size = {
.width = width * texture_scale,
.height = height * texture_scale
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
};
}
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
static void
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
update_cursor (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
{
MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
cursor: Correct switching between fallback and backend cursors When switching from the stage cursor to the native cursor, we forgot to repaint the stage to get rid of the old cursor. Fix this by having the abstract cursor renderer class track whether we're using the backend, rather than doing chain-up shenanigans.
2014-05-17 11:22:05 -04:00
gboolean handled_by_backend;
gboolean should_redraw = FALSE;
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
if (cursor_sprite)
meta_cursor_sprite_prepare_at (cursor_sprite,
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
(int) priv->current_x,
(int) priv->current_y);
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
handled_by_backend =
META_CURSOR_RENDERER_GET_CLASS (renderer)->update_cursor (renderer,
cursor_sprite);
cursor: Correct switching between fallback and backend cursors When switching from the stage cursor to the native cursor, we forgot to repaint the stage to get rid of the old cursor. Fix this by having the abstract cursor renderer class track whether we're using the backend, rather than doing chain-up shenanigans.
2014-05-17 11:22:05 -04:00
if (handled_by_backend != priv->handled_by_backend)
{
priv->handled_by_backend = handled_by_backend;
should_redraw = TRUE;
}
if (!handled_by_backend)
should_redraw = TRUE;
if (should_redraw)
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
queue_redraw (renderer, cursor_sprite);
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
}
MetaCursorRenderer *
cursor-renderer: Remove the MetaScreen It's unused.
2014-04-22 14:27:38 -04:00
meta_cursor_renderer_new (void)
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
{
cursor-renderer: Remove the MetaScreen It's unused.
2014-04-22 14:27:38 -04:00
return g_object_new (META_TYPE_CURSOR_RENDERER, NULL);
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
}
void
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
meta_cursor_renderer_set_cursor (MetaCursorRenderer *renderer,
MetaCursorSprite *cursor_sprite)
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
{
MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
if (priv->displayed_cursor == cursor_sprite)
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
return;
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
priv->displayed_cursor = cursor_sprite;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
update_cursor (renderer, cursor_sprite);
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
}
backend: Add meta_cursor_renderer_force_update() There will be times where additional updates will be needed, such as animated cursors. We should update the texture and redraw in that case. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:36:05 -04:00
void
meta_cursor_renderer_force_update (MetaCursorRenderer *renderer)
{
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
MetaCursorRendererPrivate *priv =
meta_cursor_renderer_get_instance_private (renderer);
update_cursor (renderer, priv->displayed_cursor);
backend: Add meta_cursor_renderer_force_update() There will be times where additional updates will be needed, such as animated cursors. We should update the texture and redraw in that case. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:36:05 -04:00
}
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
void
meta_cursor_renderer_set_position (MetaCursorRenderer *renderer,
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
float x,
float y)
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
{
MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
g_assert (meta_is_wayland_compositor ());
priv->current_x = x;
priv->current_y = y;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
update_cursor (renderer, priv->displayed_cursor);
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
}
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
ClutterPoint
meta_cursor_renderer_get_position (MetaCursorRenderer *renderer)
{
MetaCursorRendererPrivate *priv =
meta_cursor_renderer_get_instance_private (renderer);
return (ClutterPoint) {
.x = priv->current_x,
.y = priv->current_y
};
}
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
MetaCursorSprite *
backends: Add a native cursor renderer
2014-04-22 15:15:11 -04:00
meta_cursor_renderer_get_cursor (MetaCursorRenderer *renderer)
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
{
backends: Add a native cursor renderer
2014-04-22 15:15:11 -04:00
MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
backends: Add a native cursor renderer
2014-04-22 15:15:11 -04:00
return priv->displayed_cursor;
Split out the code that renders the code into a MetaCursorRenderer Right now, this is the same exact same mess it's always been, but it will be fixed up soon with backend-specific renderers.
2014-04-21 18:05:59 -04:00
}
Reference in New Issue Copy Permalink