dnd 2

This is needed for DND surfaces. We should probably test to see if it's
used for cursor surfaces at all.

src/backends/meta-cursor-private.h

@@ -30,7 +30,7 @@
 typedef struct {
   CoglTexture2D *texture;
   struct gbm_bo *bo;
-  int hot_x, hot_y;
+  int offset_x, offset_y;
 } MetaCursorImage;
 
 struct _MetaCursorReference {
@@ -41,11 +41,11 @@ struct _MetaCursorReference {
 };
 
 CoglTexture *meta_cursor_reference_get_cogl_texture (MetaCursorReference *cursor,
-                                                     int                 *hot_x,
-                                                     int                 *hot_y);
+                                                     int                 *offset_x,
+                                                     int                 *offset_y);
 
 struct gbm_bo *meta_cursor_reference_get_gbm_bo (MetaCursorReference *cursor,
-                                                 int                 *hot_x,
-                                                 int                 *hot_y);
+                                                 int                 *offset_x,
+                                                 int                 *offset_y);
 
 #endif /* META_CURSOR_PRIVATE_H */

src/backends/meta-cursor-renderer.c

@@ -35,13 +35,21 @@
 
 #include "meta-stage.h"
 
+typedef struct
+{
+  CoglTexture *texture;
+  MetaRectangle current_rect;
+  gboolean handled_by_backend;
+} MetaCursorLayer;
+
 struct _MetaCursorRendererPrivate
 {
   int current_x, current_y;
-  MetaRectangle current_rect;
+
+  MetaCursorLayer core_layer;
+  MetaCursorLayer dnd_layer;
 
   MetaCursorReference *displayed_cursor;
-  gboolean handled_by_backend;
 };
 typedef struct _MetaCursorRendererPrivate MetaCursorRendererPrivate;
 
@@ -53,18 +61,14 @@ queue_redraw (MetaCursorRenderer *renderer)
   MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
   MetaBackend *backend = meta_get_backend ();
   ClutterActor *stage = meta_backend_get_stage (backend);
-  CoglTexture *texture;
 
   /* During early initialization, we can have no stage */
   if (!stage)
     return;
 
-  if (priv->displayed_cursor && !priv->handled_by_backend)
-    texture = meta_cursor_reference_get_cogl_texture (priv->displayed_cursor, NULL, NULL);
-  else
-    texture = NULL;
-
-  meta_stage_set_cursor (META_STAGE (stage), texture, &priv->current_rect);
+  if (priv->core_layer.texture && !priv->core_layer.handled_by_backend)
+    meta_stage_set_cursor (META_STAGE (stage), layer->texture, &priv->current_rect);
+  meta_stage_set_dnd_surface (META_STAGE (stage), 
 }
 
 static gboolean
@@ -84,33 +88,68 @@ meta_cursor_renderer_init (MetaCursorRenderer *renderer)
 {
 }
 
