mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-11-18 09:00:34 +00:00
4cf4470fcd
Remove gdk_drawable_get_data(), gdk_drawable_set_data(), gdk_drawable_ref(), gdk_drawable_unref(), gdk_draw_string(), gdk_draw_text(), gdk_draw_text_wc()
639 lines
16 KiB
C
639 lines
16 KiB
C
/* GDK - The GIMP Drawing Kit
|
|
* Copyright (C) 1995-1999 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
*
|
|
* 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 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, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/*
|
|
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
|
|
* file for a list of people on the GTK+ Team.
|
|
*/
|
|
|
|
/*
|
|
* GTK+ DirectFB backend
|
|
* Copyright (C) 2001-2002 convergence integrated media GmbH
|
|
* Copyright (C) 2002-2004 convergence GmbH
|
|
* Written by Denis Oliver Kropp <dok@convergence.de> and
|
|
* Sven Neumann <sven@convergence.de>
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "gdk.h"
|
|
#include "gdkdirectfb.h"
|
|
#include "gdkprivate-directfb.h"
|
|
|
|
#include "gdkdnd.h"
|
|
#include "gdkproperty.h"
|
|
#include "gdkalias.h"
|
|
|
|
typedef struct _GdkDragContextPrivate GdkDragContextPrivate;
|
|
|
|
typedef enum
|
|
{
|
|
GDK_DRAG_STATUS_DRAG,
|
|
GDK_DRAG_STATUS_MOTION_WAIT,
|
|
GDK_DRAG_STATUS_ACTION_WAIT,
|
|
GDK_DRAG_STATUS_DROP
|
|
} GtkDragStatus;
|
|
|
|
/* Structure that holds information about a drag in progress.
|
|
* this is used on both source and destination sides.
|
|
*/
|
|
struct _GdkDragContextPrivate
|
|
{
|
|
GdkAtom local_selection;
|
|
|
|
guint16 last_x; /* Coordinates from last event */
|
|
guint16 last_y;
|
|
guint drag_status : 4; /* current status of drag */
|
|
};
|
|
|
|
/* Drag Contexts */
|
|
|
|
static GList *contexts = NULL;
|
|
static GdkDragContext *current_dest_drag = NULL;
|
|
|
|
|
|
#define GDK_DRAG_CONTEXT_PRIVATE_DATA(ctx) ((GdkDragContextPrivate *) GDK_DRAG_CONTEXT (ctx)->windowing_data)
|
|
|
|
static void gdk_drag_context_finalize (GObject *object);
|
|
|
|
G_DEFINE_TYPE (GdkDragContext, gdk_drag_context, G_TYPE_OBJECT)
|
|
|
|
static void
|
|
gdk_drag_context_init (GdkDragContext *dragcontext)
|
|
{
|
|
GdkDragContextPrivate *private;
|
|
|
|
private = G_TYPE_INSTANCE_GET_PRIVATE (dragcontext,
|
|
GDK_TYPE_DRAG_CONTEXT,
|
|
GdkDragContextPrivate);
|
|
|
|
dragcontext->windowing_data = private;
|
|
|
|
contexts = g_list_prepend (contexts, dragcontext);
|
|
}
|
|
|
|
static void
|
|
gdk_drag_context_class_init (GdkDragContextClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->finalize = gdk_drag_context_finalize;
|
|
|
|
g_type_class_add_private (object_class, sizeof (GdkDragContextPrivate));
|
|
}
|
|
|
|
static void
|
|
gdk_drag_context_finalize (GObject *object)
|
|
{
|
|
GdkDragContext *context = GDK_DRAG_CONTEXT (object);
|
|
|
|
g_list_free (context->targets);
|
|
|
|
if (context->source_window)
|
|
g_object_unref (context->source_window);
|
|
|
|
if (context->dest_window)
|
|
g_object_unref (context->dest_window);
|
|
|
|
contexts = g_list_remove (contexts, context);
|
|
|
|
G_OBJECT_CLASS (gdk_drag_context_parent_class)->finalize (object);
|
|
}
|
|
|
|
GdkDragContext *
|
|
gdk_drag_context_new (void)
|
|
{
|
|
return g_object_new (gdk_drag_context_get_type (), NULL);
|
|
}
|
|
|
|
static GdkDragContext *
|
|
gdk_drag_context_find (gboolean is_source,
|
|
GdkWindow *source,
|
|
GdkWindow *dest)
|
|
{
|
|
GdkDragContext *context;
|
|
GdkDragContextPrivate *private;
|
|
GList *list;
|
|
|
|
for (list = contexts; list; list = list->next)
|
|
{
|
|
context = (GdkDragContext *) list->data;
|
|
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
|
|
|
|
if ((!context->is_source == !is_source) &&
|
|
((source == NULL) ||
|
|
(context->source_window && (context->source_window == source))) &&
|
|
((dest == NULL) ||
|
|
(context->dest_window && (context->dest_window == dest))))
|
|
return context;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/************************** Public API ***********************/
|
|
|
|
void
|
|
_gdk_dnd_init (void)
|
|
{
|
|
}
|
|
|
|
/* Source side */
|
|
|
|
static void
|
|
local_send_leave (GdkDragContext *context,
|
|
guint32 time)
|
|
{
|
|
GdkEvent event;
|
|
|
|
if ((current_dest_drag != NULL) &&
|
|
(current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) &&
|
|
(current_dest_drag->source_window == context->source_window))
|
|
{
|
|
event.dnd.type = GDK_DRAG_LEAVE;
|
|
event.dnd.window = context->dest_window;
|
|
/* Pass ownership of context to the event */
|
|
event.dnd.context = current_dest_drag;
|
|
event.dnd.send_event = FALSE;
|
|
event.dnd.time = time;
|
|
|
|
current_dest_drag = NULL;
|
|
|
|
gdk_event_put (&event);
|
|
}
|
|
}
|
|
|
|
static void
|
|
local_send_enter (GdkDragContext *context,
|
|
guint32 time)
|
|
{
|
|
GdkDragContextPrivate *private;
|
|
GdkDragContext *new_context;
|
|
GdkEvent event;
|
|
|
|
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
|
|
|
|
if (!private->local_selection)
|
|
private->local_selection = gdk_atom_intern ("LocalDndSelection", FALSE);
|
|
|
|
if (current_dest_drag != NULL)
|
|
{
|
|
g_object_unref (current_dest_drag);
|
|
current_dest_drag = NULL;
|
|
}
|
|
|
|
new_context = gdk_drag_context_new ();
|
|
new_context->protocol = GDK_DRAG_PROTO_LOCAL;
|
|
new_context->is_source = FALSE;
|
|
|
|
new_context->source_window = g_object_ref (context->source_window);
|
|
|
|
new_context->dest_window = g_object_ref (context->dest_window);
|
|
|
|
new_context->targets = g_list_copy (context->targets);
|
|
|
|
gdk_window_set_events (new_context->source_window,
|
|
gdk_window_get_events (new_context->source_window) |
|
|
GDK_PROPERTY_CHANGE_MASK);
|
|
new_context->actions = context->actions;
|
|
|
|
event.dnd.type = GDK_DRAG_ENTER;
|
|
event.dnd.window = context->dest_window;
|
|
event.dnd.send_event = FALSE;
|
|
event.dnd.context = new_context;
|
|
event.dnd.time = time;
|
|
|
|
current_dest_drag = new_context;
|
|
|
|
(GDK_DRAG_CONTEXT_PRIVATE_DATA (new_context))->local_selection =
|
|
private->local_selection;
|
|
|
|
gdk_event_put (&event);
|
|
}
|
|
|
|
static void
|
|
local_send_motion (GdkDragContext *context,
|
|
gint x_root,
|
|
gint y_root,
|
|
GdkDragAction action,
|
|
guint32 time)
|
|
{
|
|
GdkEvent event;
|
|
|
|
if ((current_dest_drag != NULL) &&
|
|
(current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) &&
|
|
(current_dest_drag->source_window == context->source_window))
|
|
{
|
|
event.dnd.type = GDK_DRAG_MOTION;
|
|
event.dnd.window = current_dest_drag->dest_window;
|
|
event.dnd.send_event = FALSE;
|
|
event.dnd.context = current_dest_drag;
|
|
event.dnd.time = time;
|
|
event.dnd.x_root = x_root;
|
|
event.dnd.y_root = y_root;
|
|
|
|
current_dest_drag->suggested_action = action;
|
|
current_dest_drag->actions = action;
|
|
|
|
(GDK_DRAG_CONTEXT_PRIVATE_DATA (current_dest_drag))->last_x = x_root;
|
|
(GDK_DRAG_CONTEXT_PRIVATE_DATA (current_dest_drag))->last_y = y_root;
|
|
|
|
GDK_DRAG_CONTEXT_PRIVATE_DATA (context)->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
|
|
|
|
gdk_event_put (&event);
|
|
}
|
|
}
|
|
|
|
static void
|
|
local_send_drop (GdkDragContext *context,
|
|
guint32 time)
|
|
{
|
|
GdkEvent event;
|
|
|
|
if ((current_dest_drag != NULL) &&
|
|
(current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) &&
|
|
(current_dest_drag->source_window == context->source_window))
|
|
{
|
|
GdkDragContextPrivate *private;
|
|
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (current_dest_drag);
|
|
|
|
event.dnd.type = GDK_DROP_START;
|
|
event.dnd.window = current_dest_drag->dest_window;
|
|
event.dnd.send_event = FALSE;
|
|
event.dnd.context = current_dest_drag;
|
|
event.dnd.time = time;
|
|
event.dnd.x_root = private->last_x;
|
|
event.dnd.y_root = private->last_y;
|
|
|
|
gdk_event_put (&event);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gdk_drag_do_leave (GdkDragContext *context,
|
|
guint32 time)
|
|
{
|
|
if (context->dest_window)
|
|
{
|
|
switch (context->protocol)
|
|
{
|
|
case GDK_DRAG_PROTO_LOCAL:
|
|
local_send_leave (context, time);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_object_unref (context->dest_window);
|
|
context->dest_window = NULL;
|
|
}
|
|
}
|
|
|
|
GdkDragContext *
|
|
gdk_drag_begin (GdkWindow *window,
|
|
GList *targets)
|
|
{
|
|
GList *list;
|
|
GdkDragContext *new_context;
|
|
|
|
g_return_val_if_fail (window != NULL, NULL);
|
|
|
|
g_object_ref (window);
|
|
|
|
new_context = gdk_drag_context_new ();
|
|
new_context->is_source = TRUE;
|
|
new_context->source_window = window;
|
|
new_context->targets = NULL;
|
|
new_context->actions = 0;
|
|
|
|
for (list = targets; list; list = list->next)
|
|
new_context->targets = g_list_append (new_context->targets, list->data);
|
|
|
|
return new_context;
|
|
}
|
|
|
|
guint32
|
|
gdk_drag_get_protocol_for_display(GdkDisplay *display, guint32 xid,
|
|
GdkDragProtocol *protocol)
|
|
{
|
|
GdkWindow *window;
|
|
|
|
window = gdk_window_lookup ((GdkNativeWindow) xid);
|
|
|
|
if (window &&
|
|
g_object_get_data (G_OBJECT (window), "gdk-dnd-registered") != NULL)
|
|
{
|
|
*protocol = GDK_DRAG_PROTO_LOCAL;
|
|
return xid;
|
|
}
|
|
|
|
*protocol = GDK_DRAG_PROTO_NONE;
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
gdk_drag_find_window_for_screen (GdkDragContext *context,
|
|
GdkWindow *drag_window,
|
|
GdkScreen *screen,
|
|
gint x_root,
|
|
gint y_root,
|
|
GdkWindow **dest_window,
|
|
GdkDragProtocol *protocol)
|
|
{
|
|
GdkWindow *dest;
|
|
|
|
g_return_if_fail (context != NULL);
|
|
|
|
dest = gdk_window_get_pointer (NULL, &x_root, &y_root, NULL);
|
|
|
|
if (context->dest_window != dest)
|
|
{
|
|
guint32 recipient;
|
|
|
|
/* Check if new destination accepts drags, and which protocol */
|
|
if ((recipient = gdk_drag_get_protocol (GDK_WINDOW_DFB_ID (dest),
|
|
protocol)))
|
|
{
|
|
*dest_window = gdk_window_lookup ((GdkNativeWindow) recipient);
|
|
if (dest_window)
|
|
g_object_ref (*dest_window);
|
|
}
|
|
else
|
|
*dest_window = NULL;
|
|
}
|
|
else
|
|
{
|
|
*dest_window = context->dest_window;
|
|
if (*dest_window)
|
|
g_object_ref (*dest_window);
|
|
|
|
*protocol = context->protocol;
|
|
}
|
|
|
|
}
|
|
|
|
gboolean
|
|
gdk_drag_motion (GdkDragContext *context,
|
|
GdkWindow *dest_window,
|
|
GdkDragProtocol protocol,
|
|
gint x_root,
|
|
gint y_root,
|
|
GdkDragAction suggested_action,
|
|
GdkDragAction possible_actions,
|
|
guint32 time)
|
|
{
|
|
GdkDragContextPrivate *private;
|
|
|
|
g_return_val_if_fail (context != NULL, FALSE);
|
|
|
|
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
|
|
|
|
if (context->dest_window != dest_window)
|
|
{
|
|
GdkEvent event;
|
|
|
|
/* Send a leave to the last destination */
|
|
gdk_drag_do_leave (context, time);
|
|
private->drag_status = GDK_DRAG_STATUS_DRAG;
|
|
|
|
/* Check if new destination accepts drags, and which protocol */
|
|
if (dest_window)
|
|
{
|
|
context->dest_window = g_object_ref (dest_window);
|
|
context->protocol = protocol;
|
|
|
|
switch (protocol)
|
|
{
|
|
case GDK_DRAG_PROTO_LOCAL:
|
|
local_send_enter (context, time);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
context->suggested_action = suggested_action;
|
|
}
|
|
else
|
|
{
|
|
context->dest_window = NULL;
|
|
context->action = 0;
|
|
}
|
|
|
|
/* Push a status event, to let the client know that
|
|
* the drag changed
|
|
*/
|
|
|
|
event.dnd.type = GDK_DRAG_STATUS;
|
|
event.dnd.window = context->source_window;
|
|
/* We use this to signal a synthetic status. Perhaps
|
|
* we should use an extra field...
|
|
*/
|
|
event.dnd.send_event = TRUE;
|
|
event.dnd.context = context;
|
|
event.dnd.time = time;
|
|
|
|
gdk_event_put (&event);
|
|
}
|
|
else
|
|
{
|
|
context->suggested_action = suggested_action;
|
|
}
|
|
|
|
/* Send a drag-motion event */
|
|
|
|
private->last_x = x_root;
|
|
private->last_y = y_root;
|
|
|
|
if (context->dest_window)
|
|
{
|
|
if (private->drag_status == GDK_DRAG_STATUS_DRAG)
|
|
{
|
|
switch (context->protocol)
|
|
{
|
|
case GDK_DRAG_PROTO_LOCAL:
|
|
local_send_motion (context,
|
|
x_root, y_root, suggested_action, time);
|
|
break;
|
|
|
|
case GDK_DRAG_PROTO_NONE:
|
|
g_warning ("GDK_DRAG_PROTO_NONE is not valid in gdk_drag_motion()");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
gdk_drag_drop (GdkDragContext *context,
|
|
guint32 time)
|
|
{
|
|
g_return_if_fail (context != NULL);
|
|
|
|
if (context->dest_window)
|
|
{
|
|
switch (context->protocol)
|
|
{
|
|
case GDK_DRAG_PROTO_LOCAL:
|
|
local_send_drop (context, time);
|
|
break;
|
|
case GDK_DRAG_PROTO_NONE:
|
|
g_warning ("GDK_DRAG_PROTO_NONE is not valid in gdk_drag_drop()");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gdk_drag_abort (GdkDragContext *context,
|
|
guint32 time)
|
|
{
|
|
g_return_if_fail (context != NULL);
|
|
|
|
gdk_drag_do_leave (context, time);
|
|
}
|
|
|
|
/* Destination side */
|
|
|
|
void
|
|
gdk_drag_status (GdkDragContext *context,
|
|
GdkDragAction action,
|
|
guint32 time)
|
|
{
|
|
GdkDragContextPrivate *private;
|
|
GdkDragContext *src_context;
|
|
GdkEvent event;
|
|
|
|
g_return_if_fail (context != NULL);
|
|
|
|
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
|
|
|
|
src_context = gdk_drag_context_find (TRUE,
|
|
context->source_window,
|
|
context->dest_window);
|
|
|
|
if (src_context)
|
|
{
|
|
GdkDragContextPrivate *private;
|
|
|
|
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (src_context);
|
|
|
|
if (private->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
|
|
private->drag_status = GDK_DRAG_STATUS_DRAG;
|
|
|
|
event.dnd.type = GDK_DRAG_STATUS;
|
|
event.dnd.window = src_context->source_window;
|
|
event.dnd.send_event = FALSE;
|
|
event.dnd.context = src_context;
|
|
event.dnd.time = time;
|
|
|
|
src_context->action = action;
|
|
|
|
gdk_event_put (&event);
|
|
}
|
|
}
|
|
|
|
void
|
|
gdk_drop_reply (GdkDragContext *context,
|
|
gboolean ok,
|
|
guint32 time)
|
|
{
|
|
g_return_if_fail (context != NULL);
|
|
}
|
|
|
|
void
|
|
gdk_drop_finish (GdkDragContext *context,
|
|
gboolean success,
|
|
guint32 time)
|
|
{
|
|
GdkDragContextPrivate *private;
|
|
GdkDragContext *src_context;
|
|
GdkEvent event;
|
|
|
|
g_return_if_fail (context != NULL);
|
|
|
|
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
|
|
|
|
src_context = gdk_drag_context_find (TRUE,
|
|
context->source_window,
|
|
context->dest_window);
|
|
if (src_context)
|
|
{
|
|
g_object_ref (src_context);
|
|
|
|
event.dnd.type = GDK_DROP_FINISHED;
|
|
event.dnd.window = src_context->source_window;
|
|
event.dnd.send_event = FALSE;
|
|
event.dnd.context = src_context;
|
|
|
|
gdk_event_put (&event);
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
gdk_drag_drop_succeeded (GdkDragContext *context)
|
|
{
|
|
g_warning("gdk_drag_drop_succeeded unimplemented \n");
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
gdk_window_register_dnd (GdkWindow *window)
|
|
{
|
|
g_return_if_fail (window != NULL);
|
|
|
|
if (g_object_get_data (G_OBJECT (window), "gdk-dnd-registered") != NULL)
|
|
return;
|
|
|
|
g_object_set_data (G_OBJECT (window),
|
|
"gdk-dnd-registered",
|
|
GINT_TO_POINTER (TRUE));
|
|
|
|
}
|
|
|
|
/*************************************************************
|
|
* gdk_drag_get_selection:
|
|
* Returns the selection atom for the current source window
|
|
* arguments:
|
|
*
|
|
* results:
|
|
*************************************************************/
|
|
|
|
GdkAtom
|
|
gdk_drag_get_selection (GdkDragContext *context)
|
|
{
|
|
g_return_val_if_fail (context != NULL, GDK_NONE);
|
|
|
|
if (context->protocol == GDK_DRAG_PROTO_LOCAL)
|
|
return (GDK_DRAG_CONTEXT_PRIVATE_DATA (context))->local_selection;
|
|
else
|
|
return GDK_NONE;
|
|
}
|
|
|
|
#define __GDK_DND_X11_C__
|
|
#include "gdkaliasdef.c"
|