isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2025-04-02 16:43:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename MetaCursorReference to MetaCursorSprite

Browse Source 
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
This commit is contained in:
Jonas Ådahl 2015-03-10 11:23:00 +08:00
parent fe8454d13f
commit 4b667d1e09
12 changed files with 172 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/backends/meta-cursor-private.h
View File

@ -40,7 +40,7 @@ typedef struct {
#endif #endif
} MetaCursorImage; } MetaCursorImage;
struct _MetaCursorReference { struct _MetaCursorSprite {
int ref_count; int ref_count;
int current_frame; int current_frame;
@ -49,18 +49,18 @@ struct _MetaCursorReference {
MetaCursorImage image; MetaCursorImage image;
}; };
CoglTexture *meta_cursor_reference_get_cogl_texture (MetaCursorReference *cursor, CoglTexture *meta_cursor_sprite_get_cogl_texture (MetaCursorSprite *self,
int *hot_x, int *hot_x,
int *hot_y); int *hot_y);
#ifdef HAVE_NATIVE_BACKEND #ifdef HAVE_NATIVE_BACKEND
struct gbm_bo *meta_cursor_reference_get_gbm_bo (MetaCursorReference *cursor, struct gbm_bo *meta_cursor_sprite_get_gbm_bo (MetaCursorSprite *self,
int *hot_x, int *hot_x,
int *hot_y); int *hot_y);
#endif #endif
gboolean meta_cursor_reference_is_animated (MetaCursorReference *self); gboolean meta_cursor_sprite_is_animated (MetaCursorSprite *self);
void meta_cursor_reference_tick_frame (MetaCursorReference *self); void meta_cursor_sprite_tick_frame (MetaCursorSprite *self);
guint meta_cursor_reference_get_current_frame_time (MetaCursorReference *self); guint meta_cursor_sprite_get_current_frame_time (MetaCursorSprite *self);
#endif /* META_CURSOR_PRIVATE_H */ #endif /* META_CURSOR_PRIVATE_H */

18
src/backends/meta-cursor-renderer.c
View File

@ -40,7 +40,7 @@ struct _MetaCursorRendererPrivate
int current_x, current_y; int current_x, current_y;
MetaRectangle current_rect; MetaRectangle current_rect;
MetaCursorReference *displayed_cursor; MetaCursorSprite *displayed_cursor;
gboolean handled_by_backend; gboolean handled_by_backend;
}; };
typedef struct _MetaCursorRendererPrivate MetaCursorRendererPrivate; typedef struct _MetaCursorRendererPrivate MetaCursorRendererPrivate;
@ -60,7 +60,8 @@ queue_redraw (MetaCursorRenderer *renderer)
return; return;
if (priv->displayed_cursor && !priv->handled_by_backend) if (priv->displayed_cursor && !priv->handled_by_backend)
texture = meta_cursor_reference_get_cogl_texture (priv->displayed_cursor, NULL, NULL); texture = meta_cursor_sprite_get_cogl_texture (priv->displayed_cursor,
NULL, NULL);
else else
texture = NULL; texture = NULL;
@ -96,7 +97,8 @@ update_cursor (MetaCursorRenderer *renderer)
CoglTexture *texture; CoglTexture *texture;
int hot_x, hot_y; int hot_x, hot_y;
texture = meta_cursor_reference_get_cogl_texture (priv->displayed_cursor, &hot_x, &hot_y); texture = meta_cursor_sprite_get_cogl_texture (priv->displayed_cursor,
&hot_x, &hot_y);
priv->current_rect.x = priv->current_x - hot_x; priv->current_rect.x = priv->current_x - hot_x;
priv->current_rect.y = priv->current_y - hot_y; priv->current_rect.y = priv->current_y - hot_y;
@ -132,15 +134,15 @@ meta_cursor_renderer_new (void)
} }
void void
meta_cursor_renderer_set_cursor (MetaCursorRenderer *renderer, meta_cursor_renderer_set_cursor (MetaCursorRenderer *renderer,
MetaCursorReference *cursor) MetaCursorSprite *cursor_sprite)
{ {
MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer); MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
if (priv->displayed_cursor == cursor) if (priv->displayed_cursor == cursor_sprite)
return; return;
priv->displayed_cursor = cursor; priv->displayed_cursor = cursor_sprite;
update_cursor (renderer); update_cursor (renderer);
} }
@ -165,7 +167,7 @@ meta_cursor_renderer_set_position (MetaCursorRenderer *renderer,
update_cursor (renderer); update_cursor (renderer);
} }
MetaCursorReference * MetaCursorSprite *
meta_cursor_renderer_get_cursor (MetaCursorRenderer *renderer) meta_cursor_renderer_get_cursor (MetaCursorRenderer *renderer)
{ {
MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer); MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);

6
src/backends/meta-cursor-renderer.h
View File