+static void
+update_layer (MetaCursorRenderer *renderer,
+              MetaCursorLayer    *layer,
+              CoglTexture        *texture,
+              int                 offset_x,
+              int                 offset_y)
+{
+  MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
+
+  layer->texture = texture;
+
+  if (layer->texture)
+    {
+      layer->current_rect.x = priv->current_x + offset_x;
+      layer->current_rect.y = priv->current_y + offset_y;
+      layer->current_rect.width = cogl_texture_get_width (layer->texture);
+      layer->current_rect.height = cogl_texture_get_height (layer->texture);
+    }
+  else
+    {
+      layer->current_rect.x = 0;
+      layer->current_rect.y = 0;
+      layer->current_rect.width = 0;
+      layer->current_rect.height = 0;
+    }
+}
+
 static void
 update_cursor (MetaCursorRenderer *renderer)
 {
   MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
   gboolean handled_by_backend;
   gboolean should_redraw = FALSE;
+  CoglTexture *texture;
+  int hot_x, hot_y;
 
   if (priv->displayed_cursor)
     {
+<<<<<<< HEAD
       CoglTexture *texture;
-      int hot_x, hot_y;
+      int offset_x, offset_y;
 
-      texture = meta_cursor_reference_get_cogl_texture (priv->displayed_cursor, &hot_x, &hot_y);
+      texture = meta_cursor_reference_get_cogl_texture (priv->displayed_cursor, &offset_x, &offset_y);
 
-      priv->current_rect.x = priv->current_x - hot_x;
-      priv->current_rect.y = priv->current_y - hot_y;
+      priv->current_rect.x = priv->current_x + offset_x;
+      priv->current_rect.y = priv->current_y + offset_y;
       priv->current_rect.width = cogl_texture_get_width (COGL_TEXTURE (texture));
       priv->current_rect.height = cogl_texture_get_height (COGL_TEXTURE (texture));
+=======
+      texture = meta_cursor_reference_get_cogl_texture (priv->displayed_cursor, &hot_x, &hot_y);
+>>>>>>> 75e7834... dnd 2
     }
   else
     {
-      priv->current_rect.x = 0;
-      priv->current_rect.y = 0;
-      priv->current_rect.width = 0;
-      priv->current_rect.height = 0;
+      texture = NULL;
+      hot_x = 0;
+      hot_y = 0;
     }
 
+  update_layer (renderer, &priv->core_layer, texture, hot_x, hot_y);
+  update_layer (renderer, &priv->
+
   handled_by_backend = META_CURSOR_RENDERER_GET_CLASS (renderer)->update_cursor (renderer);
   if (handled_by_backend != priv->handled_by_backend)
     {
@@ -144,6 +183,17 @@ meta_cursor_renderer_set_cursor (MetaCursorRenderer  *renderer,
   update_cursor (renderer);
 }
 
+void
+meta_cursor_renderer_set_dnd_surface (MetaCursorRenderer *renderer,
+                                      CoglTexture        *texture,
+                                      int                 offset_x,
+                                      int                 offset_y)
+{
+  MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
+
+  update_layer (renderer, &priv->dnd_layer, 
+}
+
 void
 meta_cursor_renderer_set_position (MetaCursorRenderer *renderer,
                                    int x, int y)
@@ -171,5 +221,5 @@ meta_cursor_renderer_get_rect (MetaCursorRenderer *renderer)
 {
   MetaCursorRendererPrivate *priv = meta_cursor_renderer_get_instance_private (renderer);
 
-  return &priv->current_rect;
+  return &priv->core_layer.current_rect;
 }

src/backends/meta-cursor-tracker.c

@@ -310,6 +310,7 @@ meta_cursor_tracker_get_hot (MetaCursorTracker *tracker,
                              int               *y)
 {
   MetaCursorReference *cursor;
+  int offset_x, offset_y;
 
   g_return_if_fail (META_IS_CURSOR_TRACKER (tracker));
 
@@ -324,14 +325,19 @@ meta_cursor_tracker_get_hot (MetaCursorTracker *tracker,
     }
 
   if (cursor)
-    meta_cursor_reference_get_cogl_texture (cursor, x, y);
+    {
+      meta_cursor_reference_get_cogl_texture (cursor, &offset_x, &offset_y);
+    }
   else
     {
-      if (x)
-        *x = 0;
-      if (y)
-        *y = 0;
+      offset_x = 0;
+      offset_y = 0;
     }
+
+  if (x)
+    *x = -offset_x;
+  if (y)
+    *y = -offset_y;
 }
 
 void

src/backends/meta-cursor.c

@@ -352,25 +352,25 @@ meta_cursor_reference_from_buffer (struct wl_resource *buffer,
 
 CoglTexture *
 meta_cursor_reference_get_cogl_texture (MetaCursorReference *cursor,
-                                        int                 *hot_x,
-                                        int                 *hot_y)
+                                        int                 *offset_x,
+                                        int                 *offset_y)
 {
-  if (hot_x)
-    *hot_x = cursor->image.hot_x;
-  if (hot_y)
-    *hot_y = cursor->image.hot_y;
+  if (offset_x)
+    *offset_x = cursor->image.offset_x;
+  if (offset_y)
+    *offset_y = cursor->image.offset_y;
   return COGL_TEXTURE (cursor->image.texture);
 }
 
 struct gbm_bo *
 meta_cursor_reference_get_gbm_bo (MetaCursorReference *cursor,
-                                  int                 *hot_x,
-                                  int                 *hot_y)
+                                  int                 *offset_x,
+                                  int                 *offset_y)
 {
-  if (hot_x)
-    *hot_x = cursor->image.hot_x;
-  if (hot_y)
-    *hot_y = cursor->image.hot_y;
+  if (offset_x)
+    *offset_x = cursor->image.offset_x;
+  if (offset_y)
+    *offset_y = cursor->image.offset_y;
   return cursor->image.bo;
 }
 

src/backends/meta-cursor.h

@@ -34,8 +34,7 @@ MetaCursorReference * meta_cursor_reference_from_theme  (MetaCursor          cur
 #ifdef HAVE_WAYLAND
 #include <wayland-server.h>
 MetaCursorReference * meta_cursor_reference_from_buffer (struct wl_resource *buffer,
-                                                         int                 hot_x,
-                                                         int                 hot_y);
+                                                         int offset_x, int offset_y);
 #endif
 
 MetaCursor meta_cursor_reference_get_meta_cursor (MetaCursorReference *cursor);

src/backends/meta-stage.c

@@ -40,6 +40,7 @@ typedef struct {
 } MetaOverlay;
 
 struct _MetaStagePrivate {
+  MetaOverlay dnd_overlay;
   MetaOverlay cursor_overlay;
 };
 typedef struct _MetaStagePrivate MetaStagePrivate;
@@ -112,6 +113,7 @@ meta_stage_finalize (GObject *object)
   MetaStage *stage = META_STAGE (object);
   MetaStagePrivate *priv = meta_stage_get_instance_private (stage);
 
+  meta_overlay_free (&priv->dnd_overlay);
   meta_overlay_free (&priv->cursor_overlay);
 }
 
@@ -123,6 +125,7 @@ meta_stage_paint (ClutterActor *actor)
 
   CLUTTER_ACTOR_CLASS (meta_stage_parent_class)->paint (actor);
 
+  meta_overlay_paint (&priv->dnd_overlay);
   meta_overlay_paint (&priv->cursor_overlay);
 }
 
@@ -142,6 +145,7 @@ meta_stage_init (MetaStage *stage)
 {
   MetaStagePrivate *priv = meta_stage_get_instance_private (stage);
 
+  meta_overlay_init (&priv->dnd_overlay);
   meta_overlay_init (&priv->cursor_overlay);
 
   clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), FALSE);
