isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-11 22:10:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
8a43123765
mutter/src/backends/meta-stage.c

486 lines
12 KiB
C
Raw Normal View History

wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
/*
Rename MetaWaylandStage to MetaStage and put in compositor/
2014-04-22 18:46:57 +00:00
* Copyright (C) 2014 Red Hat
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
*
* 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.
Rename MetaWaylandStage to MetaStage and put in compositor/
2014-04-22 18:46:57 +00:00
*
* Written by:
* Jasper St. Pierre <jstpierre@mecheye.net>
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
*/
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 08:36:24 +00:00
#include "config.h"
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
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 08:36:24 +00:00
#include "backends/meta-stage-private.h"
wayland-stage: Cut down on dependencies
2014-04-22 00:49:38 +00:00
Introduce regional stage rendering Add support for drawing a stage using multiple framebuffers each making up one part of the stage. This works by the stage backend (ClutterStageWindow) providing a list of views which will be for splitting up the stage in different regions. A view layout, for now, is a set of rectangles. The stage window (i.e. stage "backend" will use this information when drawing a frame, using one framebuffer for each view. The scene graph is adapted to explictly take a view when painting the stage. It will use this view, its assigned framebuffer and layout to offset and clip the drawing accordingly. This effectively removes any notion of "stage framebuffer", since each stage now may consist of multiple framebuffers. Therefore, API involving this has been deprecated and made no-ops; namely clutter_stage_ensure_context(). Callers are now assumed to either always use a framebuffer reference explicitly, or push/pop the framebuffer of a given view where the code has not yet changed to use the explicit-buffer-using cogl API. Currently only the nested X11 backend supports this mode fully, and the per view framebuffers are all offscreen. Upon frame completion, it'll blit each view's framebuffer onto the onscreen framebuffer before swapping. Other backends (X11 CM and native/KMS) are adapted to manage a full-stage view. The X11 CM backend will continue to use this method, while the native/KMS backend will be adopted to use multiple view drawing. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-27 03:09:24 +00:00
#include "backends/meta-backend-private.h"
screen-cast: Track and always record cursors Always force-track the cursor position (so that the X11 backend can keep it up to date), and if the cursor wasn't part of the sampled framebuffer when reading pixels into CPU memory, draw it in an extra pass using cairo after the fact. The cairo based cursor painting only happens on the X11 backend, as we otherwise inhibit the hw cursor. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 09:43:44 +00:00
#include "backends/meta-cursor-tracker-private.h"
Introduce regional stage rendering Add support for drawing a stage using multiple framebuffers each making up one part of the stage. This works by the stage backend (ClutterStageWindow) providing a list of views which will be for splitting up the stage in different regions. A view layout, for now, is a set of rectangles. The stage window (i.e. stage "backend" will use this information when drawing a frame, using one framebuffer for each view. The scene graph is adapted to explictly take a view when painting the stage. It will use this view, its assigned framebuffer and layout to offset and clip the drawing accordingly. This effectively removes any notion of "stage framebuffer", since each stage now may consist of multiple framebuffers. Therefore, API involving this has been deprecated and made no-ops; namely clutter_stage_ensure_context(). Callers are now assumed to either always use a framebuffer reference explicitly, or push/pop the framebuffer of a given view where the code has not yet changed to use the explicit-buffer-using cogl API. Currently only the nested X11 backend supports this mode fully, and the per view framebuffers are all offscreen. Upon frame completion, it'll blit each view's framebuffer onto the onscreen framebuffer before swapping. Other backends (X11 CM and native/KMS) are adapted to manage a full-stage view. The X11 CM backend will continue to use this method, while the native/KMS backend will be adopted to use multiple view drawing. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-27 03:09:24 +00:00
#include "clutter/clutter-mutter.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 08:36:24 +00:00
#include "meta/meta-backend.h"
#include "meta/meta-monitor-manager.h"
#include "meta/util.h"
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
#define N_WATCH_MODES 4
backends/stage: Emit signal between painting actors and overlays Will be used by screen casting for embedding the cursor separately, or not including at all. https://gitlab.gnome.org/GNOME/mutter/merge_requests/357
2018-12-12 10:39:18 +00:00
enum
{
ACTORS_PAINTED,
N_SIGNALS
};
static guint signals[N_SIGNALS];
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
struct _MetaStageWatch
{
ClutterStageView *view;
MetaStageWatchFunc callback;
gpointer user_data;
};
backends/stage: Fix minor style issue https://gitlab.gnome.org/GNOME/mutter/merge_requests/357
2018-12-12 10:39:00 +00:00
struct _MetaOverlay
{
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
MetaStage *stage;
gboolean is_visible;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
CoglPipeline *pipeline;
CoglTexture *texture;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
graphene_rect_t current_rect;
graphene_rect_t previous_rect;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
gboolean previous_is_valid;
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 11:49:13 +00:00
};
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
struct _MetaStage
{
ClutterStage parent;
stage: Keep a pointer to the backend Will be used later. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:11:08 +00:00
MetaBackend *backend;
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
GPtrArray *watchers[N_WATCH_MODES];
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 11:49:13 +00:00
GList *overlays;
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
gboolean is_active;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
};
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
G_DEFINE_TYPE (MetaStage, meta_stage, CLUTTER_TYPE_STAGE);
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00: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 11:49:13 +00:00
static MetaOverlay *
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
meta_overlay_new (MetaStage *stage)
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
{
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
ClutterBackend *clutter_backend =
meta_backend_get_clutter_backend (stage->backend);
CoglContext *ctx = clutter_backend_get_cogl_context (clutter_backend);
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 11:49:13 +00:00
MetaOverlay *overlay;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
src: Stop using GSlice It has been inofficially deprecated for years, is known to cause issues with valgrind and potentially hides memory corruption. Lets stop using it. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1512>
2020-10-19 17:57:57 +00:00
overlay = g_new0 (MetaOverlay, 1);
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
overlay->stage = stage;
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
overlay->pipeline = cogl_pipeline_new (ctx);
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 11:49:13 +00:00
return overlay;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
}
static void
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
meta_overlay_free (MetaOverlay *overlay)
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
{
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
if (overlay->pipeline)
cogl_object_unref (overlay->pipeline);
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 11:49:13 +00:00
src: Stop using GSlice It has been inofficially deprecated for years, is known to cause issues with valgrind and potentially hides memory corruption. Lets stop using it. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1512>
2020-10-19 17:57:57 +00:00
g_free (overlay);
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
}
static void
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
meta_overlay_set (MetaOverlay *overlay,
CoglTexture *texture,
graphene_rect_t *rect)
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
{
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
if (overlay->texture != texture)
{
overlay->texture = texture;
if (texture)
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
cogl_pipeline_set_layer_texture (overlay->pipeline, 0, texture);
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
else
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
cogl_pipeline_set_layer_texture (overlay->pipeline, 0, NULL);
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
}
overlay->current_rect = *rect;
}
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
static void
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
meta_overlay_paint (MetaOverlay *overlay,
ClutterPaintContext *paint_context)
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
{
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
CoglFramebuffer *framebuffer;
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
if (!overlay->texture)
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
return;
screen-cast: Track and always record cursors Always force-track the cursor position (so that the X11 backend can keep it up to date), and if the cursor wasn't part of the sampled framebuffer when reading pixels into CPU memory, draw it in an extra pass using cairo after the fact. The cairo based cursor painting only happens on the X11 backend, as we otherwise inhibit the hw cursor. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 09:43:44 +00:00
if (!overlay->is_visible &&
!(clutter_paint_context_get_paint_flags (paint_context) &
CLUTTER_PAINT_FLAG_FORCE_CURSORS))
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
return;
stage: Refine our assertions for overlays in MetaStage We indeed call this function if we're not an X11 compositor, but in this case we're simply calling it to say that we have no cursor overlay. Make sure not to assert fail in this case.
2014-08-21 22:03:03 +00:00
clutter, core: Stop using the Cogl framebuffer stack The Cogl framebuffer stack is going away; replace all its uses by the framebuffer stack carried by the paint context. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-22 10:41:04 +00:00
framebuffer = clutter_paint_context_get_framebuffer (paint_context);
cogl_framebuffer_draw_rectangle (framebuffer,
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
overlay->pipeline,
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 14:13:16 +00:00
overlay->current_rect.origin.x,
overlay->current_rect.origin.y,
(overlay->current_rect.origin.x +
overlay->current_rect.size.width),
(overlay->current_rect.origin.y +
overlay->current_rect.size.height));
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
if (!graphene_rect_equal (&overlay->previous_rect, &overlay->current_rect))
stage: Queue redraw previous Rect only if it has changed No need to queue redraw the same area multiple times, so we can avoid the computation involved with it. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2019-02-28 22:02:59 +00:00
{
overlay->previous_rect = overlay->current_rect;
overlay->previous_is_valid = TRUE;
}
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
}
static void
meta_stage_finalize (GObject *object)
{
MetaStage *stage = META_STAGE (object);
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
GList *l;
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
int i;
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
l = stage->overlays;
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 11:49:13 +00:00
while (l)
{
meta_overlay_free (l->data);
l = g_list_delete_link (l, l);
}
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
for (i = 0; i < N_WATCH_MODES; i++)
g_clear_pointer (&stage->watchers[i], g_ptr_array_unref);
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 11:49:13 +00:00
G_OBJECT_CLASS (meta_stage_parent_class)->finalize (object);
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
}
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
static void
notify_watchers_for_mode (MetaStage *stage,
ClutterStageView *view,
stage: Pass paint context in phase callbacks If there is a paint context available (i.e. for the phases that are during the actual stage paint), pass it along the callbacks, so that the callback implementations can change their operation depending on the paint context state. This also means we can get the current view from the paint context, instead of the temporarily used field in the instance struct. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-04-20 20:24:55 +00:00
ClutterPaintContext *paint_context,
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
MetaStageWatchPhase watch_phase)
{
GPtrArray *watchers;
int i;
watchers = stage->watchers[watch_phase];
for (i = 0; i < watchers->len; i++)
{
MetaStageWatch *watch = g_ptr_array_index (watchers, i);
if (watch->view && view != watch->view)
continue;
stage: Pass paint context in phase callbacks If there is a paint context available (i.e. for the phases that are during the actual stage paint), pass it along the callbacks, so that the callback implementations can change their operation depending on the paint context state. This also means we can get the current view from the paint context, instead of the temporarily used field in the instance struct. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-04-20 20:24:55 +00:00
watch->callback (stage, view, paint_context, watch->user_data);
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
}
}
meta/stage: Process BEFORE_PAINT watchers at ClutterStage.before_paint This way, watches can properly get notified about before-paint without having to connect to the corresponding signal. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1421
2020-08-31 13:30:06 +00:00
static void
meta_stage_before_paint (ClutterStage *stage,
ClutterStageView *view)
{
MetaStage *meta_stage = META_STAGE (stage);
notify_watchers_for_mode (meta_stage, view, NULL,
META_STAGE_WATCH_BEFORE_PAINT);
}
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
static void
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
meta_stage_paint (ClutterActor *actor,
ClutterPaintContext *paint_context)
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
{
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
MetaStage *stage = META_STAGE (actor);
stage: Pass paint context in phase callbacks If there is a paint context available (i.e. for the phases that are during the actual stage paint), pass it along the callbacks, so that the callback implementations can change their operation depending on the paint context state. This also means we can get the current view from the paint context, instead of the temporarily used field in the instance struct. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-04-20 20:24:55 +00:00
ClutterStageView *view;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
clutter: Introduce paint contexts When painting, actors rely on semi global state tracked by the state to get various things needed for painting, such as the current draw framebuffer. Having state hidden in such ways can be very deceiving as it's hard to follow changes spread out, and adding more and more state that should be tracked during a paint gets annoying as they will not change in isolation but one by one in their own places. To do this better, introduce a paint context that is passed along in paint calls that contains the necessary state needed during painting. The paint context implements a framebuffer stack just as Cogl works, which is currently needed for offscreen rendering used by clutter. The same context is passed around for paint nodes, contents and effects as well. In this commit, the context is only introduced, but not used. It aims to replace the Cogl framebuffer stack, and will allow actors to know what view it is currently painted on. https://gitlab.gnome.org/GNOME/mutter/merge_requests/935
2019-11-13 21:21:58 +00:00
CLUTTER_ACTOR_CLASS (meta_stage_parent_class)->paint (actor, paint_context);
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
stage: Pass paint context in phase callbacks If there is a paint context available (i.e. for the phases that are during the actual stage paint), pass it along the callbacks, so that the callback implementations can change their operation depending on the paint context state. This also means we can get the current view from the paint context, instead of the temporarily used field in the instance struct. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-04-20 20:24:55 +00:00
view = clutter_paint_context_get_stage_view (paint_context);
stage: Only invoke paint phase callbacks when painting views These phase callbacks are not intended to be inovked when something secondary is painting the stage, such as a screen cast stream, or similar. Thus, only invoke the callbacks when there is a view associated with the paint context, which will not be the case for offscreen painting. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-04-20 20:39:08 +00:00
if (view)
{
notify_watchers_for_mode (stage, view, paint_context,
META_STAGE_WATCH_AFTER_ACTOR_PAINT);
}
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
backends/stage: Emit signal between painting actors and overlays Will be used by screen casting for embedding the cursor separately, or not including at all. https://gitlab.gnome.org/GNOME/mutter/merge_requests/357
2018-12-12 10:39:18 +00:00
g_signal_emit (stage, signals[ACTORS_PAINTED], 0);
screen-cast: Track and always record cursors Always force-track the cursor position (so that the X11 backend can keep it up to date), and if the cursor wasn't part of the sampled framebuffer when reading pixels into CPU memory, draw it in an extra pass using cairo after the fact. The cairo based cursor painting only happens on the X11 backend, as we otherwise inhibit the hw cursor. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 09:43:44 +00:00
if ((clutter_paint_context_get_paint_flags (paint_context) &
CLUTTER_PAINT_FLAG_FORCE_CURSORS))
{
MetaCursorTracker *cursor_tracker =
meta_backend_get_cursor_tracker (stage->backend);
meta_cursor_tracker_track_position (cursor_tracker);
}
clutter/paint-context: Add 'no-cursors' paint flag Will be used by the stage to not paint the overlays. We skip all overlays since overlays are only ever used for pointer cursors when the hardware cursors cannot or should not be used. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-04-20 20:41:12 +00:00
if (!(clutter_paint_context_get_paint_flags (paint_context) &
CLUTTER_PAINT_FLAG_NO_CURSORS))
stage: Use g_list_foreach instead of manual for loop https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:12:13 +00:00
g_list_foreach (stage->overlays, (GFunc) meta_overlay_paint, paint_context);
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
screen-cast: Track and always record cursors Always force-track the cursor position (so that the X11 backend can keep it up to date), and if the cursor wasn't part of the sampled framebuffer when reading pixels into CPU memory, draw it in an extra pass using cairo after the fact. The cairo based cursor painting only happens on the X11 backend, as we otherwise inhibit the hw cursor. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 09:43:44 +00:00
if ((clutter_paint_context_get_paint_flags (paint_context) &
CLUTTER_PAINT_FLAG_FORCE_CURSORS))
{
MetaCursorTracker *cursor_tracker =
meta_backend_get_cursor_tracker (stage->backend);
meta_cursor_tracker_untrack_position (cursor_tracker);
}
stage: Only invoke paint phase callbacks when painting views These phase callbacks are not intended to be inovked when something secondary is painting the stage, such as a screen cast stream, or similar. Thus, only invoke the callbacks when there is a view associated with the paint context, which will not be the case for offscreen painting. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-04-20 20:39:08 +00:00
if (view)
{
notify_watchers_for_mode (stage, view, paint_context,
META_STAGE_WATCH_AFTER_OVERLAY_PAINT);
}
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
}
static void
clutter/stage: Pass redraw clip instead of extents when painting view That's the struct we have ready, the callee can just call cairo_region_get_extents() if it only cares about the extents rectangle. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1042
2020-02-06 08:00:12 +00:00
meta_stage_paint_view (ClutterStage *stage,
ClutterStageView *view,
const cairo_region_t *redraw_clip)
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
{
MetaStage *meta_stage = META_STAGE (stage);
clutter/stage: Pass redraw clip instead of extents when painting view That's the struct we have ready, the callee can just call cairo_region_get_extents() if it only cares about the extents rectangle. https://gitlab.gnome.org/GNOME/mutter/merge_requests/1042
2020-02-06 08:00:12 +00:00
CLUTTER_STAGE_CLASS (meta_stage_parent_class)->paint_view (stage, view,
redraw_clip);
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
stage: Pass paint context in phase callbacks If there is a paint context available (i.e. for the phases that are during the actual stage paint), pass it along the callbacks, so that the callback implementations can change their operation depending on the paint context state. This also means we can get the current view from the paint context, instead of the temporarily used field in the instance struct. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-04-20 20:24:55 +00:00
notify_watchers_for_mode (meta_stage, view, NULL,
META_STAGE_WATCH_AFTER_PAINT);
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
}
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
static void
meta_stage_activate (ClutterStage *actor)
{
MetaStage *stage = META_STAGE (actor);
CLUTTER_STAGE_CLASS (meta_stage_parent_class)->activate (actor);
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
stage->is_active = TRUE;
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
}
static void
meta_stage_deactivate (ClutterStage *actor)
{
MetaStage *stage = META_STAGE (actor);
CLUTTER_STAGE_CLASS (meta_stage_parent_class)->deactivate (actor);
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
stage->is_active = FALSE;
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
}
renderer-native: Fake page flipping slower when power saving We rely on the frame clock to compress input events, thus if the frame clock stops, input events are not dispatched. At the same time, there is no reason to redraw at a full frame rate, as nothing will be presented anyway, so slow down to 10Hz (compared to the most common 60Hz). Note that we'll only actually reach 10Hz if there is an active animation being displayed, which won't happen e.g. if there is a screen shield in the way. https://gitlab.gnome.org/GNOME/mutter/merge_requests/506
2019-03-25 09:24:46 +00:00
static void
on_power_save_changed (MetaMonitorManager *monitor_manager,
MetaStage *stage)
{
if (meta_monitor_manager_get_power_save_mode (monitor_manager) ==
META_POWER_SAVE_ON)
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
}
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
static void
Rename MetaWaylandStage to MetaStage and put in compositor/
2014-04-22 18:46:57 +00:00
meta_stage_class_init (MetaStageClass *klass)
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
{
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
ClutterStageClass *stage_class = (ClutterStageClass *) klass;
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
ClutterActorClass *actor_class = (ClutterActorClass *) klass;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
GObjectClass *object_class = (GObjectClass *) klass;
object_class->finalize = meta_stage_finalize;
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
Rename MetaWaylandStage to MetaStage and put in compositor/
2014-04-22 18:46:57 +00:00
actor_class->paint = meta_stage_paint;
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
stage_class->activate = meta_stage_activate;
stage_class->deactivate = meta_stage_deactivate;
meta/stage: Process BEFORE_PAINT watchers at ClutterStage.before_paint This way, watches can properly get notified about before-paint without having to connect to the corresponding signal. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1421
2020-08-31 13:30:06 +00:00
stage_class->before_paint = meta_stage_before_paint;
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
stage_class->paint_view = meta_stage_paint_view;
backends/stage: Emit signal between painting actors and overlays Will be used by screen casting for embedding the cursor separately, or not including at all. https://gitlab.gnome.org/GNOME/mutter/merge_requests/357
2018-12-12 10:39:18 +00:00
signals[ACTORS_PAINTED] = g_signal_new ("actors-painted",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 0);
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
}
static void
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
meta_stage_init (MetaStage *stage)
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
{
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
int i;
for (i = 0; i < N_WATCH_MODES; i++)
stage->watchers[i] = g_ptr_array_new_with_free_func (g_free);
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
}
ClutterActor *
renderer-native: Fake page flipping slower when power saving We rely on the frame clock to compress input events, thus if the frame clock stops, input events are not dispatched. At the same time, there is no reason to redraw at a full frame rate, as nothing will be presented anyway, so slow down to 10Hz (compared to the most common 60Hz). Note that we'll only actually reach 10Hz if there is an active animation being displayed, which won't happen e.g. if there is a screen shield in the way. https://gitlab.gnome.org/GNOME/mutter/merge_requests/506
2019-03-25 09:24:46 +00:00
meta_stage_new (MetaBackend *backend)
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
{
renderer-native: Fake page flipping slower when power saving We rely on the frame clock to compress input events, thus if the frame clock stops, input events are not dispatched. At the same time, there is no reason to redraw at a full frame rate, as nothing will be presented anyway, so slow down to 10Hz (compared to the most common 60Hz). Note that we'll only actually reach 10Hz if there is an active animation being displayed, which won't happen e.g. if there is a screen shield in the way. https://gitlab.gnome.org/GNOME/mutter/merge_requests/506
2019-03-25 09:24:46 +00:00
MetaStage *stage;
MetaMonitorManager *monitor_manager;
clutter/stage: Remove hide/show cursor API This removes it from the stage window API too. It's managed by the mutter backends, so we don't need the stage window to do it as well. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1175
2020-04-03 11:56:43 +00:00
stage = g_object_new (META_TYPE_STAGE, NULL);
stage: Keep a pointer to the backend Will be used later. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:11:08 +00:00
stage->backend = backend;
renderer-native: Fake page flipping slower when power saving We rely on the frame clock to compress input events, thus if the frame clock stops, input events are not dispatched. At the same time, there is no reason to redraw at a full frame rate, as nothing will be presented anyway, so slow down to 10Hz (compared to the most common 60Hz). Note that we'll only actually reach 10Hz if there is an active animation being displayed, which won't happen e.g. if there is a screen shield in the way. https://gitlab.gnome.org/GNOME/mutter/merge_requests/506
2019-03-25 09:24:46 +00:00
monitor_manager = meta_backend_get_monitor_manager (backend);
g_signal_connect (monitor_manager, "power-save-mode-changed",
G_CALLBACK (on_power_save_changed),
stage);
return CLUTTER_ACTOR (stage);
wayland: Add an actor for the cursor When running Mutter under Cogl's KMS backend no cursor will be provided so instead this makes it so the cursor will be painted as a CoglTexture that gets moved in response to mouse motion events. The painting is done in a subclass of ClutterStage so that we can guarantee that the cursor will be painted on top of everything else. This patch adds support for the set_cursor method on the pointer interface so that clients can change the cursor image. The set_pointer method sets a surface and a hotspot position to use for the cursor image. The surface's buffer is converted to a CoglTexture and attached to a pipeline to paint directly via Cogl. If a new buffer is attached to the surface the image will be updated. The cursor reverts back to the default image whenever to the pointer focus is moved off of any surface. The image for the pointer is taken from X. It gets installed into a fixed data location for mutter.
2012-01-18 23:03:23 +00:00
}
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
stage: Add utility function to queue draw a ClutterRect Remove duplicated code to clamp to pixel https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2019-02-28 21:48:46 +00:00
static void
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
queue_redraw_clutter_rect (MetaStage *stage,
MetaOverlay *overlay,
graphene_rect_t *rect)
stage: Add utility function to queue draw a ClutterRect Remove duplicated code to clamp to pixel https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2019-02-28 21:48:46 +00:00
{
cairo_rectangle_int_t clip = {
.x = floorf (rect->origin.x),
.y = floorf (rect->origin.y),
.width = ceilf (rect->size.width),
.height = ceilf (rect->size.height)
};
stage: Clamp to pixel the redraw clip taking care of the floored coords When we floor the quad coordinates then we've also to enlarge the quad by the difference between the floored value and the actual coordinate, otherwise we'd end up in a smaller quad. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2019-02-28 21:50:50 +00:00
/* Since we're flooring the coordinates, we need to enlarge the clip by the
* difference between the actual coordinate and the floored value */
clip.width += ceilf (rect->origin.x - clip.x) * 2;
clip.height += ceilf (rect->origin.y - clip.y) * 2;
stage: Add utility function to queue draw a ClutterRect Remove duplicated code to clamp to pixel https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2019-02-28 21:48:46 +00:00
clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stage), &clip);
}
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
static void
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
queue_redraw_for_overlay (MetaStage *stage,
MetaOverlay *overlay)
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
{
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
/* Clear the location the overlay was at before, if we need to. */
if (overlay->previous_is_valid)
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
{
stage: Add utility function to queue draw a ClutterRect Remove duplicated code to clamp to pixel https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2019-02-28 21:48:46 +00:00
queue_redraw_clutter_rect (stage, overlay, &overlay->previous_rect);
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
overlay->previous_is_valid = FALSE;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
}
stage: Refactor the cursor drawing code into a generic "overlay" system This isn't really anything but a really small actor system. This will be used for DND cursors as well.
2014-08-21 18:47:39 +00:00
/* Draw the overlay at the new position */
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
if (overlay->is_visible && overlay->texture)
stage: Add utility function to queue draw a ClutterRect Remove duplicated code to clamp to pixel https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2019-02-28 21:48:46 +00:00
queue_redraw_clutter_rect (stage, overlay, &overlay->current_rect);
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00: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 11:49:13 +00:00
MetaOverlay *
meta_stage_create_cursor_overlay (MetaStage *stage)
{
MetaOverlay *overlay;
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
overlay = meta_overlay_new (stage);
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
stage->overlays = g_list_prepend (stage->overlays, overlay);
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 11:49:13 +00:00
return overlay;
}
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
void
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 11:49:13 +00:00
meta_stage_remove_cursor_overlay (MetaStage *stage,
MetaOverlay *overlay)
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00: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 11:49:13 +00:00
GList *link;
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
link = g_list_find (stage->overlays, overlay);
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 11:49:13 +00:00
if (!link)
return;
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
stage->overlays = g_list_delete_link (stage->overlays, link);
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 11:49:13 +00:00
meta_overlay_free (overlay);
}
void
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 15:23:04 +00:00
meta_stage_update_cursor_overlay (MetaStage *stage,
MetaOverlay *overlay,
CoglTexture *texture,
graphene_rect_t *rect)
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 11:49:13 +00:00
{
meta_overlay_set (overlay, texture, rect);
queue_redraw_for_overlay (stage, overlay);
Move the painting of the cursor on the stage out of the cursor renderer This logic is now well-contained the stage. This is the start of us moving to backend-specific cursor renderers.
2014-04-22 19:06:42 +00:00
}
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
cursor-renderer: Always keep the cursor overlay on the stage Only when the cursor isn't handled by the backend is the overlay made visible. This is intended to be used when painting the stage to an offscreen using clutter_stage_paint_to_(frame)buffer() in a way where the cursor is always included. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1391
2020-07-29 08:32:58 +00:00
void
meta_overlay_set_visible (MetaOverlay *overlay,
gboolean is_visible)
{
if (overlay->is_visible == is_visible)
return;
overlay->is_visible = is_visible;
queue_redraw_for_overlay (overlay->stage, overlay);
}
gboolean
meta_overlay_is_visible (MetaOverlay *overlay)
{
return overlay->is_visible;
}
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
void
meta_stage_set_active (MetaStage *stage,
gboolean is_active)
{
backends/stage: Remove MetaStagePrivate The empty MetaStage was in meta-stage-private.h for no reason, so lets move it to the C file. This makes it pointless to have a private instance struct, so just move the fields to the private struct _MetaStage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-07-12 12:59:18 +00:00
if (stage->is_active == is_active)
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
return;
if (is_active)
clutter: Simplify stage state management Making this an event is overly convoluted, accounting that we emit the event, then convert it to a ClutterStage signal, then its only consumer (a11y) sets the active ATK state. Take the event out of the equation, unify activation/deactivation of the stage in MetaStage, and use it from the X11 backend too. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1623>
2020-12-08 02:38:14 +00:00
g_signal_emit_by_name (CLUTTER_STAGE (stage), "activate");
else
g_signal_emit_by_name (CLUTTER_STAGE (stage), "deactivate");
wayland: manually activate/deactivate stage when taking/dropping grab clutter currently never emits activated or deactivated signals on the stage object when using the EGL backend. Since the stage never gets activated, accessibility tools, like orca, don't work. This commit makes mutter take on the responsibility, by tracking when the stage gains/loses focus, and then synthesizing stage CLUTTER_STAGE_STATE_ACTIVATED state events. A limitation of this approach is that clutter's own notion of the stage activeness won't reflect mutter's notion of the stage activeness. This isn't a problem, in practice, and can be addressed in the medium-term after making changes to clutter. https://bugzilla.gnome.org/show_bug.cgi?id=746670
2015-03-24 16:40:10 +00:00
}
stage: Introduce MetaStageWatch and family MetaStageWatch, watch modes and the watch function are part of the new stage view watching API. It's design does not rely on signals on purpose; the number of signals that would be emitted would be too high, and would impact performance. MetaStageWatch is an opaque structure outside of MetaStage. This will be used by the screencast code to monitor a single view, which has a one-to-one relatioship to logical monitors. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-18 00:43:05 +00:00
MetaStageWatch *
meta_stage_watch_view (MetaStage *stage,
ClutterStageView *view,
MetaStageWatchPhase watch_phase,
MetaStageWatchFunc callback,
gpointer user_data)
{
MetaStageWatch *watch;
GPtrArray *watchers;
watch = g_new0 (MetaStageWatch, 1);
watch->view = view;
watch->callback = callback;
watch->user_data = user_data;
watchers = stage->watchers[watch_phase];
g_ptr_array_add (watchers, watch);
return watch;
}
void
meta_stage_remove_watch (MetaStage *stage,
MetaStageWatch *watch)
{
GPtrArray *watchers;
gboolean removed = FALSE;
int i;
for (i = 0; i < N_WATCH_MODES; i++)
{
watchers = stage->watchers[i];
removed = g_ptr_array_remove_fast (watchers, watch);
if (removed)
break;
}
g_assert (removed);
}
Reference in New Issue Copy Permalink