@ -45,14 +45,14 @@ GType meta_cursor_renderer_get_type (void) G_GNUC_CONST;
MetaCursorRenderer * meta_cursor_renderer_new (void); MetaCursorRenderer * meta_cursor_renderer_new (void);
void meta_cursor_renderer_set_cursor (MetaCursorRenderer *renderer, void meta_cursor_renderer_set_cursor (MetaCursorRenderer *renderer,
MetaCursorReference *cursor); MetaCursorSprite *cursor_sprite);
void meta_cursor_renderer_set_position (MetaCursorRenderer *renderer, void meta_cursor_renderer_set_position (MetaCursorRenderer *renderer,
int x, int y); int x, int y);
void meta_cursor_renderer_force_update (MetaCursorRenderer *renderer); void meta_cursor_renderer_force_update (MetaCursorRenderer *renderer);
MetaCursorReference * meta_cursor_renderer_get_cursor (MetaCursorRenderer *renderer); MetaCursorSprite * meta_cursor_renderer_get_cursor (MetaCursorRenderer *renderer);
const MetaRectangle * meta_cursor_renderer_get_rect (MetaCursorRenderer *renderer); const MetaRectangle * meta_cursor_renderer_get_rect (MetaCursorRenderer *renderer);
#endif /* META_CURSOR_RENDERER_H */ #endif /* META_CURSOR_RENDERER_H */

20
src/backends/meta-cursor-tracker-private.h
View File

@ -34,7 +34,7 @@ struct _MetaCursorTracker {
gboolean is_showing; gboolean is_showing;
MetaCursorReference *displayed_cursor; MetaCursorSprite *displayed_cursor;
/* Wayland clients can set a NULL buffer as their cursor /* Wayland clients can set a NULL buffer as their cursor
* explicitly, which means that we shouldn't display anything. * explicitly, which means that we shouldn't display anything.
@ -42,12 +42,12 @@ struct _MetaCursorTracker {
* determine an unset window cursor; we need an extra boolean. * determine an unset window cursor; we need an extra boolean.
*/ */
gboolean has_window_cursor; gboolean has_window_cursor;
MetaCursorReference *window_cursor; MetaCursorSprite *window_cursor;
MetaCursorReference *root_cursor; MetaCursorSprite *root_cursor;
/* The cursor from the X11 server. */ /* The cursor from the X11 server. */
MetaCursorReference *xfixes_cursor; MetaCursorSprite *xfixes_cursor;
}; };
struct _MetaCursorTrackerClass { struct _MetaCursorTrackerClass {
@ -57,16 +57,16 @@ struct _MetaCursorTrackerClass {
gboolean meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker, gboolean meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
XEvent *xevent); XEvent *xevent);
void meta_cursor_tracker_set_window_cursor (MetaCursorTracker *tracker, void meta_cursor_tracker_set_window_cursor (MetaCursorTracker *tracker,
MetaCursorReference *cursor); MetaCursorSprite *cursor_sprite);
void meta_cursor_tracker_unset_window_cursor (MetaCursorTracker *tracker); void meta_cursor_tracker_unset_window_cursor (MetaCursorTracker *tracker);
void meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker, void meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker,
MetaCursorReference *cursor); MetaCursorSprite *cursor_sprite);
void meta_cursor_tracker_update_position (MetaCursorTracker *tracker, void meta_cursor_tracker_update_position (MetaCursorTracker *tracker,
int new_x, int new_x,
int new_y); int new_y);
MetaCursorReference * meta_cursor_tracker_get_displayed_cursor (MetaCursorTracker *tracker); MetaCursorSprite * meta_cursor_tracker_get_displayed_cursor (MetaCursorTracker *tracker);
#endif #endif

85
src/backends/meta-cursor-tracker.c
View File

