isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-23 16:40:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
50ff9d4c71
mutter/src/backends/meta-cursor.c

383 lines
10 KiB
C
Raw Normal View History

cursor-tracker: Start moving some code to a new file I want the MetaCursorTracker to mostly be about retrieving cursor information. Start moving the code that loads cursor images to a new file, MetaCursor. Eventually, MetaCursorTracker's APIs will all take MetaCursorReferences, and we can have a clean backend split here.
2014-03-31 14:08:14 -04:00
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright 2013 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*
* Author: Giovanni Campagna <gcampagn@redhat.com>
*/
#include "config.h"
backends: Get rid of meta-cursor-private.h There is nothing special about the private API which only consists of getters for renderer specific backing buffer. Lets them to the regular .h file and treat them as part of the normal API. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:41:12 -04:00
#include "meta-cursor.h"
cursor-tracker: Start moving some code to a new file I want the MetaCursorTracker to mostly be about retrieving cursor information. Start moving the code that loads cursor images to a new file, MetaCursor. Eventually, MetaCursorTracker's APIs will all take MetaCursorReferences, and we can have a clean backend split here.
2014-03-31 14:08:14 -04:00
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
#include <meta/errors.h>
#include "display-private.h"
#include "screen-private.h"
backends: Make MetaBackend available to introspection This moves meta-backend.h under meta/ and, for now, just exposes to introspection the methods that we actually need in gnome-shell. https://bugzilla.gnome.org/show_bug.cgi?id=734301
2014-08-05 08:11:59 -04:00
#include "meta-backend-private.h"
Make the native backend build-optional
2014-05-29 12:11:26 -04:00
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
#include <string.h>
#include <X11/cursorfont.h>
#include <X11/extensions/Xfixes.h>
#include <X11/Xcursor/Xcursor.h>
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
enum {
PREPARE_AT,
backends: Add MetaCursorSprite::texture-changed signal As wayland implements the cursor role, it consists of a persistent MetaCursorSprite that gets the backing texture changed. This is inconvenient for the places using MetaCursorTracker to track cursor changes, as they actually track MetaCursorSprites. This signal will be used to trigger emission of MetaCursorTracker::cursor-changed, which will make users able to update accordingly. https://bugzilla.gnome.org/show_bug.cgi?id=754806
2017-11-16 13:16:54 -05:00
TEXTURE_CHANGED,
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
backends: Get rid of meta-cursor-private.h There is nothing special about the private API which only consists of getters for renderer specific backing buffer. Lets them to the regular .h file and treat them as part of the normal API. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:41:12 -04:00
struct _MetaCursorSprite
{
GObject parent;
MetaCursor cursor;
MetaCursorSprite: Squash MetaCurorImage into MetaCursorSprite It fills little purpose on separating into a MetaCursorImage struct, so lets squash in the three fields into the MetaCursorSprite object. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-16 23:56:42 -04:00
CoglTexture2D *texture;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
float texture_scale;
MetaCursorSprite: Squash MetaCurorImage into MetaCursorSprite It fills little purpose on separating into a MetaCursorImage struct, so lets squash in the three fields into the MetaCursorSprite object. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-16 23:56:42 -04:00
int hot_x, hot_y;
backends: Get rid of meta-cursor-private.h There is nothing special about the private API which only consists of getters for renderer specific backing buffer. Lets them to the regular .h file and treat them as part of the normal API. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:41:12 -04:00
int current_frame;
XcursorImages *xcursor_images;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
int theme_scale;
gboolean theme_dirty;
backends: Get rid of meta-cursor-private.h There is nothing special about the private API which only consists of getters for renderer specific backing buffer. Lets them to the regular .h file and treat them as part of the normal API. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:41:12 -04:00
};
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
G_DEFINE_TYPE (MetaCursorSprite, meta_cursor_sprite, G_TYPE_OBJECT)
cursor-tracker: Start moving some code to a new file I want the MetaCursorTracker to mostly be about retrieving cursor information. Start moving the code that loads cursor images to a new file, MetaCursor. Eventually, MetaCursorTracker's APIs will all take MetaCursorReferences, and we can have a clean backend split here.
2014-03-31 14:08:14 -04:00
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
static const char *
translate_meta_cursor (MetaCursor cursor)
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
{
switch (cursor)
{
case META_CURSOR_DEFAULT:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "left_ptr";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_NORTH_RESIZE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "top_side";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_SOUTH_RESIZE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "bottom_side";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_WEST_RESIZE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "left_side";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_EAST_RESIZE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "right_side";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_SE_RESIZE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "bottom_right_corner";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_SW_RESIZE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "bottom_left_corner";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_NE_RESIZE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "top_right_corner";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_NW_RESIZE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "top_left_corner";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_MOVE_OR_RESIZE_WINDOW:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "fleur";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_BUSY:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "watch";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_DND_IN_DRAG:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "dnd-none";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_DND_MOVE:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "dnd-move";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_DND_COPY:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "dnd-copy";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_DND_UNSUPPORTED_TARGET:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "dnd-none";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_POINTING_HAND:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "hand2";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_CROSSHAIR:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "crosshair";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
case META_CURSOR_IBEAM:
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
return "xterm";
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
default:
break;
}
cursor: Always use names for cursors Rather than sometimes using names and sometimes using glyphs.
2014-04-22 11:53:31 -04:00
g_assert_not_reached ();
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
}
Cursor
cursor: Make load_cursor_on_server public
2014-04-23 10:41:09 -04:00
meta_cursor_create_x_cursor (Display *xdisplay,
MetaCursor cursor)
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
{
cursor: Make load_cursor_on_server public
2014-04-23 10:41:09 -04:00
return XcursorLibraryLoadCursor (xdisplay, translate_meta_cursor (cursor));
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
}
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
static XcursorImages *
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
load_cursor_on_client (MetaCursor cursor, int scale)
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
{
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
return XcursorLibraryLoadImages (translate_meta_cursor (cursor),
meta_prefs_get_cursor_theme (),
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
meta_prefs_get_cursor_size () * scale);
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
}
cursor: Split out code that loads an image into a GBM buffer
2014-03-31 17:50:15 -04:00
static void
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
meta_cursor_sprite_load_from_xcursor_image (MetaCursorSprite *self,
XcursorImage *xc_image)
cursor: Retrieve the GBM device from the MetaBackend Not the MetaCursorTracker.
2014-04-22 15:23:45 -04:00
{
MetaBackend *meta_backend = meta_get_backend ();
MetaCursorRenderer *renderer = meta_backend_get_cursor_renderer (meta_backend);
Support for hardware cursor sizes other than 64x64 on wayland Use the new DRM capabilities to figure out the correct cursor size, and make sure that matches instead of hardcoding 64x64. This fixes incorrect rendering on some newer AMD cards that support 256x256 cursors. Based heavily on a patch by: Alvaro Fernando García <alvarofernandogarcia@gmail.com>
2014-09-24 17:40:09 -04:00
uint width, height, rowstride;
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
CoglPixelFormat cogl_format;
ClutterBackend *clutter_backend;
CoglContext *cogl_context;
Use correct cogl object types Use the correct pointer types for cogl objects. This avoids warnings when including the cogl headers doesn't result in all the cogl types being typedefs to void. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-07 10:21:24 -04:00
CoglTexture2D *texture;
Do not skip CoglError parameters While CoglError is a define to GError, it doesn't follow the convention of ignoring errors when NULL is passed, but rather treats the error as fatal :-( That's clearly unwanted for a compositor, so make sure to always pass an error parameter where a runtime error is possible (i.e. any CoglError that is not a malformed blend string). https://bugzilla.gnome.org/show_bug.cgi?id=765058
2016-04-14 09:30:31 -04:00
CoglError *error = NULL;
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
MetaCursorSprite: Squash MetaCurorImage into MetaCursorSprite It fills little purpose on separating into a MetaCursorImage struct, so lets squash in the three fields into the MetaCursorSprite object. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-16 23:56:42 -04:00
g_assert (self->texture == NULL);
cursor: Refactor code to load cursor images out We're going to make MetaCursorReference specialized and per-backend soon.
2014-03-31 17:13:03 -04:00
width = xc_image->width;
height = xc_image->height;
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
rowstride = width * 4;
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
cogl_format = COGL_PIXEL_FORMAT_BGRA_8888;
#else
cogl_format = COGL_PIXEL_FORMAT_ARGB_8888;
#endif
clutter_backend = clutter_get_default_backend ();
cogl_context = clutter_backend_get_cogl_context (clutter_backend);
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
texture = cogl_texture_2d_new_from_data (cogl_context,
width, height,
cogl_format,
rowstride,
(uint8_t *) xc_image->pixels,
Do not skip CoglError parameters While CoglError is a define to GError, it doesn't follow the convention of ignoring errors when NULL is passed, but rather treats the error as fatal :-( That's clearly unwanted for a compositor, so make sure to always pass an error parameter where a runtime error is possible (i.e. any CoglError that is not a malformed blend string). https://bugzilla.gnome.org/show_bug.cgi?id=765058
2016-04-14 09:30:31 -04:00
&error);
if (error)
{
meta_warning ("Failed to allocate cursor texture: %s\n", error->message);
cogl_error_free (error);
}
Use correct cogl object types Use the correct pointer types for cogl objects. This avoids warnings when including the cogl headers doesn't result in all the cogl types being typedefs to void. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-07 10:21:24 -04:00
meta_cursor_sprite_set_texture (self, COGL_TEXTURE (texture),
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
xc_image->xhot, xc_image->yhot);
Do not try to unref NULL CoglObjects https://bugzilla.gnome.org/show_bug.cgi?id=765058
2016-04-14 10:21:35 -04:00
if (texture)
cogl_object_unref (texture);
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
meta_cursor_renderer_realize_cursor_from_xcursor (renderer, self, xc_image);
cursor: Refactor out code that loads from XcursorImage
2014-03-31 16:09:32 -04:00
}
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
static XcursorImage *
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
meta_cursor_sprite_get_current_frame_image (MetaCursorSprite *self)
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
{
return self->xcursor_images->images[self->current_frame];
}
void
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
meta_cursor_sprite_tick_frame (MetaCursorSprite *self)
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
{
XcursorImage *image;
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
if (!meta_cursor_sprite_is_animated (self))
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
return;
self->current_frame++;
if (self->current_frame >= self->xcursor_images->nimage)
self->current_frame = 0;
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
image = meta_cursor_sprite_get_current_frame_image (self);
MetaCursorSprite: Squash MetaCurorImage into MetaCursorSprite It fills little purpose on separating into a MetaCursorImage struct, so lets squash in the three fields into the MetaCursorSprite object. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-16 23:56:42 -04:00
g_clear_pointer (&self->texture, cogl_object_unref);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
meta_cursor_sprite_load_from_xcursor_image (self, image);
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
}
guint
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
meta_cursor_sprite_get_current_frame_time (MetaCursorSprite *self)
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
{
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
if (!meta_cursor_sprite_is_animated (self))
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
return 0;
return self->xcursor_images->images[self->current_frame]->delay;
}
gboolean
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
meta_cursor_sprite_is_animated (MetaCursorSprite *self)
backend: Store XcursorImages for theme cursors There's a chance the icon will be animated, so store the XcursorImages instead of the individual XcursorImage, and handle that as a nimages=1 special case. API to "tick" a cursor animation, and retrieve current frame timing information has been added. https://bugzilla.gnome.org/show_bug.cgi?id=752342
2015-07-13 14:32:42 -04:00
{
return (self->xcursor_images &&
self->xcursor_images->nimage > 1);
}
Rename MetaCursorReference to MetaCursorSprite It isn't really a reference to a MetaCursor enum, but a reference counted cursor sprite, and enum value. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-09 23:23:00 -04:00
MetaCursorSprite *
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
meta_cursor_sprite_new (void)
{
return g_object_new (META_TYPE_CURSOR_SPRITE, NULL);
}
static void
meta_cursor_sprite_load_from_theme (MetaCursorSprite *self)
cursor: Load cursor images lazily It doesn't make sense to load cursor textures that we might not ever use. Since the code here also uses CoglTexture2D, and cursors tend to be NPOT textures, then we won't crash users of cards without NPOT support. At least until they open the magnifier. :)
2014-11-27 17:34:25 -05:00
{
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
XcursorImage *image;
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
g_assert (self->cursor != META_CURSOR_NONE);
backends: Protect from reentrancy in meta_cursor_sprite_load_from_theme This function is supposedly not failable, so just move the theme_dirty flag clearing to the beginning of the function. Protects against cases where requesting a cursor image may result in it being loaded and set as a texture, which emits ::texture-changed, which may end up requesting the cursor image again. https://bugzilla.gnome.org/show_bug.cgi?id=754806
2017-11-17 08:07:20 -05:00
self->theme_dirty = FALSE;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
/* We might be reloading with a different scale. If so clear the old data. */
if (self->xcursor_images)
{
g_clear_pointer (&self->texture, cogl_object_unref);
XcursorImagesDestroy (self->xcursor_images);
}
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
self->current_frame = 0;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
self->xcursor_images = load_cursor_on_client (self->cursor,
self->theme_scale);
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
if (!self->xcursor_images)
meta_fatal ("Could not find cursor. Perhaps set XCURSOR_PATH?");
image = meta_cursor_sprite_get_current_frame_image (self);
meta_cursor_sprite_load_from_xcursor_image (self, image);
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
}
MetaCursorSprite *
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
meta_cursor_sprite_from_theme (MetaCursor cursor)
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
{
MetaCursorSprite *self;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
self = meta_cursor_sprite_new ();
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
self->cursor = cursor;
self->theme_dirty = TRUE;
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
return self;
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
void
meta_cursor_sprite_set_texture (MetaCursorSprite *self,
CoglTexture *texture,
int hot_x,
int hot_y)
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
{
backends: Add MetaCursorSprite::texture-changed signal As wayland implements the cursor role, it consists of a persistent MetaCursorSprite that gets the backing texture changed. This is inconvenient for the places using MetaCursorTracker to track cursor changes, as they actually track MetaCursorSprites. This signal will be used to trigger emission of MetaCursorTracker::cursor-changed, which will make users able to update accordingly. https://bugzilla.gnome.org/show_bug.cgi?id=754806
2017-11-16 13:16:54 -05:00
if (self->texture == COGL_TEXTURE_2D (texture) &&
self->hot_x == hot_x &&
self->hot_y == hot_y)
return;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
g_clear_pointer (&self->texture, cogl_object_unref);
if (texture)
self->texture = cogl_object_ref (texture);
MetaCursorSprite: Squash MetaCurorImage into MetaCursorSprite It fills little purpose on separating into a MetaCursorImage struct, so lets squash in the three fields into the MetaCursorSprite object. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-16 23:56:42 -04:00
self->hot_x = hot_x;
self->hot_y = hot_y;
backends: Add MetaCursorSprite::texture-changed signal As wayland implements the cursor role, it consists of a persistent MetaCursorSprite that gets the backing texture changed. This is inconvenient for the places using MetaCursorTracker to track cursor changes, as they actually track MetaCursorSprites. This signal will be used to trigger emission of MetaCursorTracker::cursor-changed, which will make users able to update accordingly. https://bugzilla.gnome.org/show_bug.cgi?id=754806
2017-11-16 13:16:54 -05:00
g_signal_emit (self, signals[TEXTURE_CHANGED], 0);
cursor: Refactor code to load cursor images out We're going to make MetaCursorReference specialized and per-backend soon.
2014-03-31 17:13:03 -04:00
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
void
meta_cursor_sprite_set_texture_scale (MetaCursorSprite *self,
float scale)
cursor: Refactor code to load cursor images out We're going to make MetaCursorReference specialized and per-backend soon.
2014-03-31 17:13:03 -04:00
{
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
self->texture_scale = scale;
}
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
void
meta_cursor_sprite_set_theme_scale (MetaCursorSprite *self,
int theme_scale)
{
if (self->theme_scale != theme_scale)
self->theme_dirty = TRUE;
self->theme_scale = theme_scale;
cursor-tracker: Split the code that loads MetaCursorReferences out The plan here is to move the usage of these interfaces to the consumer, and then slam the code into backends.
2014-03-31 15:21:19 -04:00
}
cursor: Introduce accessors for the texture / GBM bo We want to make this private, and have MetaCursorReference be backend-defined, with the texture possibly loaded on demand. We can't make the definition of MetaCursorReference truly private yet because of the XFixes cursor. A victim of MetaCursorTracker trying to do too many things at once...
2014-03-31 15:31:15 -04:00
CoglTexture *
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
meta_cursor_sprite_get_cogl_texture (MetaCursorSprite *self)
cursor: Introduce accessors for the texture / GBM bo We want to make this private, and have MetaCursorReference be backend-defined, with the texture possibly loaded on demand. We can't make the definition of MetaCursorReference truly private yet because of the XFixes cursor. A victim of MetaCursorTracker trying to do too many things at once...
2014-03-31 15:31:15 -04:00
{
MetaCursorSprite: Squash MetaCurorImage into MetaCursorSprite It fills little purpose on separating into a MetaCursorImage struct, so lets squash in the three fields into the MetaCursorSprite object. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-16 23:56:42 -04:00
return COGL_TEXTURE (self->texture);
cursor: Introduce accessors for the texture / GBM bo We want to make this private, and have MetaCursorReference be backend-defined, with the texture possibly loaded on demand. We can't make the definition of MetaCursorReference truly private yet because of the XFixes cursor. A victim of MetaCursorTracker trying to do too many things at once...
2014-03-31 15:31:15 -04:00
}
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
MetaCursor
meta_cursor_sprite_get_meta_cursor (MetaCursorSprite *self)
cursor: Introduce accessors for the texture / GBM bo We want to make this private, and have MetaCursorReference be backend-defined, with the texture possibly loaded on demand. We can't make the definition of MetaCursorReference truly private yet because of the XFixes cursor. A victim of MetaCursorTracker trying to do too many things at once...
2014-03-31 15:31:15 -04:00
{
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
return self->cursor;
}
cursor: Load cursor images lazily It doesn't make sense to load cursor textures that we might not ever use. Since the code here also uses CoglTexture2D, and cursors tend to be NPOT textures, then we won't crash users of cards without NPOT support. At least until they open the magnifier. :)
2014-11-27 17:34:25 -05:00
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
void
meta_cursor_sprite_get_hotspot (MetaCursorSprite *self,
int *hot_x,
int *hot_y)
{
MetaCursorSprite: Squash MetaCurorImage into MetaCursorSprite It fills little purpose on separating into a MetaCursorImage struct, so lets squash in the three fields into the MetaCursorSprite object. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-16 23:56:42 -04:00
*hot_x = self->hot_x;
*hot_y = self->hot_y;
cursor: Introduce accessors for the texture / GBM bo We want to make this private, and have MetaCursorReference be backend-defined, with the texture possibly loaded on demand. We can't make the definition of MetaCursorReference truly private yet because of the XFixes cursor. A victim of MetaCursorTracker trying to do too many things at once...
2014-03-31 15:31:15 -04:00
}
cursor: Save the original MetaCursor a cursor came from So we can recreate it as a server-side cursor
2014-04-23 11:04:08 -04:00
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
float
meta_cursor_sprite_get_texture_scale (MetaCursorSprite *self)
cursor: Save the original MetaCursor a cursor came from So we can recreate it as a server-side cursor
2014-04-23 11:04:08 -04:00
{
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
return self->texture_scale;
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
}
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
void
meta_cursor_sprite_prepare_at (MetaCursorSprite *self,
int x,
int y)
{
g_signal_emit (self, signals[PREPARE_AT], 0, x, y);
}
void
meta_cursor_sprite_realize_texture (MetaCursorSprite *self)
MetaCursorSprite: Put renderer specific code in the renderer There were lots of code handling the native renderer specific cases; move these parts to the renderer. Note that this causes the X11 case to always generate the texture which is a waste of memory, but his regression will be fixed in a following commit. The lazy loading of the texture was removed because it was eventually always loaded anyway indirectly by the renderer to calculate the current rect. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 23:16:58 -04:00
{
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
if (self->theme_dirty)
meta_cursor_sprite_load_from_theme (self);
cursor: Save the original MetaCursor a cursor came from So we can recreate it as a server-side cursor
2014-04-23 11:04:08 -04:00
}
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
static void
meta_cursor_sprite_init (MetaCursorSprite *self)
{
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
self->texture_scale = 1.0f;
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
}
static void
meta_cursor_sprite_finalize (GObject *object)
{
MetaCursorSprite *self = META_CURSOR_SPRITE (object);
if (self->xcursor_images)
XcursorImagesDestroy (self->xcursor_images);
MetaCursorSprite: Squash MetaCurorImage into MetaCursorSprite It fills little purpose on separating into a MetaCursorImage struct, so lets squash in the three fields into the MetaCursorSprite object. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-16 23:56:42 -04:00
g_clear_pointer (&self->texture, cogl_object_unref);
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
G_OBJECT_CLASS (meta_cursor_sprite_parent_class)->finalize (object);
}
static void
meta_cursor_sprite_class_init (MetaCursorSpriteClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = meta_cursor_sprite_finalize;
Support scaling of cursor sprites given what output they are on This commits refactors cursor handling code and plugs in logic so that cursor sprites changes appearance as it moves across the screen. Renderers are adapted to handle the necessary functionality. The logic for changing the cursor sprite appearance is done outside of MetaCursorSprite, and actually where depends on what type of cursor it is. In mutter we now have two types of cursors that may have their appearance changed: - Themed cursors (aka root cursors) - wl_surface cursors Themed cursors are created by MetaScreen and when created, when applicable(*), it will extend the cursor via connecting to a signal which is emitted everytime the cursor is moved. The signal handler will calculate the expected scale given the monitor it is on and reload the theme in a correct size when needed. wl_surface cursors are created when a wl_surface is assigned the "cursor" role, i.e. when a client calls wl_pointer.set_cursor. A cursor role object is created which is connected to the cursor object by the position signal, and will set a correct texture scale given what monitor the cursor is on and what scale the wl_surface's active buffer is in. It will also push new buffers to the same to the cursor object when new ones are committed to the surface. This commit also makes texture loading lazy, since the renderer doesn't calculate a rectangle when the cursor position changes. The native backend is refactored to be triple-buffered; see the comment in meta-cursor-renderer-native.c for further explanations. * when we are running as a Wayland compositor https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-07-17 11:16:39 -04:00
signals[PREPARE_AT] = g_signal_new ("prepare-at",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 2,
G_TYPE_INT,
G_TYPE_INT);
backends: Add MetaCursorSprite::texture-changed signal As wayland implements the cursor role, it consists of a persistent MetaCursorSprite that gets the backing texture changed. This is inconvenient for the places using MetaCursorTracker to track cursor changes, as they actually track MetaCursorSprites. This signal will be used to trigger emission of MetaCursorTracker::cursor-changed, which will make users able to update accordingly. https://bugzilla.gnome.org/show_bug.cgi?id=754806
2017-11-16 13:16:54 -05:00
signals[TEXTURE_CHANGED] = g_signal_new ("texture-changed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 0);
Make MetaCursorSprite a GObject To easier track lifetime and utilize other GObject features, make MetaCursorSprite a GObject. https://bugzilla.gnome.org/show_bug.cgi?id=744932
2015-03-10 02:35:49 -04:00
}
Reference in New Issue Copy Permalink