gtk/gdk/directfb/gdkdnd-directfb.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 &&
      GPOINTER_TO_INT (gdk_drawable_get_data (window, "gdk-dnd-registered")))
    {
      *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 (GPOINTER_TO_INT (gdk_drawable_get_data (window, "gdk-dnd-registered")))
    return;

  gdk_drawable_set_data (window, "gdk-dnd-registered",
                         GINT_TO_POINTER (TRUE), NULL);
}

/*************************************************************
 * 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"