@ -54,7 +54,7 @@ enum {
static guint signals[LAST_SIGNAL]; static guint signals[LAST_SIGNAL];
static MetaCursorReference * static MetaCursorSprite *
get_displayed_cursor (MetaCursorTracker *tracker) get_displayed_cursor (MetaCursorTracker *tracker)
{ {
MetaDisplay *display = meta_get_display (); MetaDisplay *display = meta_get_display ();
@ -80,14 +80,14 @@ update_displayed_cursor (MetaCursorTracker *tracker)
static void static void
sync_cursor (MetaCursorTracker *tracker) sync_cursor (MetaCursorTracker *tracker)
{ {
MetaCursorReference *displayed_cursor = get_displayed_cursor (tracker); MetaCursorSprite *displayed_cursor = get_displayed_cursor (tracker);
if (tracker->displayed_cursor == displayed_cursor) if (tracker->displayed_cursor == displayed_cursor)
return; return;
g_clear_pointer (&tracker->displayed_cursor, meta_cursor_reference_unref); g_clear_pointer (&tracker->displayed_cursor, meta_cursor_sprite_unref);
if (displayed_cursor) if (displayed_cursor)
tracker->displayed_cursor = meta_cursor_reference_ref (displayed_cursor); tracker->displayed_cursor = meta_cursor_sprite_ref (displayed_cursor);
update_displayed_cursor (tracker); update_displayed_cursor (tracker);
g_signal_emit (tracker, signals[CURSOR_CHANGED], 0); g_signal_emit (tracker, signals[CURSOR_CHANGED], 0);
@ -108,9 +108,9 @@ meta_cursor_tracker_finalize (GObject *object)
MetaCursorTracker *self = META_CURSOR_TRACKER (object); MetaCursorTracker *self = META_CURSOR_TRACKER (object);
if (self->displayed_cursor) if (self->displayed_cursor)
meta_cursor_reference_unref (self->displayed_cursor); meta_cursor_sprite_unref (self->displayed_cursor);
if (self->root_cursor) if (self->root_cursor)
meta_cursor_reference_unref (self->root_cursor); meta_cursor_sprite_unref (self->root_cursor);
G_OBJECT_CLASS (meta_cursor_tracker_parent_class)->finalize (object); G_OBJECT_CLASS (meta_cursor_tracker_parent_class)->finalize (object);
} }
@ -156,13 +156,13 @@ meta_cursor_tracker_get_for_screen (MetaScreen *screen)
} }
static void static void
set_window_cursor (MetaCursorTracker *tracker, set_window_cursor (MetaCursorTracker *tracker,
gboolean has_cursor, gboolean has_cursor,
MetaCursorReference *cursor) MetaCursorSprite *cursor_sprite)
{ {
g_clear_pointer (&tracker->window_cursor, meta_cursor_reference_unref); g_clear_pointer (&tracker->window_cursor, meta_cursor_sprite_unref);
if (cursor) if (cursor_sprite)
tracker->window_cursor = meta_cursor_reference_ref (cursor); tracker->window_cursor = meta_cursor_sprite_ref (cursor_sprite);
tracker->has_window_cursor = has_cursor; tracker->has_window_cursor = has_cursor;
sync_cursor (tracker); sync_cursor (tracker);
} }
@ -184,20 +184,20 @@ meta_cursor_tracker_handle_xevent (MetaCursorTracker *tracker,
if (notify_event->subtype != XFixesDisplayCursorNotify) if (notify_event->subtype != XFixesDisplayCursorNotify)
return FALSE; return FALSE;
g_clear_pointer (&tracker->xfixes_cursor, meta_cursor_reference_unref); g_clear_pointer (&tracker->xfixes_cursor, meta_cursor_sprite_unref);
g_signal_emit (tracker, signals[CURSOR_CHANGED], 0); g_signal_emit (tracker, signals[CURSOR_CHANGED], 0);
return TRUE; return TRUE;
} }
static MetaCursorReference * static MetaCursorSprite *
meta_cursor_reference_take_texture (CoglTexture2D *texture, meta_cursor_sprite_take_texture (CoglTexture2D *texture,
int hot_x, int hot_x,
int hot_y) int hot_y)
{ {
MetaCursorReference *self; MetaCursorSprite *self;
self = g_slice_new0 (MetaCursorReference); self = g_slice_new0 (MetaCursorSprite);
self->ref_count = 1; self->ref_count = 1;
self->image.texture = texture; self->image.texture = texture;
self->image.hot_x = hot_x; self->image.hot_x = hot_x;
@ -263,10 +263,11 @@ ensure_xfixes_cursor (MetaCursorTracker *tracker)
if (sprite != NULL) if (sprite != NULL)
{ {
MetaCursorReference *cursor = meta_cursor_reference_take_texture (sprite, MetaCursorSprite *cursor_sprite =
cursor_image->xhot, meta_cursor_sprite_take_texture (sprite,
cursor_image->yhot); cursor_image->xhot,
tracker->xfixes_cursor = cursor; cursor_image->yhot);
tracker->xfixes_cursor = cursor_sprite;
} }
XFree (cursor_image); XFree (cursor_image);
} }
@ -279,22 +280,22 @@ ensure_xfixes_cursor (MetaCursorTracker *tracker)
CoglTexture * CoglTexture *
meta_cursor_tracker_get_sprite (MetaCursorTracker *tracker) meta_cursor_tracker_get_sprite (MetaCursorTracker *tracker)
{ {
MetaCursorReference *cursor; MetaCursorSprite *cursor_sprite;
g_return_val_if_fail (META_IS_CURSOR_TRACKER (tracker), NULL); g_return_val_if_fail (META_IS_CURSOR_TRACKER (tracker), NULL);
if (meta_is_wayland_compositor ()) if (meta_is_wayland_compositor ())
{ {
cursor = tracker->displayed_cursor; cursor_sprite = tracker->displayed_cursor;
} }
else else
{ {
ensure_xfixes_cursor (tracker); ensure_xfixes_cursor (tracker);
cursor = tracker->xfixes_cursor; cursor_sprite = tracker->xfixes_cursor;
} }
if (cursor) if (cursor_sprite)
return meta_cursor_reference_get_cogl_texture (cursor, NULL, NULL); return meta_cursor_sprite_get_cogl_texture (cursor_sprite, NULL, NULL);
else else
return NULL; return NULL;
} }
@ -311,22 +312,22 @@ meta_cursor_tracker_get_hot (MetaCursorTracker *tracker,
int *x, int *x,
int *y) int *y)
{ {
MetaCursorReference *cursor; MetaCursorSprite *cursor_sprite;
g_return_if_fail (META_IS_CURSOR_TRACKER (tracker)); g_return_if_fail (META_IS_CURSOR_TRACKER (tracker));
if (meta_is_wayland_compositor ()) if (meta_is_wayland_compositor ())
{ {
cursor = tracker->displayed_cursor; cursor_sprite = tracker->displayed_cursor;
} }
else else
{ {
ensure_xfixes_cursor (tracker); ensure_xfixes_cursor (tracker);
cursor = tracker->xfixes_cursor; cursor_sprite = tracker->xfixes_cursor;
} }
if (cursor) if (cursor_sprite)
meta_cursor_reference_get_cogl_texture (cursor, x, y); meta_cursor_sprite_get_cogl_texture (cursor_sprite, x, y);
else else
{ {
if (x) if (x)
@ -337,10 +338,10 @@ meta_cursor_tracker_get_hot (MetaCursorTracker *tracker,
} }
void void
meta_cursor_tracker_set_window_cursor (MetaCursorTracker *tracker, meta_cursor_tracker_set_window_cursor (MetaCursorTracker *tracker,
MetaCursorReference *cursor) MetaCursorSprite *cursor_sprite)
{ {
set_window_cursor (tracker, TRUE, cursor); set_window_cursor (tracker, TRUE, cursor_sprite);
} }
void void
@ -350,12 +351,12 @@ meta_cursor_tracker_unset_window_cursor (MetaCursorTracker *tracker)
} }
void void
meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker, meta_cursor_tracker_set_root_cursor (MetaCursorTracker *tracker,
MetaCursorReference *cursor) MetaCursorSprite *cursor_sprite)
{ {
g_clear_pointer (&tracker->root_cursor, meta_cursor_reference_unref); g_clear_pointer (&tracker->root_cursor, meta_cursor_sprite_unref);
if (cursor) if (cursor_sprite)
tracker->root_cursor = meta_cursor_reference_ref (cursor); tracker->root_cursor = meta_cursor_sprite_ref (cursor_sprite);
sync_cursor (tracker); sync_cursor (tracker);
} }
@ -438,7 +439,7 @@ meta_cursor_tracker_set_pointer_visible (MetaCursorTracker *tracker,
sync_cursor (tracker); sync_cursor (tracker);
} }
MetaCursorReference * MetaCursorSprite *
meta_cursor_tracker_get_displayed_cursor (MetaCursorTracker *tracker) meta_cursor_tracker_get_displayed_cursor (MetaCursorTracker *tracker)
{ {
return tracker->displayed_cursor; return tracker->displayed_cursor;

96
src/backends/meta-cursor.c
View File

@ -43,8 +43,8 @@
#include <cogl/cogl-wayland-server.h> #include <cogl/cogl-wayland-server.h>
#endif #endif
MetaCursorReference * MetaCursorSprite *
meta_cursor_reference_ref (MetaCursorReference *self) meta_cursor_sprite_ref (MetaCursorSprite *self)
{ {
g_assert (self->ref_count > 0); g_assert (self->ref_count > 0);
self->ref_count++; self->ref_count++;
@ -65,21 +65,21 @@ meta_cursor_image_free (MetaCursorImage *image)
} }
static void static void
meta_cursor_reference_free (MetaCursorReference *self) meta_cursor_sprite_free (MetaCursorSprite *self)
{ {
if (self->xcursor_images) if (self->xcursor_images)
XcursorImagesDestroy (self->xcursor_images); XcursorImagesDestroy (self->xcursor_images);
meta_cursor_image_free (&self->image); meta_cursor_image_free (&self->image);
g_slice_free (MetaCursorReference, self); g_slice_free (MetaCursorSprite, self);
} }
void void
meta_cursor_reference_unref (MetaCursorReference *self) meta_cursor_sprite_unref (MetaCursorSprite *self)
{ {
self->ref_count--; self->ref_count--;
if (self->ref_count == 0) if (self->ref_count == 0)
meta_cursor_reference_free (self); meta_cursor_sprite_free (self);
} }
static const char * static const char *
@ -259,17 +259,17 @@ meta_cursor_image_load_from_xcursor_image (MetaCursorImage *image,
} }
static XcursorImage * static XcursorImage *
meta_cursor_reference_get_current_frame_image (MetaCursorReference *self) meta_cursor_sprite_get_current_frame_image (MetaCursorSprite *self)
{ {
return self->xcursor_images->images[self->current_frame]; return self->xcursor_images->images[self->current_frame];
} }
void void
meta_cursor_reference_tick_frame (MetaCursorReference *self) meta_cursor_sprite_tick_frame (MetaCursorSprite *self)
{ {
XcursorImage *image; XcursorImage *image;
if (!meta_cursor_reference_is_animated (self)) if (!meta_cursor_sprite_is_animated (self))
return; return;
self->current_frame++; self->current_frame++;
@ -278,52 +278,52 @@ meta_cursor_reference_tick_frame (MetaCursorReference *self)
self->current_frame = 0; self->current_frame = 0;
meta_cursor_image_free (&self->image); meta_cursor_image_free (&self->image);
image = meta_cursor_reference_get_current_frame_image (self); image = meta_cursor_sprite_get_current_frame_image (self);
meta_cursor_image_load_from_xcursor_image (&self->image, image); meta_cursor_image_load_from_xcursor_image (&self->image, image);
} }
guint guint
meta_cursor_reference_get_current_frame_time (MetaCursorReference *self) meta_cursor_sprite_get_current_frame_time (MetaCursorSprite *self)
{ {
if (!meta_cursor_reference_is_animated (self)) if (!meta_cursor_sprite_is_animated (self))
return 0; return 0;
return self->xcursor_images->images[self->current_frame]->delay; return self->xcursor_images->images[self->current_frame]->delay;
} }
gboolean gboolean
meta_cursor_reference_is_animated (MetaCursorReference *self) meta_cursor_sprite_is_animated (MetaCursorSprite *self)
{ {
return (self->xcursor_images && return (self->xcursor_images &&
self->xcursor_images->nimage > 1); self->xcursor_images->nimage > 1);
} }
static void static void
load_cursor_image (MetaCursorReference *cursor) load_cursor_image (MetaCursorSprite *self)
{ {
XcursorImage *image; XcursorImage *image;
/* Either cursors are loaded from X cursors or buffers. Since /* Either cursors are loaded from X cursors or buffers. Since
* buffers are converted over immediately, we can make sure to * buffers are converted over immediately, we can make sure to
* load this directly. */ * load this directly. */
g_assert (cursor->cursor != META_CURSOR_NONE); g_assert (self->cursor != META_CURSOR_NONE);
if (!cursor->xcursor_images) if (!self->xcursor_images)
{ {
cursor->current_frame = 0; self->current_frame = 0;
cursor->xcursor_images = load_cursor_on_client (cursor->cursor); self->xcursor_images = load_cursor_on_client (self->cursor);
if (!cursor->xcursor_images) if (!self->xcursor_images)
meta_fatal ("Could not find cursor. Perhaps set XCURSOR_PATH?"); meta_fatal ("Could not find cursor. Perhaps set XCURSOR_PATH?");
} }
image = meta_cursor_reference_get_current_frame_image (cursor); image = meta_cursor_sprite_get_current_frame_image (self);
meta_cursor_image_load_from_xcursor_image (&cursor->image, image); meta_cursor_image_load_from_xcursor_image (&self->image, image);
} }
MetaCursorReference * MetaCursorSprite *
meta_cursor_reference_from_theme (MetaCursor cursor) meta_cursor_sprite_from_theme (MetaCursor cursor)
{ {
MetaCursorReference *self = g_slice_new0 (MetaCursorReference); MetaCursorSprite *self = g_slice_new0 (MetaCursorSprite);
self->ref_count = 1; self->ref_count = 1;
self->cursor = cursor; self->cursor = cursor;
return self; return self;
@ -419,14 +419,14 @@ meta_cursor_image_load_from_buffer (MetaCursorImage *image,
#endif #endif
} }
MetaCursorReference * MetaCursorSprite *
meta_cursor_reference_from_buffer (struct wl_resource *buffer, meta_cursor_sprite_from_buffer (struct wl_resource *buffer,
int hot_x, int hot_x,
int hot_y) int hot_y)
{ {
MetaCursorReference *self; MetaCursorSprite *self;
self = g_slice_new0 (MetaCursorReference); self = g_slice_new0 (MetaCursorSprite);
self->ref_count = 1; self->ref_count = 1;
meta_cursor_image_load_from_buffer (&self->image, buffer, hot_x, hot_y); meta_cursor_image_load_from_buffer (&self->image, buffer, hot_x, hot_y);
@ -435,40 +435,40 @@ meta_cursor_reference_from_buffer (struct wl_resource *buffer,
#endif #endif
CoglTexture * CoglTexture *
meta_cursor_reference_get_cogl_texture (MetaCursorReference *cursor, meta_cursor_sprite_get_cogl_texture (MetaCursorSprite *self,
int *hot_x, int *hot_x,
int *hot_y) int *hot_y)
{ {
if (!cursor->image.texture) if (!self->image.texture)
load_cursor_image (cursor); load_cursor_image (self);
if (hot_x) if (hot_x)
*hot_x = cursor->image.hot_x; *hot_x = self->image.hot_x;
if (hot_y) if (hot_y)
*hot_y = cursor->image.hot_y; *hot_y = self->image.hot_y;
return COGL_TEXTURE (cursor->image.texture); return COGL_TEXTURE (self->image.texture);
} }
#ifdef HAVE_NATIVE_BACKEND #ifdef HAVE_NATIVE_BACKEND
struct gbm_bo * struct gbm_bo *
meta_cursor_reference_get_gbm_bo (MetaCursorReference *cursor, meta_cursor_sprite_get_gbm_bo (MetaCursorSprite *self,
int *hot_x, int *hot_x,
int *hot_y) int *hot_y)
{ {
if (!cursor->image.bo) if (!self->image.bo)
load_cursor_image (cursor); load_cursor_image (self);
if (hot_x) if (hot_x)
*hot_x = cursor->image.hot_x; *hot_x = self->image.hot_x;
if (hot_y) if (hot_y)
*hot_y = cursor->image.hot_y; *hot_y = self->image.hot_y;
return cursor->image.bo; return self->image.bo;
} }
#endif #endif
MetaCursor MetaCursor
meta_cursor_reference_get_meta_cursor (MetaCursorReference *cursor) meta_cursor_sprite_get_meta_cursor (MetaCursorSprite *self)
{ {
return cursor->cursor; return self->cursor;
} }

16
src/backends/meta-cursor.h
View File

@ -22,23 +22,23 @@
#ifndef META_CURSOR_H #ifndef META_CURSOR_H
#define META_CURSOR_H #define META_CURSOR_H
typedef struct _MetaCursorReference MetaCursorReference; typedef struct _MetaCursorSprite MetaCursorSprite;
MetaCursorReference * meta_cursor_reference_ref (MetaCursorReference *cursor); MetaCursorSprite * meta_cursor_sprite_ref (MetaCursorSprite *self);
void meta_cursor_reference_unref (MetaCursorReference *cursor); void meta_cursor_sprite_unref (MetaCursorSprite *self);
#include <meta/common.h> #include <meta/common.h>
MetaCursorReference * meta_cursor_reference_from_theme (MetaCursor cursor); MetaCursorSprite * meta_cursor_sprite_from_theme (MetaCursor cursor);
#ifdef HAVE_WAYLAND #ifdef HAVE_WAYLAND
#include <wayland-server.h> #include <wayland-server.h>
MetaCursorReference * meta_cursor_reference_from_buffer (struct wl_resource *buffer, MetaCursorSprite * meta_cursor_sprite_from_buffer (struct wl_resource *buffer,
int hot_x, int hot_x,
int hot_y); int hot_y);
#endif #endif
MetaCursor meta_cursor_reference_get_meta_cursor (MetaCursorReference *cursor); MetaCursor meta_cursor_sprite_get_meta_cursor (MetaCursorSprite *self);
Cursor meta_cursor_create_x_cursor (Display *xdisplay, Cursor meta_cursor_create_x_cursor (Display *xdisplay,
MetaCursor cursor); MetaCursor cursor);

2
src/backends/meta-monitor-manager-private.h
View File

@ -174,7 +174,7 @@ struct _MetaCRTC
/* Used when changing configuration */ /* Used when changing configuration */
gboolean is_dirty; gboolean is_dirty;
MetaCursorReference *cursor; MetaCursorSprite *cursor;
gpointer driver_private; gpointer driver_private;
GDestroyNotify driver_notify; GDestroyNotify driver_notify;

44
src/backends/native/meta-cursor-renderer-native.c
View File

@ -43,7 +43,7 @@ struct _MetaCursorRendererNativePrivate
{ {
gboolean has_hw_cursor; gboolean has_hw_cursor;
MetaCursorReference *last_cursor; MetaCursorSprite *last_cursor;
guint animation_timeout_id; guint animation_timeout_id;
int drm_fd; int drm_fd;
@ -74,23 +74,23 @@ meta_cursor_renderer_native_finalize (GObject *object)
static void static void
set_crtc_cursor (MetaCursorRendererNative *native, set_crtc_cursor (MetaCursorRendererNative *native,
MetaCRTC *crtc, MetaCRTC *crtc,
MetaCursorReference *cursor, MetaCursorSprite *cursor_sprite,
gboolean force) gboolean force)
{ {
MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native); MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native);
if (crtc->cursor == cursor && !force) if (crtc->cursor == cursor_sprite && !force)
return; return;
crtc->cursor = cursor; crtc->cursor = cursor_sprite;
if (cursor) if (cursor_sprite)
{ {
struct gbm_bo *bo; struct gbm_bo *bo;
union gbm_bo_handle handle; union gbm_bo_handle handle;
int hot_x, hot_y; int hot_x, hot_y;
bo = meta_cursor_reference_get_gbm_bo (cursor, &hot_x, &hot_y); bo = meta_cursor_sprite_get_gbm_bo (cursor_sprite, &hot_x, &hot_y);
handle = gbm_bo_get_handle (bo); handle = gbm_bo_get_handle (bo);
drmModeSetCursor2 (priv->drm_fd, crtc->crtc_id, handle.u32, drmModeSetCursor2 (priv->drm_fd, crtc->crtc_id, handle.u32,
@ -109,7 +109,7 @@ update_hw_cursor (MetaCursorRendererNative *native,
MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native); MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native);
MetaCursorRenderer *renderer = META_CURSOR_RENDERER (native); MetaCursorRenderer *renderer = META_CURSOR_RENDERER (native);
const MetaRectangle *cursor_rect = meta_cursor_renderer_get_rect (renderer); const MetaRectangle *cursor_rect = meta_cursor_renderer_get_rect (renderer);
MetaCursorReference *cursor = meta_cursor_renderer_get_cursor (renderer); MetaCursorSprite *cursor_sprite = meta_cursor_renderer_get_cursor (renderer);
MetaMonitorManager *monitors; MetaMonitorManager *monitors;
MetaCRTC *crtcs; MetaCRTC *crtcs;
unsigned int i, n_crtcs; unsigned int i, n_crtcs;
@ -120,14 +120,14 @@ update_hw_cursor (MetaCursorRendererNative *native,
for (i = 0; i < n_crtcs; i++) for (i = 0; i < n_crtcs; i++)
{ {
gboolean crtc_should_have_cursor; gboolean crtc_should_have_cursor;
MetaCursorReference *crtc_cursor; MetaCursorSprite *crtc_cursor;
MetaRectangle *crtc_rect; MetaRectangle *crtc_rect;
crtc_rect = &crtcs[i].rect; crtc_rect = &crtcs[i].rect;
crtc_should_have_cursor = (priv->has_hw_cursor && meta_rectangle_overlap (cursor_rect, crtc_rect)); crtc_should_have_cursor = (priv->has_hw_cursor && meta_rectangle_overlap (cursor_rect, crtc_rect));
if (crtc_should_have_cursor) if (crtc_should_have_cursor)
crtc_cursor = cursor; crtc_cursor = cursor_sprite;
else else
crtc_cursor = NULL; crtc_cursor = NULL;
@ -145,10 +145,10 @@ update_hw_cursor (MetaCursorRendererNative *native,
static gboolean static gboolean
should_have_hw_cursor (MetaCursorRenderer *renderer) should_have_hw_cursor (MetaCursorRenderer *renderer)
{ {
MetaCursorReference *cursor = meta_cursor_renderer_get_cursor (renderer); MetaCursorSprite *cursor_sprite = meta_cursor_renderer_get_cursor (renderer);
if (cursor) if (cursor_sprite)
return (meta_cursor_reference_get_gbm_bo (cursor, NULL, NULL) != NULL); return (meta_cursor_sprite_get_gbm_bo (cursor_sprite, NULL, NULL) != NULL);
else else
return FALSE; return FALSE;
} }
@ -157,11 +157,12 @@ static gboolean
meta_cursor_renderer_native_update_animation (MetaCursorRendererNative *native) meta_cursor_renderer_native_update_animation (MetaCursorRendererNative *native)
{ {
MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native); MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native);
MetaCursorReference *cursor; MetaCursorSprite *cursor_sprite;
priv->animation_timeout_id = 0; priv->animation_timeout_id = 0;
cursor = meta_cursor_renderer_get_cursor (META_CURSOR_RENDERER (native)); cursor_sprite =
meta_cursor_reference_tick_frame (cursor); meta_cursor_renderer_get_cursor (META_CURSOR_RENDERER (native));
meta_cursor_sprite_tick_frame (cursor_sprite);
meta_cursor_renderer_force_update (META_CURSOR_RENDERER (native)); meta_cursor_renderer_force_update (META_CURSOR_RENDERER (native));
meta_cursor_renderer_native_force_update (native); meta_cursor_renderer_native_force_update (native);
@ -172,13 +173,14 @@ static void
meta_cursor_renderer_native_trigger_frame (MetaCursorRendererNative *native) meta_cursor_renderer_native_trigger_frame (MetaCursorRendererNative *native)
{ {
MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native); MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native);
MetaCursorReference *cursor; MetaCursorSprite *cursor_sprite;
gboolean cursor_change; gboolean cursor_change;
guint delay; guint delay;
cursor = meta_cursor_renderer_get_cursor (META_CURSOR_RENDERER (native)); cursor_sprite =
cursor_change = cursor != priv->last_cursor; meta_cursor_renderer_get_cursor (META_CURSOR_RENDERER (native));
priv->last_cursor = cursor; cursor_change = cursor_sprite != priv->last_cursor;
priv->last_cursor = cursor_sprite;
if (!cursor_change && priv->animation_timeout_id) if (!cursor_change && priv->animation_timeout_id)
return; return;
@ -189,9 +191,9 @@ meta_cursor_renderer_native_trigger_frame (MetaCursorRendererNative *native)
priv->animation_timeout_id = 0; priv->animation_timeout_id = 0;
} }
if (cursor && meta_cursor_reference_is_animated (cursor)) if (cursor_sprite && meta_cursor_sprite_is_animated (cursor_sprite))
{ {
delay = meta_cursor_reference_get_current_frame_time (cursor); delay = meta_cursor_sprite_get_current_frame_time (cursor_sprite);
if (delay == 0) if (delay == 0)
return; return;

6
src/backends/x11/meta-cursor-renderer-x11.c
View File

@ -53,12 +53,12 @@ meta_cursor_renderer_x11_update_cursor (MetaCursorRenderer *renderer)
Display *xdisplay = meta_backend_x11_get_xdisplay (backend); Display *xdisplay = meta_backend_x11_get_xdisplay (backend);
MetaCursorReference *cursor_ref = meta_cursor_renderer_get_cursor (renderer); MetaCursorSprite *cursor_sprite = meta_cursor_renderer_get_cursor (renderer);
gboolean has_server_cursor = FALSE; gboolean has_server_cursor = FALSE;
if (cursor_ref) if (cursor_sprite)
{ {
MetaCursor cursor = meta_cursor_reference_get_meta_cursor (cursor_ref); MetaCursor cursor = meta_cursor_sprite_get_meta_cursor (cursor_sprite);
if (cursor != META_CURSOR_NONE) if (cursor != META_CURSOR_NONE)
{ {
Cursor xcursor = meta_cursor_create_x_cursor (xdisplay, cursor); Cursor xcursor = meta_cursor_create_x_cursor (xdisplay, cursor);

8
src/core/screen.c
View File

@ -1261,12 +1261,12 @@ meta_screen_update_cursor (MetaScreen *screen)
MetaDisplay *display = screen->display; MetaDisplay *display = screen->display;
MetaCursor cursor = screen->current_cursor; MetaCursor cursor = screen->current_cursor;
Cursor xcursor; Cursor xcursor;
MetaCursorReference *cursor_ref; MetaCursorSprite *cursor_sprite;
MetaCursorTracker *tracker = meta_cursor_tracker_get_for_screen (screen); MetaCursorTracker *tracker = meta_cursor_tracker_get_for_screen (screen);
cursor_ref = meta_cursor_reference_from_theme (cursor); cursor_sprite = meta_cursor_sprite_from_theme (cursor);
meta_cursor_tracker_set_root_cursor (tracker, cursor_ref); meta_cursor_tracker_set_root_cursor (tracker, cursor_sprite);
meta_cursor_reference_unref (cursor_ref); meta_cursor_sprite_unref (cursor_sprite);
/* Set a cursor for X11 applications that don't specify their own */ /* Set a cursor for X11 applications that don't specify their own */
xcursor = meta_display_create_x_cursor (display, cursor); xcursor = meta_display_create_x_cursor (display, cursor);

17
src/wayland/meta-wayland-pointer.c
View File

@ -735,22 +735,23 @@ meta_wayland_pointer_update_cursor_surface (MetaWaylandPointer *pointer)
if (pointer->current) if (pointer->current)
{ {
MetaCursorReference *cursor; MetaCursorSprite *cursor_sprite;
if (pointer->cursor_surface && pointer->cursor_surface->buffer) if (pointer->cursor_surface && pointer->cursor_surface->buffer)
{ {
struct wl_resource *buffer = pointer->cursor_surface->buffer->resource; struct wl_resource *buffer = pointer->cursor_surface->buffer->resource;
cursor = meta_cursor_reference_from_buffer (buffer, cursor_sprite = meta_cursor_sprite_from_buffer (buffer,
pointer->hotspot_x, pointer->hotspot_x,
pointer->hotspot_y); pointer->hotspot_y);
} }
else else
cursor = NULL; cursor_sprite = NULL;
meta_cursor_tracker_set_window_cursor (pointer->cursor_tracker, cursor); meta_cursor_tracker_set_window_cursor (pointer->cursor_tracker,
cursor_sprite);
if (cursor) if (cursor_sprite)
meta_cursor_reference_unref (cursor); meta_cursor_sprite_unref (cursor_sprite);
} }
else else
{ {