@@ -183,6 +187,19 @@ queue_redraw_for_overlay (MetaStage   *stage,
     }
 }
 
+void
+meta_stage_set_dnd_surface (MetaStage     *stage,
+                            CoglTexture   *texture,
+                            MetaRectangle *rect)
+{
+  MetaStagePrivate *priv = meta_stage_get_instance_private (stage);
+
+  g_assert (meta_is_wayland_compositor ());
+
+  meta_overlay_set (&priv->dnd_overlay, texture, rect);
+  queue_redraw_for_overlay (stage, &priv->dnd_overlay);
+}
+
 void
 meta_stage_set_cursor (MetaStage     *stage,
                        CoglTexture   *texture,

src/backends/meta-stage.h

@@ -51,9 +51,14 @@ GType             meta_stage_get_type                (void) G_GNUC_CONST;
 
 ClutterActor     *meta_stage_new                     (void);
 
+void meta_stage_set_dnd_surface (MetaStage     *stage,
+                                 CoglTexture   *texture,
+                                 MetaRectangle *rect);
+
 void meta_stage_set_cursor (MetaStage     *stage,
                             CoglTexture   *texture,
                             MetaRectangle *rect);
+
 G_END_DECLS
 
 #endif /* META_STAGE_H */

src/backends/native/meta-cursor-renderer-native.c

@@ -72,16 +72,16 @@ set_crtc_cursor (MetaCursorRendererNative *native,
       struct gbm_bo *bo;
       union gbm_bo_handle handle;
       int width, height;
-      int hot_x, hot_y;
+      int offset_x, offset_y;
 
-      bo = meta_cursor_reference_get_gbm_bo (cursor, &hot_x, &hot_y);
+      bo = meta_cursor_reference_get_gbm_bo (cursor, &offset_x, &offset_y);
 
       handle = gbm_bo_get_handle (bo);
       width = gbm_bo_get_width (bo);
       height = gbm_bo_get_height (bo);
 
       drmModeSetCursor2 (priv->drm_fd, crtc->crtc_id, handle.u32,
-                         width, height, hot_x, hot_y);
+                         width, height, -offset_x, -offset_y);
     }
   else
     {

src/wayland/meta-wayland-surface.c

@@ -426,6 +426,9 @@ commit_pending_state (MetaWaylandSurface      *surface,
   if (!cairo_region_is_empty (pending->damage))
     surface_process_damage (surface, pending->damage);
 
+  surface->offset_x += pending->dx;
+  surface->offset_y += pending->dy;
+
   if (pending->opaque_region)
     {
       pending->opaque_region = scale_region (pending->opaque_region, surface->scale);

src/wayland/meta-wayland-surface.h

@@ -115,6 +115,8 @@ struct _MetaWaylandSurface
     GSList *pending_placement_ops;
   } sub;
 
+  int32_t offset_x, offset_y;
+
   gboolean has_set_geometry;
 
   /* All the pending state that wl_surface.commit will apply. */