[gtk/wip/chergert/quartz4u: 139/146] macos: start on GdkDrag and surfaces for macos
- From: Christian Hergert <chergert src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk/wip/chergert/quartz4u: 139/146] macos: start on GdkDrag and surfaces for macos
- Date: Fri, 19 Jun 2020 18:20:30 +0000 (UTC)
commit f254c0dc8ed967d6e704d0f68732bea6a6450ab2
Author: Christian Hergert <chergert redhat com>
Date: Thu Jun 18 12:36:35 2020 -0700
macos: start on GdkDrag and surfaces for macos
This doesn't at all work other than being able to drag a window
around a bit. Still needs pasteboard interaction and better
completion of the drag operation.
Also, we haven't implemented GdkDrop.
gdk/macos/gdkmacosdrag-private.h | 41 +++
gdk/macos/gdkmacosdrag.c | 487 ++++++++++++++++++++++++++++++++
gdk/macos/gdkmacosdragsurface-private.h | 21 +-
gdk/macos/gdkmacosdragsurface.c | 84 +++++-
gdk/macos/gdkmacossurface.c | 52 +++-
gdk/macos/meson.build | 1 +
6 files changed, 665 insertions(+), 21 deletions(-)
---
diff --git a/gdk/macos/gdkmacosdrag-private.h b/gdk/macos/gdkmacosdrag-private.h
new file mode 100644
index 0000000000..7a7bf8a041
--- /dev/null
+++ b/gdk/macos/gdkmacosdrag-private.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2020 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GDK_MACOS_DRAG_PRIVATE_H__
+#define __GDK_MACOS_DRAG_PRIVATE_H__
+
+#include "gdkdragprivate.h"
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_MACOS_DRAG (gdk_macos_drag_get_type ())
+#define GDK_MACOS_DRAG(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MACOS_DRAG,
GdkMacosDrag))
+#define GDK_MACOS_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_MACOS_DRAG,
GdkMacosDragClass))
+#define GDK_IS_MACOS_DRAG(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MACOS_DRAG))
+#define GDK_IS_MACOS_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MACOS_DRAG))
+#define GDK_MACOS_DRAG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MACOS_DRAG,
GdkMacosDragClass))
+
+typedef struct _GdkMacosDrag GdkMacosDrag;
+typedef struct _GdkMacosDragClass GdkMacosDragClass;
+
+GType gdk_macos_drag_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __GDK_MACOS_DRAG_PRIVATE_H__ */
diff --git a/gdk/macos/gdkmacosdrag.c b/gdk/macos/gdkmacosdrag.c
new file mode 100644
index 0000000000..e0f47db822
--- /dev/null
+++ b/gdk/macos/gdkmacosdrag.c
@@ -0,0 +1,487 @@
+/*
+ * Copyright © 2020 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#include "config.h"
+
+#include "gdkdeviceprivate.h"
+#include "gdkintl.h"
+
+#include "gdkmacoscursor-private.h"
+#include "gdkmacosdisplay-private.h"
+#include "gdkmacosdrag-private.h"
+#include "gdkmacosdragsurface-private.h"
+
+#define BIG_STEP 20
+#define SMALL_STEP 1
+
+struct _GdkMacosDrag
+{
+ GdkDrag parent_instance;
+
+ GdkMacosDragSurface *drag_surface;
+
+ int hot_x;
+ int hot_y;
+
+ int last_x;
+ int last_y;
+};
+
+struct _GdkMacosDragClass
+{
+ GdkDragClass parent_class;
+};
+
+G_DEFINE_TYPE (GdkMacosDrag, gdk_macos_drag, GDK_TYPE_DRAG)
+
+enum {
+ PROP_0,
+ PROP_DRAG_SURFACE,
+ N_PROPS
+};
+
+static GParamSpec *properties [N_PROPS];
+
+static GdkSurface *
+gdk_macos_drag_get_drag_surface (GdkDrag *drag)
+{
+ return GDK_SURFACE (GDK_MACOS_DRAG (drag)->drag_surface);
+}
+
+static void
+gdk_macos_drag_set_hotspot (GdkDrag *drag,
+ int hot_x,
+ int hot_y)
+{
+ GdkMacosDrag *self = (GdkMacosDrag *)drag;
+
+ g_assert (GDK_IS_MACOS_DRAG (self));
+
+ self->hot_x = hot_x;
+ self->hot_y = hot_y;
+
+ /* TODO: move/resize to take point into account */
+}
+
+static void
+gdk_macos_drag_drop_done (GdkDrag *drag,
+ gboolean success)
+{
+ GdkMacosDrag *self = (GdkMacosDrag *)drag;
+
+ g_assert (GDK_IS_MACOS_DRAG (self));
+
+ gdk_surface_hide (GDK_SURFACE (self->drag_surface));
+
+ /* TODO: Apple HIG suggests doing a "zoomback" animation of
+ * the surface back towards the original position.
+ */
+
+ g_object_unref (drag);
+}
+
+static void
+gdk_macos_drag_set_cursor (GdkDrag *drag,
+ GdkCursor *cursor)
+{
+ NSCursor *nscursor;
+
+ g_assert (GDK_IS_MACOS_DRAG (drag));
+ g_assert (!cursor || GDK_IS_CURSOR (cursor));
+
+ nscursor = _gdk_macos_cursor_get_ns_cursor (cursor);
+
+ if (nscursor != NULL)
+ [nscursor set];
+}
+
+static void
+gdk_macos_drag_cancel (GdkDrag *drag,
+ GdkDragCancelReason reason)
+{
+ GdkMacosDrag *self = (GdkMacosDrag *)drag;
+
+ g_assert (GDK_IS_MACOS_DRAG (self));
+
+ g_print ("Drag cancel\n");
+
+ gdk_drag_drop_done (drag, FALSE);
+
+ //g_clear_pointer ((GdkSurface **)&self->drag_surface, gdk_surface_destroy);
+}
+
+static void
+gdk_macos_drag_drop_performed (GdkDrag *drag,
+ guint32 time)
+{
+ GdkMacosDrag *self = (GdkMacosDrag *)drag;
+
+ g_assert (GDK_IS_MACOS_DRAG (self));
+
+ //g_clear_pointer ((GdkSurface **)&self->drag_surface, gdk_surface_destroy);
+}
+
+static void
+gdk_drag_get_current_actions (GdkModifierType state,
+ gint button,
+ GdkDragAction actions,
+ GdkDragAction *suggested_action,
+ GdkDragAction *possible_actions)
+{
+ *suggested_action = 0;
+ *possible_actions = 0;
+
+ if ((button == GDK_BUTTON_MIDDLE || button == GDK_BUTTON_SECONDARY) && (actions & GDK_ACTION_ASK))
+ {
+ *suggested_action = GDK_ACTION_ASK;
+ *possible_actions = actions;
+ }
+ else if (state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK))
+ {
+ if ((state & GDK_SHIFT_MASK) && (state & GDK_CONTROL_MASK))
+ {
+ if (actions & GDK_ACTION_LINK)
+ {
+ *suggested_action = GDK_ACTION_LINK;
+ *possible_actions = GDK_ACTION_LINK;
+ }
+ }
+ else if (state & GDK_CONTROL_MASK)
+ {
+ if (actions & GDK_ACTION_COPY)
+ {
+ *suggested_action = GDK_ACTION_COPY;
+ *possible_actions = GDK_ACTION_COPY;
+ }
+ }
+ else
+ {
+ if (actions & GDK_ACTION_MOVE)
+ {
+ *suggested_action = GDK_ACTION_MOVE;
+ *possible_actions = GDK_ACTION_MOVE;
+ }
+ }
+ }
+ else
+ {
+ *possible_actions = actions;
+
+ if ((state & (GDK_ALT_MASK)) && (actions & GDK_ACTION_ASK))
+ *suggested_action = GDK_ACTION_ASK;
+ else if (actions & GDK_ACTION_COPY)
+ *suggested_action = GDK_ACTION_COPY;
+ else if (actions & GDK_ACTION_MOVE)
+ *suggested_action = GDK_ACTION_MOVE;
+ else if (actions & GDK_ACTION_LINK)
+ *suggested_action = GDK_ACTION_LINK;
+ }
+}
+
+static void
+gdk_drag_update (GdkDrag *drag,
+ gdouble x_root,
+ gdouble y_root,
+ GdkModifierType mods,
+ guint32 evtime)
+{
+ GdkMacosDrag *self = (GdkMacosDrag *)drag;
+ GdkDragAction suggested_action;
+ GdkDragAction possible_actions;
+
+ g_assert (GDK_IS_MACOS_DRAG (self));
+
+ self->last_x = x_root;
+ self->last_y = y_root;
+
+ gdk_drag_get_current_actions (mods,
+ GDK_BUTTON_PRIMARY,
+ gdk_drag_get_actions (drag),
+ &suggested_action,
+ &possible_actions);
+
+ _gdk_macos_drag_surface_drag_motion (self->drag_surface,
+ x_root,
+ y_root,
+ suggested_action,
+ possible_actions,
+ evtime);
+}
+
+static gboolean
+gdk_dnd_handle_motion_event (GdkDrag *drag,
+ GdkEvent *event)
+{
+ double x, y;
+ int x_root, y_root;
+
+ g_assert (GDK_IS_MACOS_DRAG (drag));
+ g_assert (event != NULL);
+
+ gdk_event_get_position (event, &x, &y);
+ x_root = event->surface->x + x;
+ y_root = event->surface->y + y;
+ gdk_drag_update (drag, x_root, y_root,
+ gdk_event_get_modifier_state (event),
+ gdk_event_get_time (event));
+
+ return TRUE;
+}
+
+static gboolean
+gdk_dnd_handle_grab_broken_event (GdkDrag *drag,
+ GdkEvent *event)
+{
+ GdkMacosDrag *self = GDK_MACOS_DRAG (drag);
+
+ gboolean is_implicit = gdk_grab_broken_event_get_implicit (event);
+ GdkSurface *grab_surface = gdk_grab_broken_event_get_grab_surface (event);
+
+ /* Don't cancel if we break the implicit grab from the initial button_press. */
+ if (is_implicit || grab_surface == (GdkSurface *)self->drag_surface)
+ return FALSE;
+
+ if (gdk_event_get_device (event) != gdk_drag_get_device (drag))
+ return FALSE;
+
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_ERROR);
+
+ return TRUE;
+}
+
+static gboolean
+gdk_dnd_handle_button_event (GdkDrag *drag,
+ GdkEvent *event)
+{
+ GdkMacosDrag *self = GDK_MACOS_DRAG (drag);
+
+ g_assert (GDK_IS_MACOS_DRAG (self));
+ g_assert (event != NULL);
+
+#if 0
+ /* FIXME: Check the button matches */
+ if (event->button != self->button)
+ return FALSE;
+#endif
+
+ if (gdk_drag_get_selected_action (drag) != 0)
+ g_signal_emit_by_name (drag, "drop-performed");
+ else
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_NO_TARGET);
+
+ return TRUE;
+}
+
+static gboolean
+gdk_dnd_handle_key_event (GdkDrag *drag,
+ GdkEvent *event)
+{
+ GdkMacosDrag *self = GDK_MACOS_DRAG (drag);
+ GdkModifierType state;
+ GdkDevice *pointer;
+ gint dx, dy;
+
+ dx = dy = 0;
+ state = gdk_event_get_modifier_state (event);
+ pointer = gdk_device_get_associated_device (gdk_event_get_device (event));
+
+ if (event->event_type == GDK_KEY_PRESS)
+ {
+ guint keyval = gdk_key_event_get_keyval (event);
+
+ switch (keyval)
+ {
+ case GDK_KEY_Escape:
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_USER_CANCELLED);
+ return TRUE;
+
+ case GDK_KEY_space:
+ case GDK_KEY_Return:
+ case GDK_KEY_ISO_Enter:
+ case GDK_KEY_KP_Enter:
+ case GDK_KEY_KP_Space:
+ if (gdk_drag_get_selected_action (drag) != 0)
+ g_signal_emit_by_name (drag, "drop-performed");
+ else
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_NO_TARGET);
+
+ return TRUE;
+
+ case GDK_KEY_Up:
+ case GDK_KEY_KP_Up:
+ dy = (state & GDK_ALT_MASK) ? -BIG_STEP : -SMALL_STEP;
+ break;
+
+ case GDK_KEY_Down:
+ case GDK_KEY_KP_Down:
+ dy = (state & GDK_ALT_MASK) ? BIG_STEP : SMALL_STEP;
+ break;
+
+ case GDK_KEY_Left:
+ case GDK_KEY_KP_Left:
+ dx = (state & GDK_ALT_MASK) ? -BIG_STEP : -SMALL_STEP;
+ break;
+
+ case GDK_KEY_Right:
+ case GDK_KEY_KP_Right:
+ dx = (state & GDK_ALT_MASK) ? BIG_STEP : SMALL_STEP;
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ /* The state is not yet updated in the event, so we need
+ * to query it here. We could use XGetModifierMapping, but
+ * that would be overkill.
+ */
+ _gdk_device_query_state (pointer, NULL, NULL, NULL, NULL, &state);
+
+ if (dx != 0 || dy != 0)
+ {
+ GdkDisplay *display = gdk_event_get_display ((GdkEvent *)event);
+
+ self->last_x += dx;
+ self->last_y += dy;
+
+ _gdk_macos_display_warp_pointer (GDK_MACOS_DISPLAY (display),
+ self->last_x,
+ self->last_y);
+ }
+
+ gdk_drag_update (drag,
+ self->last_x, self->last_y,
+ state,
+ gdk_event_get_time (event));
+
+ return TRUE;
+}
+
+static gboolean
+gdk_macos_drag_handle_event (GdkDrag *drag,
+ GdkEvent *event)
+{
+ g_assert (GDK_IS_MACOS_DRAG (drag));
+ g_assert (event != NULL);
+
+ switch ((guint) event->event_type)
+ {
+ case GDK_MOTION_NOTIFY:
+ return gdk_dnd_handle_motion_event (drag, event);
+
+ case GDK_BUTTON_RELEASE:
+ return gdk_dnd_handle_button_event (drag, event);
+
+ case GDK_KEY_PRESS:
+ case GDK_KEY_RELEASE:
+ return gdk_dnd_handle_key_event (drag, event);
+
+ case GDK_GRAB_BROKEN:
+ return gdk_dnd_handle_grab_broken_event (drag, event);
+
+ default:
+ return FALSE;
+ }
+}
+
+static void
+gdk_macos_drag_finalize (GObject *object)
+{
+ GdkMacosDrag *self = (GdkMacosDrag *)object;
+ GdkMacosDragSurface *drag_surface = g_steal_pointer (&self->drag_surface);
+
+ G_OBJECT_CLASS (gdk_macos_drag_parent_class)->finalize (object);
+
+ if (drag_surface)
+ gdk_surface_destroy (GDK_SURFACE (drag_surface));
+}
+
+static void
+gdk_macos_drag_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdkMacosDrag *self = GDK_MACOS_DRAG (object);
+
+ switch (prop_id)
+ {
+ case PROP_DRAG_SURFACE:
+ g_value_set_object (value, self->drag_surface);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gdk_macos_drag_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GdkMacosDrag *self = GDK_MACOS_DRAG (object);
+
+ switch (prop_id)
+ {
+ case PROP_DRAG_SURFACE:
+ self->drag_surface = g_value_dup_object (value);
+ self->last_x = GDK_SURFACE (self->drag_surface)->x;
+ self->last_y = GDK_SURFACE (self->drag_surface)->y;
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gdk_macos_drag_class_init (GdkMacosDragClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GdkDragClass *drag_class = GDK_DRAG_CLASS (klass);
+
+ object_class->finalize = gdk_macos_drag_finalize;
+ object_class->get_property = gdk_macos_drag_get_property;
+ object_class->set_property = gdk_macos_drag_set_property;
+
+ drag_class->get_drag_surface = gdk_macos_drag_get_drag_surface;
+ drag_class->set_hotspot = gdk_macos_drag_set_hotspot;
+ drag_class->drop_done = gdk_macos_drag_drop_done;
+ drag_class->set_cursor = gdk_macos_drag_set_cursor;
+ drag_class->cancel = gdk_macos_drag_cancel;
+ drag_class->drop_performed = gdk_macos_drag_drop_performed;
+ drag_class->handle_event = gdk_macos_drag_handle_event;
+
+ properties [PROP_DRAG_SURFACE] =
+ g_param_spec_object ("drag-surface",
+ P_("Drag Surface"),
+ P_("Drag Surface"),
+ GDK_TYPE_MACOS_DRAG_SURFACE,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+
+ g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+gdk_macos_drag_init (GdkMacosDrag *self)
+{
+}
diff --git a/gdk/macos/gdkmacosdragsurface-private.h b/gdk/macos/gdkmacosdragsurface-private.h
index 94dec116fc..cf7408f308 100644
--- a/gdk/macos/gdkmacosdragsurface-private.h
+++ b/gdk/macos/gdkmacosdragsurface-private.h
@@ -31,14 +31,19 @@ typedef struct _GdkMacosDragSurfaceClass GdkMacosDragSurfaceClass;
#define GDK_MACOS_DRAG_SURFACE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object),
GDK_TYPE_MACOS_DRAG_SURFACE, GdkMacosDragSurface))
#define GDK_IS_MACOS_DRAG_SURFACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object),
GDK_TYPE_MACOS_DRAG_SURFACE))
-GType _gdk_macos_drag_surface_get_type (void);
-GdkMacosSurface *_gdk_macos_drag_surface_new (GdkMacosDisplay *display,
- GdkSurface *parent,
- GdkFrameClock *frame_clock,
- int x,
- int y,
- int width,
- int height);
+GType _gdk_macos_drag_surface_get_type (void);
+GdkMacosSurface *_gdk_macos_drag_surface_new (GdkMacosDisplay *display,
+ GdkFrameClock *frame_clock,
+ int x,
+ int y,
+ int width,
+ int height);
+void _gdk_macos_drag_surface_drag_motion (GdkMacosDragSurface *self,
+ int x_root,
+ int y_root,
+ GdkDragAction suggested_action,
+ GdkDragAction possible_actions,
+ guint32 evtime);
G_END_DECLS
diff --git a/gdk/macos/gdkmacosdragsurface.c b/gdk/macos/gdkmacosdragsurface.c
index 000eb8f602..e678764ba2 100644
--- a/gdk/macos/gdkmacosdragsurface.c
+++ b/gdk/macos/gdkmacosdragsurface.c
@@ -22,6 +22,8 @@
#include "gdkdragsurfaceprivate.h"
#include "gdkmacosdragsurface-private.h"
+#include "gdkmacosdisplay-private.h"
+#include "gdkmacosutils-private.h"
struct _GdkMacosDragSurface
{
@@ -33,26 +35,37 @@ struct _GdkMacosDragSurfaceClass
GdkMacosSurfaceClass parent_instance;
};
+static gboolean
+_gdk_macos_drag_surface_present (GdkDragSurface *surface,
+ int width,
+ int height)
+{
+ g_assert (GDK_IS_MACOS_SURFACE (surface));
+
+ g_print ("presenting drag surface %dx%d\n", width, height);
+
+ _gdk_macos_surface_move_resize (GDK_MACOS_SURFACE (surface),
+ -1, -1,
+ width, height);
+
+ if (!GDK_SURFACE_IS_MAPPED (GDK_SURFACE (surface)))
+ _gdk_macos_surface_show (GDK_MACOS_SURFACE (surface));
+
+ return GDK_SURFACE_IS_MAPPED (GDK_SURFACE (surface));
+}
+
static void
drag_surface_iface_init (GdkDragSurfaceInterface *iface)
{
+ iface->present = _gdk_macos_drag_surface_present;
}
G_DEFINE_TYPE_WITH_CODE (GdkMacosDragSurface, _gdk_macos_drag_surface, GDK_TYPE_MACOS_SURFACE,
G_IMPLEMENT_INTERFACE (GDK_TYPE_DRAG_SURFACE, drag_surface_iface_init))
-static void
-_gdk_macos_drag_surface_finalize (GObject *object)
-{
- G_OBJECT_CLASS (_gdk_macos_drag_surface_parent_class)->finalize (object);
-}
-
static void
_gdk_macos_drag_surface_class_init (GdkMacosDragSurfaceClass *klass)
{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
- object_class->finalize = _gdk_macos_drag_surface_finalize;
}
static void
@@ -62,19 +75,66 @@ _gdk_macos_drag_surface_init (GdkMacosDragSurface *self)
GdkMacosSurface *
_gdk_macos_drag_surface_new (GdkMacosDisplay *display,
- GdkSurface *parent,
GdkFrameClock *frame_clock,
int x,
int y,
int width,
int height)
{
+ GDK_BEGIN_MACOS_ALLOC_POOL;
+
+ GdkMacosWindow *window;
+ GdkMacosSurface *self;
+ NSScreen *screen;
+ NSUInteger style_mask;
+ NSRect content_rect;
+ NSRect screen_rect;
+ int nx;
+ int ny;
+
g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (display), NULL);
g_return_val_if_fail (!frame_clock || GDK_IS_FRAME_CLOCK (frame_clock), NULL);
- g_return_val_if_fail (!parent || GDK_IS_MACOS_SURFACE (parent), NULL);
- return g_object_new (GDK_TYPE_MACOS_DRAG_SURFACE,
+ style_mask = NSWindowStyleMaskBorderless;
+
+ _gdk_macos_display_to_display_coords (display, x, y, &nx, &ny);
+
+ screen = _gdk_macos_display_get_screen_at_display_coords (display, nx, ny);
+ screen_rect = [screen frame];
+ nx -= screen_rect.origin.x;
+ ny -= screen_rect.origin.y;
+ content_rect = NSMakeRect (nx, ny - height, width, height);
+
+ window = [[GdkMacosWindow alloc] initWithContentRect:content_rect
+ styleMask:style_mask
+ backing:NSBackingStoreBuffered
+ defer:NO
+ screen:screen];
+
+ [window setOpaque:NO];
+ [window setBackgroundColor:[NSColor clearColor]];
+ [window setDecorated:NO];
+
+ self = g_object_new (GDK_TYPE_MACOS_DRAG_SURFACE,
"display", display,
"frame-clock", frame_clock,
+ "native", window,
NULL);
+
+ GDK_END_MACOS_ALLOC_POOL;
+
+ return g_steal_pointer (&self);
+}
+
+void
+_gdk_macos_drag_surface_drag_motion (GdkMacosDragSurface *self,
+ int x_root,
+ int y_root,
+ GdkDragAction suggested_action,
+ GdkDragAction possible_actions,
+ guint32 evtime)
+{
+ g_return_if_fail (GDK_IS_MACOS_DRAG_SURFACE (self));
+
+ _gdk_macos_surface_move (GDK_MACOS_SURFACE (self), x_root, y_root);
}
diff --git a/gdk/macos/gdkmacossurface.c b/gdk/macos/gdkmacossurface.c
index 7927519286..5f5051112d 100644
--- a/gdk/macos/gdkmacossurface.c
+++ b/gdk/macos/gdkmacossurface.c
@@ -32,6 +32,7 @@
#include "gdkmacosdevice.h"
#include "gdkmacosdisplay-private.h"
+#include "gdkmacosdrag-private.h"
#include "gdkmacosdragsurface-private.h"
#include "gdkmacosmonitor-private.h"
#include "gdkmacospopupsurface-private.h"
@@ -279,6 +280,54 @@ gdk_macos_surface_get_geometry (GdkSurface *surface,
*height = surface->height;
}
+static GdkDrag *
+gdk_macos_surface_drag_begin (GdkSurface *surface,
+ GdkDevice *device,
+ GdkContentProvider *content,
+ GdkDragAction actions,
+ double dx,
+ double dy)
+{
+ GdkMacosSurface *self = (GdkMacosSurface *)surface;
+ GdkMacosSurface *drag_surface;
+ GdkCursor *cursor;
+ GdkSeat *seat;
+ GdkDrag *drag;
+
+ g_assert (GDK_IS_MACOS_SURFACE (self));
+ g_assert (GDK_IS_MACOS_TOPLEVEL_SURFACE (self) ||
+ GDK_IS_MACOS_POPUP_SURFACE (self));
+ g_assert (GDK_IS_MACOS_DEVICE (device));
+ g_assert (GDK_IS_CONTENT_PROVIDER (content));
+
+ seat = gdk_device_get_seat (device);
+ drag_surface = _gdk_macos_surface_new (GDK_MACOS_DISPLAY (surface->display),
+ GDK_SURFACE_TEMP,
+ surface,
+ dx, dy,
+ 1, 1);
+ drag = g_object_new (GDK_TYPE_MACOS_DRAG,
+ "drag-surface", drag_surface,
+ "surface", surface,
+ "device", device,
+ "content", content,
+ "actions", actions,
+ NULL);
+
+ cursor = gdk_drag_get_cursor (GDK_DRAG (drag),
+ gdk_drag_get_selected_action (GDK_DRAG (drag)));
+ gdk_drag_set_cursor (GDK_DRAG (drag), cursor);
+
+ gdk_seat_ungrab (seat);
+
+ g_clear_object (&drag_surface);
+
+ /* Hold a reference until drop_done is called */
+ g_object_ref (drag);
+
+ return g_steal_pointer (&drag);
+}
+
static void
gdk_macos_surface_destroy (GdkSurface *surface,
gboolean foreign_destroy)
@@ -391,6 +440,7 @@ gdk_macos_surface_class_init (GdkMacosSurfaceClass *klass)
object_class->set_property = gdk_macos_surface_set_property;
surface_class->destroy = gdk_macos_surface_destroy;
+ surface_class->drag_begin = gdk_macos_surface_drag_begin;
surface_class->get_device_state = gdk_macos_surface_get_device_state;
surface_class->get_geometry = gdk_macos_surface_get_geometry;
surface_class->get_root_coords = gdk_macos_surface_get_root_coords;
@@ -448,7 +498,7 @@ _gdk_macos_surface_new (GdkMacosDisplay *display,
break;
case GDK_SURFACE_TEMP:
- ret = _gdk_macos_drag_surface_new (display, parent, frame_clock, x, y, width, height);
+ ret = _gdk_macos_drag_surface_new (display, frame_clock, x, y, width, height);
break;
default:
diff --git a/gdk/macos/meson.build b/gdk/macos/meson.build
index e657af0d74..4d6362f8cb 100644
--- a/gdk/macos/meson.build
+++ b/gdk/macos/meson.build
@@ -9,6 +9,7 @@ gdk_macos_sources = files([
'gdkmacosdisplay.c',
'gdkmacosdisplay-settings.c',
'gdkmacosdisplay-translate.c',
+ 'gdkmacosdrag.c',
'gdkmacosdragsurface.c',
'gdkmacoseventsource.c',
'gdkmacoskeymap.c',
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
