blender/extern/xdnd/xdnd.c

/* xdnd.c, xdnd.h - C program library for handling the Xdnd protocol
   Copyright (C) 1996-2000 Paul Sheer

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307, USA.
 */


/* 
   Released 1998-08-07
   Changes:

   2000-08-08: INCR protocol implemented.

*/

/*
    DONE:
     - INCR protocol now implemented

    TODO:
     - action_choose_dialog not yet supported (never called)
     - widget_delete_selection not yet supported and DELETE requests are ignored
     - not yet tested with applications that only supported XDND 0 or 1
*/

#include <X11/Xlib.h>
#include <X11/X.h>
#include <X11/Xatom.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#include <sys/types.h>
#ifdef HAVE_UNISTD_H
#   include <unistd.h>
#endif

#ifdef HAVE_SYS_SELECT_H
#  include <sys/select.h>
#endif

#include "xdnd.h"

static void xdnd_send_enter (DndClass * dnd, Window window, Window from, Atom * typelist);
static void xdnd_send_position (DndClass * dnd, Window window, Window from, Atom action, int x, int y,
                                unsigned long etime);
static void xdnd_send_status (DndClass * dnd, Window window, Window from, int will_accept, int want_position,
                              int x, int y, int w, int h, Atom action);
static void xdnd_send_leave (DndClass * dnd, Window window, Window from);
static void xdnd_send_drop (DndClass * dnd, Window window, Window from, unsigned long etime);
static void xdnd_send_finished (DndClass * dnd, Window window, Window from, int error);
static int xdnd_convert_selection (DndClass * dnd, Window window, Window requester, Atom type);
static void xdnd_selection_send (DndClass * dnd, XSelectionRequestEvent * request, unsigned char *data,
                                 int length);
static int xdnd_get_selection (DndClass * dnd, Window from, Atom property, Window insert);


/* just to remind us : */

#if 0
typedef struct {
    int type;
    unsigned long serial;
    Bool send_event;
    Display *display;
    Window window;
    Atom message_type;
    int format;
    union {
        char b[20];
        short s[10];
        long l[5];
    } data;
} XClientMessageEvent;
XClientMessageEvent xclient;
#endif

/* #define DND_DEBUG */

#define xdnd_xfree(x) {if (x) { free (x); x = 0; }}

#ifdef DND_DEBUG

#include <sys/time.h>
#include <unistd.h>

char *xdnd_debug_milliseconds (void)
{
    struct timeval tv;
    static char r[22];
    gettimeofday (&tv, 0);
    sprintf (r, "%.2ld.%.3ld", tv.tv_sec % 100L, tv.tv_usec / 1000L);
    return r;
}

#define dnd_debug1(a)       printf("%s: %d: %s: " a "\n", __FILE__, __LINE__, xdnd_debug_milliseconds ())
#define dnd_debug2(a,b)     printf("%s: %d: %s: " a "\n", __FILE__, __LINE__, xdnd_debug_milliseconds (), b)
#define dnd_debug3(a,b,c)   printf("%s: %d: %s: " a "\n", __FILE__, __LINE__, xdnd_debug_milliseconds (), b, c)
#define dnd_debug4(a,b,c,d) printf("%s: %d: %s: " a "\n", __FILE__, __LINE__, xdnd_debug_milliseconds (), b, c, d)
#else
#define dnd_debug1(a)       
#define dnd_debug2(a,b)     
#define dnd_debug3(a,b,c)   
#define dnd_debug4(a,b,c,d) 
#endif

#define dnd_warning(a) fprintf (stderr, a)

#define dnd_version_at_least(a,b) ((a) >= (b))

static unsigned char dnd_copy_cursor_bits[] =
{
  0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x0f, 0x00, 0x02, 0x00, 0x08, 0x01,
  0x02, 0x00, 0x08, 0x01, 0x02, 0x00, 0x08, 0x01, 0x02, 0x00, 0xe8, 0x0f,
  0x02, 0x00, 0x08, 0x01, 0x02, 0x00, 0x08, 0x01, 0x02, 0x00, 0x08, 0x01,
  0x02, 0x00, 0x08, 0x00, 0x02, 0x04, 0x08, 0x00, 0x02, 0x0c, 0x08, 0x00,
  0x02, 0x1c, 0x08, 0x00, 0x02, 0x3c, 0x08, 0x00, 0x02, 0x7c, 0x08, 0x00,
  0x02, 0xfc, 0x08, 0x00, 0x02, 0xfc, 0x09, 0x00, 0x02, 0xfc, 0x0b, 0x00,
  0x02, 0x7c, 0x08, 0x00, 0xfe, 0x6d, 0x0f, 0x00, 0x00, 0xc4, 0x00, 0x00,
  0x00, 0xc0, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
  0x00, 0x00, 0x00, 0x00};

static unsigned char dnd_copy_mask_bits[] =
{
  0xff, 0xff, 0x1f, 0x00, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, 0x1f,
  0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f,
  0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f,
  0x07, 0x06, 0xfc, 0x1f, 0x07, 0x0e, 0xfc, 0x1f, 0x07, 0x1e, 0x1c, 0x00,
  0x07, 0x3e, 0x1c, 0x00, 0x07, 0x7e, 0x1c, 0x00, 0x07, 0xfe, 0x1c, 0x00,
  0x07, 0xfe, 0x1d, 0x00, 0x07, 0xfe, 0x1f, 0x00, 0x07, 0xfe, 0x1f, 0x00,
  0xff, 0xff, 0x1f, 0x00, 0xff, 0xff, 0x1e, 0x00, 0xff, 0xef, 0x1f, 0x00,
  0x00, 0xe6, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00,
  0x00, 0x80, 0x01, 0x00};

static unsigned char dnd_move_cursor_bits[] =
{
  0x00, 0x00, 0x00, 0xfe, 0xff, 0x0f, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08,
  0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08,
  0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x04, 0x08, 0x02, 0x0c, 0x08,
  0x02, 0x1c, 0x08, 0x02, 0x3c, 0x08, 0x02, 0x7c, 0x08, 0x02, 0xfc, 0x08,
  0x02, 0xfc, 0x09, 0x02, 0xfc, 0x0b, 0x02, 0x7c, 0x08, 0xfe, 0x6d, 0x0f,
  0x00, 0xc4, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01,
  0x00, 0x00, 0x00};

static unsigned char dnd_move_mask_bits[] =
{
  0xff, 0xff, 0x1f, 0xff, 0xff, 0x1f, 0xff, 0xff, 0x1f, 0x07, 0x00, 0x1c,
  0x07, 0x00, 0x1c, 0x07, 0x00, 0x1c, 0x07, 0x00, 0x1c, 0x07, 0x00, 0x1c,
  0x07, 0x00, 0x1c, 0x07, 0x06, 0x1c, 0x07, 0x0e, 0x1c, 0x07, 0x1e, 0x1c,
  0x07, 0x3e, 0x1c, 0x07, 0x7e, 0x1c, 0x07, 0xfe, 0x1c, 0x07, 0xfe, 0x1d,
  0x07, 0xfe, 0x1f, 0x07, 0xfe, 0x1f, 0xff, 0xff, 0x1f, 0xff, 0xff, 0x1e,
  0xff, 0xef, 0x1f, 0x00, 0xe6, 0x01, 0x00, 0xc0, 0x03, 0x00, 0xc0, 0x03,
  0x00, 0x80, 0x01};

static unsigned char dnd_link_cursor_bits[] =
{
  0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x0f, 0x00, 0x02, 0x00, 0x08, 0x01,
  0x02, 0x00, 0x88, 0x00, 0x02, 0x00, 0x48, 0x00, 0x02, 0x00, 0xe8, 0x0f,
  0x02, 0x00, 0x48, 0x00, 0x02, 0x00, 0x88, 0x00, 0x02, 0x00, 0x08, 0x01,
  0x02, 0x00, 0x08, 0x00, 0x02, 0x04, 0x08, 0x00, 0x02, 0x0c, 0x08, 0x00,
  0x02, 0x1c, 0x08, 0x00, 0x02, 0x3c, 0x08, 0x00, 0x02, 0x7c, 0x08, 0x00,
  0x02, 0xfc, 0x08, 0x00, 0x02, 0xfc, 0x09, 0x00, 0x02, 0xfc, 0x0b, 0x00,
  0x02, 0x7c, 0x08, 0x00, 0xfe, 0x6d, 0x0f, 0x00, 0x00, 0xc4, 0x00, 0x00,
  0x00, 0xc0, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
  0x00, 0x00, 0x00, 0x00};

static unsigned char dnd_link_mask_bits[] =
{
  0xff, 0xff, 0x1f, 0x00, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, 0x1f,
  0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f,
  0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f,
  0x07, 0x06, 0xfc, 0x1f, 0x07, 0x0e, 0xfc, 0x1f, 0x07, 0x1e, 0x1c, 0x00,
  0x07, 0x3e, 0x1c, 0x00, 0x07, 0x7e, 0x1c, 0x00, 0x07, 0xfe, 0x1c, 0x00,
  0x07, 0xfe, 0x1d, 0x00, 0x07, 0xfe, 0x1f, 0x00, 0x07, 0xfe, 0x1f, 0x00,
  0xff, 0xff, 0x1f, 0x00, 0xff, 0xff, 0x1e, 0x00, 0xff, 0xef, 0x1f, 0x00,
  0x00, 0xe6, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00,
  0x00, 0x80, 0x01, 0x00};

static unsigned char dnd_ask_cursor_bits[] =
{
  0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x0f, 0x00, 0x02, 0x00, 0x88, 0x03,
  0x02, 0x00, 0x48, 0x04, 0x02, 0x00, 0x08, 0x04, 0x02, 0x00, 0x08, 0x02,
  0x02, 0x00, 0x08, 0x01, 0x02, 0x00, 0x08, 0x01, 0x02, 0x00, 0x08, 0x00,
  0x02, 0x00, 0x08, 0x01, 0x02, 0x04, 0x08, 0x00, 0x02, 0x0c, 0x08, 0x00,
  0x02, 0x1c, 0x08, 0x00, 0x02, 0x3c, 0x08, 0x00, 0x02, 0x7c, 0x08, 0x00,
  0x02, 0xfc, 0x08, 0x00, 0x02, 0xfc, 0x09, 0x00, 0x02, 0xfc, 0x0b, 0x00,
  0x02, 0x7c, 0x08, 0x00, 0xfe, 0x6d, 0x0f, 0x00, 0x00, 0xc4, 0x00, 0x00,
  0x00, 0xc0, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
  0x00, 0x00, 0x00, 0x00};

static unsigned char dnd_ask_mask_bits[] =
{
  0xff, 0xff, 0x1f, 0x00, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, 0x1f,
  0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f,
  0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f, 0x07, 0x00, 0xfc, 0x1f,
  0x07, 0x06, 0xfc, 0x1f, 0x07, 0x0e, 0xfc, 0x1f, 0x07, 0x1e, 0x1c, 0x00,
  0x07, 0x3e, 0x1c, 0x00, 0x07, 0x7e, 0x1c, 0x00, 0x07, 0xfe, 0x1c, 0x00,
  0x07, 0xfe, 0x1d, 0x00, 0x07, 0xfe, 0x1f, 0x00, 0x07, 0xfe, 0x1f, 0x00,
  0xff, 0xff, 0x1f, 0x00, 0xff, 0xff, 0x1e, 0x00, 0xff, 0xef, 0x1f, 0x00,
  0x00, 0xe6, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00,
  0x00, 0x80, 0x01, 0x00};

static DndCursor dnd_cursors[] =
{
    {29, 25, 10, 10, dnd_copy_cursor_bits, dnd_copy_mask_bits, "XdndActionCopy", 0, 0, 0, 0},
    {21, 25, 10, 10, dnd_move_cursor_bits, dnd_move_mask_bits, "XdndActionMove", 0, 0, 0, 0},
    {29, 25, 10, 10, dnd_link_cursor_bits, dnd_link_mask_bits, "XdndActionLink", 0, 0, 0, 0},
    {29, 25, 10, 10, dnd_ask_cursor_bits, dnd_ask_mask_bits, "XdndActionAsk", 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};

void xdnd_reset (DndClass * dnd)
{
    dnd->stage = XDND_DROP_STAGE_IDLE;
    dnd->dragging_version = 0;
    dnd->internal_drag = 0;
    dnd->want_position = 0;
    dnd->ready_to_drop = 0;
    dnd->will_accept = 0;
    dnd->rectangle.x = dnd->rectangle.y = 0;
    dnd->rectangle.width = dnd->rectangle.height = 0;
    dnd->dropper_window = 0;
    dnd->dropper_toplevel = 0;
    dnd->dragger_window = 0;
    dnd->dragger_typelist = 0;
    dnd->desired_type = 0;
    dnd->time = 0;
}

void xdnd_init (DndClass * dnd, Display * display)
{
    DndCursor *cursor;
    XColor black, white;
    memset (dnd, 0, sizeof (*dnd));

    dnd->display = display;
    dnd->root_window = DefaultRootWindow (display);
    dnd->version = XDND_VERSION;

    dnd->XdndAware = XInternAtom (dnd->display, "XdndAware", False);
    dnd->XdndSelection = XInternAtom (dnd->display, "XdndSelection", False);
    dnd->XdndEnter = XInternAtom (dnd->display, "XdndEnter", False);
    dnd->XdndLeave = XInternAtom (dnd->display, "XdndLeave", False);
    dnd->XdndPosition = XInternAtom (dnd->display, "XdndPosition", False);
    dnd->XdndDrop = XInternAtom (dnd->display, "XdndDrop", False);
    dnd->XdndFinished = XInternAtom (dnd->display, "XdndFinished", False);
    dnd->XdndStatus = XInternAtom (dnd->display, "XdndStatus", False);
    dnd->XdndActionCopy = XInternAtom (dnd->display, "XdndActionCopy", False);
    dnd->XdndActionMove = XInternAtom (dnd->display, "XdndActionMove", False);
    dnd->XdndActionLink = XInternAtom (dnd->display, "XdndActionLink", False);
    dnd->XdndActionAsk = XInternAtom (dnd->display, "XdndActionAsk", False);
    dnd->XdndActionPrivate = XInternAtom (dnd->display, "XdndActionPrivate", False);
    dnd->XdndTypeList = XInternAtom (dnd->display, "XdndTypeList", False);
    dnd->XdndActionList = XInternAtom (dnd->display, "XdndActionList", False);
    dnd->XdndActionDescription = XInternAtom (dnd->display, "XdndActionDescription", False);

    dnd->Xdnd_NON_PROTOCOL_ATOM = XInternAtom (dnd->display, "JXSelectionWindowProperty", False);

    xdnd_reset (dnd);

    dnd->cursors = dnd_cursors;

    black.pixel = BlackPixel (dnd->display, DefaultScreen (dnd->display));
    white.pixel = WhitePixel (dnd->display, DefaultScreen (dnd->display));

    XQueryColor (dnd->display, DefaultColormap (dnd->display, DefaultScreen (dnd->display)), &black);
    XQueryColor (dnd->display, DefaultColormap (dnd->display, DefaultScreen (dnd->display)), &white);

    for (cursor = &dnd->cursors[0]; cursor->width; cursor++) {
        cursor->image_pixmap = XCreateBitmapFromData \
            (dnd->display, dnd->root_window, (char *) cursor->image_data, cursor->width, cursor->height);
        cursor->mask_pixmap = XCreateBitmapFromData \
            (dnd->display, dnd->root_window, (char *) cursor->mask_data, cursor->width, cursor->height);
        cursor->cursor = XCreatePixmapCursor (dnd->display, cursor->image_pixmap,
              cursor->mask_pixmap, &black, &white, cursor->x, cursor->y);
        XFreePixmap (dnd->display, cursor->image_pixmap);
        XFreePixmap (dnd->display, cursor->mask_pixmap);
        cursor->action = XInternAtom (dnd->display, cursor->_action, False);
    }
}

void xdnd_shut (DndClass * dnd)
{
    DndCursor *cursor;
    for (cursor = &dnd->cursors[0]; cursor->width; cursor++)
        XFreeCursor (dnd->display, cursor->cursor);
    memset (dnd, 0, sizeof (*dnd));
    return;
}


/* typelist is a null terminated array */
static int array_length (Atom * a)
{
    int n;
    for (n = 0; a[n]; n++);
    return n;
}

void xdnd_set_dnd_aware (DndClass * dnd, Window window, Atom * typelist)
{
    Window root_return, parent;
    unsigned int nchildren_return;
    Window *children_return = 0;
    int r, s;
    if(!window) return;
    if (dnd->widget_exists)
        if (!(*dnd->widget_exists) (dnd, window))
            return;
    s = XChangeProperty (dnd->display, window, dnd->XdndAware, XA_ATOM, 32, PropModeReplace,
                         (unsigned char *) &dnd->version, 1);
#if 1
    dnd_debug4 ("XChangeProperty() = %d, window = %ld, widget = %s", s, window, "<WIDGET>");
#endif
    if (s && typelist) {
        int n;
        n = array_length (typelist);
        if (n)
            s = XChangeProperty (dnd->display, window, dnd->XdndAware, XA_ATOM, 32, PropModeAppend,
                                 (unsigned char *) typelist, n);
    }
    r =
        XQueryTree (dnd->display, window, &root_return, &parent, &children_return,
                    &nchildren_return);
    if (children_return)
        XFree (children_return);
    if (r && parent != root_return)
        xdnd_set_dnd_aware (dnd, parent, typelist);
}

int xdnd_is_dnd_aware (DndClass * dnd, Window window, int *version, Atom * typelist)
{
    Atom actual;
    int format;
    unsigned long count, remaining;
    unsigned char *data = 0;
    Atom *types, *t;
    int result = 1;

    *version = 0;
    XGetWindowProperty (dnd->display, window, dnd->XdndAware,
                        0, 0x8000000L, False, XA_ATOM,
                        &actual, &format,
                        &count, &remaining, &data);

    if (actual != XA_ATOM || format != 32 || count == 0 || !data) {
        dnd_debug2 ("XGetWindowProperty failed in xdnd_is_dnd_aware - XdndAware = %ld", dnd->XdndAware);
        if (data)
            XFree (data);
        return 0;
    }
    types = (Atom *) data;
#if XDND_VERSION >= 3
    if (types[0] < 3) {
        if (data)
            XFree (data);
        return 0;
    }
#endif
    *version = dnd->version < types[0] ? dnd->version : types[0];        /* minimum */
    dnd_debug2 ("Using XDND version %d", *version);
    if (count > 1) {
        result = 0;
        for (t = typelist; *t; t++) {
            int j;
            for (j = 1; j < count; j++) {
                if (types[j] == *t) {
                    result = 1;
                    break;
                }
            }
            if (result)
                break;
        }
    }
    XFree (data);
    return result;
}

void xdnd_set_type_list (DndClass * dnd, Window window, Atom * typelist)
{
    int n;
    n = array_length (typelist);
    XChangeProperty (dnd->display, window, dnd->XdndTypeList, XA_ATOM, 32,
                     PropModeReplace, (unsigned char *) typelist, n);
}

/* result must be free'd */
void xdnd_get_type_list (DndClass * dnd, Window window, Atom ** typelist)
{
    Atom type, *a;
    int format, i;
    unsigned long count, remaining;
    unsigned char *data = NULL;

    *typelist = 0;

    XGetWindowProperty (dnd->display, window, dnd->XdndTypeList,
                        0, 0x8000000L, False, XA_ATOM,
                        &type, &format, &count, &remaining, &data);

    if (type != XA_ATOM || format != 32 || count == 0 || !data) {
        if (data)
            XFree (data);
        dnd_debug2 ("XGetWindowProperty failed in xdnd_get_type_list - dnd->XdndTypeList = %ld", dnd->XdndTypeList);
        return;
    }
    *typelist = malloc ((count + 1) * sizeof (Atom));
    a = (Atom *) data;
    for (i = 0; i < count; i++)
        (*typelist)[i] = a[i];
    (*typelist)[count] = 0;

    XFree (data);
}

void xdnd_get_three_types (DndClass * dnd, XEvent * xevent, Atom ** typelist)
{
    int i;
    *typelist = malloc ((XDND_THREE + 1) * sizeof (Atom));
    for (i = 0; i < XDND_THREE; i++)
        (*typelist)[i] = XDND_ENTER_TYPE (xevent, i);
    (*typelist)[XDND_THREE] = 0;        /* although (*typelist)[1] or (*typelist)[2] may also be set to nill */
}

/* result must be free'd */
static char *concat_string_list (char **t, int *bytes)
{
    int l, n;
    char *s;
    for (l = n = 0;; n++) {
        if (!t[n])
            break;
        if (!t[n][0])
            break;
        l += strlen (t[n]) + 1;
    }
    s = malloc (l + 1);
    for (l = n = 0;; n++) {
        if (!t[n])
            break;
        if (!(t[n][0]))
            break;
        strcpy (s + l, t[n]);
        l += strlen (t[n]) + 1;
    }
    *bytes = l;
    s[l] = '\0';
    return s;
}

void xdnd_set_actions (DndClass * dnd, Window window, Atom * actions, char **descriptions)
{
    int n, l;
    char *s;
    n = array_length (actions);

    XChangeProperty (dnd->display, window, dnd->XdndActionList, XA_ATOM, 32,
                     PropModeReplace, (unsigned char *) actions, n);

    s = concat_string_list (descriptions, &l);
    XChangeProperty (dnd->display, window, dnd->XdndActionList, XA_STRING, 8,
                     PropModeReplace, (unsigned char *) s, l);
    xdnd_xfree (s);
}

/* returns 1 on error or no actions, otherwise result must be free'd 
   xdnd_get_actions (window, &actions, &descriptions);
   free (actions); free (descriptions); */
int xdnd_get_actions (DndClass * dnd, Window window, Atom ** actions, char ***descriptions)
{
    Atom type, *a;
    int format, i;
    unsigned long count, dcount, remaining;
    unsigned char *data = 0, *r;

    *actions = 0;
    *descriptions = 0;
    XGetWindowProperty (dnd->display, window, dnd->XdndActionList,
                        0, 0x8000000L, False, XA_ATOM,
                        &type, &format, &count, &remaining, &data);

    if (type != XA_ATOM || format != 32 || count == 0 || !data) {
        if (data)
            XFree (data);
        return 1;
    }
    *actions = malloc ((count + 1) * sizeof (Atom));
    a = (Atom *) data;
    for (i = 0; i < count; i++)
        (*actions)[i] = a[i];
    (*actions)[count] = 0;

    XFree (data);

    data = 0;
    XGetWindowProperty (dnd->display, window, dnd->XdndActionDescription,
                        0, 0x8000000L, False, XA_STRING, &type, &format,
                        &dcount, &remaining, &data);

    if (type != XA_STRING || format != 8 || dcount == 0) {
        if (data)
            XFree (data);
        *descriptions = malloc ((count + 1) * sizeof (char *));
        dnd_warning ("XGetWindowProperty no property or wrong format for action descriptions");
        for (i = 0; i < count; i++)
            (*descriptions)[i] = "";
        (*descriptions)[count] = 0;
    } else {
        int l;
        l = (count + 1) * sizeof (char *);
        *descriptions = malloc (l + dcount);
        memcpy (*descriptions + l, data, dcount);
        XFree (data);
        data = (unsigned char *) *descriptions;
        data += l;
        l = 0;
        for (i = 0, r = data;; r += l + 1, i++) {
            l = strlen ((char *) r);
            if (!l || i >= count)
                break;
            (*descriptions)[i] = (char *) r;
        }
        for (; i < count; i++) {
            (*descriptions)[i] = "";
        }
        (*descriptions)[count] = 0;
    }
    return 0;
}

/* returns non-zero on cancel */
int xdnd_choose_action_dialog (DndClass * dnd, Atom * actions, char **descriptions, Atom * result)
{
    if (!actions[0])
        return 1;
    if (!dnd->action_choose_dialog) {        /* default to return the first action if no dialog set */
        *result = actions[0];
        return 0;
    }
    return (*dnd->action_choose_dialog) (dnd, descriptions, actions, result);
}

static void xdnd_send_event (DndClass * dnd, Window window, XEvent * xevent)
{
    dnd_debug4 ("xdnd_send_event(), window = %ld, l[0] = %ld, l[4] = %ld",
    window, xevent->xclient.data.l[0], xevent->xclient.data.l[4]);
    dnd_debug2 ("xdnd_send_event(), from widget widget %s", (char *) "<WIDGET>");
    XSendEvent (dnd->display, window, 0, 0, xevent);
}

static void xdnd_send_enter (DndClass * dnd, Window window, Window from, Atom * typelist)
{
    XEvent xevent;
    int n, i;
    n = array_length (typelist);

    memset (&xevent, 0, sizeof (xevent));

    xevent.xany.type = ClientMessage;
    xevent.xany.display = dnd->display;
    xevent.xclient.window = window;
    xevent.xclient.message_type = dnd->XdndEnter;
    xevent.xclient.format = 32;

    XDND_ENTER_SOURCE_WIN (&xevent) = from;
    XDND_ENTER_THREE_TYPES_SET (&xevent, n > XDND_THREE);
    XDND_ENTER_VERSION_SET (&xevent, dnd->version);
    for (i = 0; i < n && i < XDND_THREE; i++)
        XDND_ENTER_TYPE (&xevent, i) = typelist[i];
    xdnd_send_event (dnd, window, &xevent);
}

static void xdnd_send_position (DndClass * dnd, Window window, Window from, Atom action, int x, int y, unsigned long time)
{
    XEvent xevent;

    memset (&xevent, 0, sizeof (xevent));

    xevent.xany.type = ClientMessage;
    xevent.xany.display = dnd->display;
    xevent.xclient.window = window;
    xevent.xclient.message_type = dnd->XdndPosition;
    xevent.xclient.format = 32;

    XDND_POSITION_SOURCE_WIN (&xevent) = from;
    XDND_POSITION_ROOT_SET (&xevent, x, y);
    if (dnd_version_at_least (dnd->dragging_version, 1))
        XDND_POSITION_TIME (&xevent) = time;
    if (dnd_version_at_least (dnd->dragging_version, 2))
        XDND_POSITION_ACTION (&xevent) = action;

    xdnd_send_event (dnd, window, &xevent);
}

static void xdnd_send_status (DndClass * dnd, Window window, Window from, int will_accept, \
              int want_position, int x, int y, int w, int h, Atom action)
{
    XEvent xevent;

    memset (&xevent, 0, sizeof (xevent));

    xevent.xany.type = ClientMessage;
    xevent.xany.display = dnd->display;
    xevent.xclient.window = window;
    xevent.xclient.message_type = dnd->XdndStatus;
    xevent.xclient.format = 32;

    XDND_STATUS_TARGET_WIN (&xevent) = from;
    XDND_STATUS_WILL_ACCEPT_SET (&xevent, will_accept);
    if (will_accept)
        XDND_STATUS_WANT_POSITION_SET (&xevent, want_position);
    if (want_position)
        XDND_STATUS_RECT_SET (&xevent, x, y, w, h);
    if (dnd_version_at_least (dnd->dragging_version, 2))
        if (will_accept)
            XDND_STATUS_ACTION (&xevent) = action;

    xdnd_send_event (dnd, window, &xevent);
}

static void xdnd_send_leave (DndClass * dnd, Window window, Window from)
{
    XEvent xevent;

    memset (&xevent, 0, sizeof (xevent));

    xevent.xany.type = ClientMessage;
    xevent.xany.display = dnd->display;
    xevent.xclient.window = window;
    xevent.xclient.message_type = dnd->XdndLeave;
    xevent.xclient.format = 32;

    XDND_LEAVE_SOURCE_WIN (&xevent) = from;

    xdnd_send_event (dnd, window, &xevent);
}

static void xdnd_send_drop (DndClass * dnd, Window window, Window from, unsigned long time)
{
    XEvent xevent;

    memset (&xevent, 0, sizeof (xevent));

    xevent.xany.type = ClientMessage;
    xevent.xany.display = dnd->display;
    xevent.xclient.window = window;
    xevent.xclient.message_type = dnd->XdndDrop;
    xevent.xclient.format = 32;

    XDND_DROP_SOURCE_WIN (&xevent) = from;
    if (dnd_version_at_least (dnd->dragging_version, 1))
        XDND_DROP_TIME (&xevent) = time;

    xdnd_send_event (dnd, window, &xevent);
}

/* error is not actually used, i think future versions of the protocol should return an error status
   to the calling window with the XdndFinished client message */
static void xdnd_send_finished (DndClass * dnd, Window window, Window from, int error)
{
    XEvent xevent;

    memset (&xevent, 0, sizeof (xevent));

    xevent.xany.type = ClientMessage;
    xevent.xany.display = dnd->display;
    xevent.xclient.window = window;
    xevent.xclient.message_type = dnd->XdndFinished;
    xevent.xclient.format = 32;

    XDND_FINISHED_TARGET_WIN (&xevent) = from;

    xdnd_send_event (dnd, window, &xevent);
}

/* returns non-zero on error - i.e. no selection owner set. Type is of course the mime type */
static int xdnd_convert_selection (DndClass * dnd, Window window, Window requester, Atom type)
{
    if (!(window = XGetSelectionOwner (dnd->display, dnd->XdndSelection))) {
        dnd_debug1 ("xdnd_convert_selection(): XGetSelectionOwner failed");
        return 1;
    }
    XConvertSelection (dnd->display, dnd->XdndSelection, type,
                    dnd->Xdnd_NON_PROTOCOL_ATOM, requester, CurrentTime);
    return 0;
}

/* returns non-zero on error */
static int xdnd_set_selection_owner (DndClass * dnd, Window window, Atom type, Time time)
{
    if (!XSetSelectionOwner (dnd->display, dnd->XdndSelection, window, time)) {
        dnd_debug1 ("xdnd_set_selection_owner(): XSetSelectionOwner failed");
        return 1;
    }
    return 0;
}

static void xdnd_selection_send (DndClass * dnd, XSelectionRequestEvent * request, unsigned char *data, int length)
{
    XEvent xevent;
    dnd_debug2 ("      requestor = %ld", request->requestor);
    dnd_debug2 ("      property = %ld", request->property);
    dnd_debug2 ("      length = %d", length);
    XChangeProperty (dnd->display, request->requestor, request->property,
                     request->target, 8, PropModeReplace, data, length);
    xevent.xselection.type = SelectionNotify;
    xevent.xselection.property = request->property;
    xevent.xselection.display = request->display;
    xevent.xselection.requestor = request->requestor;
    xevent.xselection.selection = request->selection;
    xevent.xselection.target = request->target;
    xevent.xselection.time = request->time;
    xdnd_send_event (dnd, request->requestor, &xevent);
}

#if 0
/* respond to a notification that a primary selection has been sent */
int xdnd_get_selection (DndClass * dnd, Window from, Atom property, Window insert)
{
    long read;
    int error = 0;
    unsigned long remaining;
    if (!property)
        return 1;
    read = 0;
    do {
        unsigned char *s;
        Atom actual;
        int format;
        unsigned long count;
        if (XGetWindowProperty (dnd->display, insert, property, read / 4, 65536, 1,
                                AnyPropertyType, &actual, &format,
                                &count, &remaining,
                                &s) != Success) {
            XFree (s);
            return 1;
        }
        read += count;
        if (dnd->widget_insert_drop && !error)
            error = (*dnd->widget_insert_drop) (dnd, s, count, remaining, insert, from, actual);
        XFree (s);
    } while (remaining);
    return error;
}
#endif

static int paste_prop_internal (DndClass * dnd, Window from, Window insert, unsigned long prop, int delete_prop)
{
    long nread = 0;
    unsigned long nitems;
    unsigned long bytes_after;
    int error = 0;
    do {
        Atom actual_type;
        int actual_fmt;
        unsigned char *s = 0;
        if (XGetWindowProperty (dnd->display, insert, prop,
                                nread / 4, 65536, delete_prop,
                                AnyPropertyType, &actual_type, &actual_fmt,
                                &nitems, &bytes_after, &s) != Success) {
            XFree (s);
            return 1;
        }
        nread += nitems;
        if (dnd->widget_insert_drop && !error)
            error = (*dnd->widget_insert_drop) (dnd, s, nitems, bytes_after, insert, from, actual_fmt);
        XFree (s);
    } while (bytes_after);
    if (!nread)
        return 1;
    return 0;
}

/*
 * Respond to a notification that a primary selection has been sent (supports INCR)
 */
static int xdnd_get_selection (DndClass * dnd, Window from, Atom prop, Window insert)
{
    struct timeval tv, tv_start;
    unsigned long bytes_after;
    Atom actual_type;
    int actual_fmt;
    unsigned long nitems;
    unsigned char *s = 0;
    if (prop == None)
        return 1;
    if (XGetWindowProperty
        (dnd->display, insert, prop, 0, 8, False, AnyPropertyType, &actual_type, &actual_fmt,
         &nitems, &bytes_after, &s) != Success) {
        XFree (s);
        return 1;
    }
    XFree (s);
    if (actual_type != XInternAtom (dnd->display, "INCR", False))
        return paste_prop_internal (dnd, from, insert, prop, True);
    XDeleteProperty (dnd->display, insert, prop);
    gettimeofday (&tv_start, 0);
    for (;;) {
        long t;
        fd_set r;
        XEvent xe;
        if (XCheckMaskEvent (dnd->display, PropertyChangeMask, &xe)) {
            if (xe.type == PropertyNotify && xe.xproperty.state == PropertyNewValue) {
/* time between arrivals of data */
                gettimeofday (&tv_start, 0);
                if (paste_prop_internal (dnd, from, insert, prop, True))
                    break;
            }
        } else {
            tv.tv_sec = 0;
            tv.tv_usec = 10000;
            FD_ZERO (&r);
            FD_SET (ConnectionNumber (dnd->display), &r);
            select (ConnectionNumber (dnd->display) + 1, &r, 0, 0, &tv);
            if (FD_ISSET (ConnectionNumber (dnd->display), &r))
                continue;
        }
        gettimeofday (&tv, 0);
        t = (tv.tv_sec - tv_start.tv_sec) * 1000000L + (tv.tv_usec - tv_start.tv_usec);
/* no data for five seconds, so quit */
        if (t > 5000000L)
            return 1;
    }
    return 0;
}


int outside_rectangle (int x, int y, XRectangle * r)
{
    return (x < r->x || y < r->y || x >= r->x + r->width || y >= r->y + r->height);
}

/* avoids linking with the maths library */
static float xdnd_sqrt (float x)
{
    float last_ans, ans = 2, a;
    if (x <= 0.0)
        return 0.0;
    do {
        last_ans = ans;
        ans = (ans + x / ans) / 2;
        a = (ans - last_ans) / ans;
        if (a < 0.0)
            a = (-a);
    } while (a > 0.001);
    return ans;
}

#define print_marks print_win_marks(from,__FILE__,__LINE__);

/* returns action on success, 0 otherwise */
Atom xdnd_drag (DndClass * dnd, Window from, Atom action, Atom * typelist)
{
    XEvent xevent, xevent_temp;
    Window over_window = 0, last_window = 0;
#if XDND_VERSION >= 3
    Window last_dropper_toplevel = 0;
    int internal_dropable = 1;
#endif
    int n;
    DndCursor *cursor;
    float x_mouse, y_mouse;
    int result = 0, dnd_aware;

    if (!typelist)
        dnd_warning ("xdnd_drag() called with typelist = 0");

/* first wait until the mouse moves more than five pixels */
    do {
        XNextEvent (dnd->display, &xevent);
        if (xevent.type == ButtonRelease) {
            dnd_debug1 ("button release - no motion");
            XSendEvent (dnd->display, xevent.xany.window, 0, ButtonReleaseMask, &xevent);
            return 0;
        }
    } while (xevent.type != MotionNotify);

    x_mouse = (float) xevent.xmotion.x_root;
    y_mouse = (float) xevent.xmotion.y_root;

    if (!dnd->drag_threshold)
        dnd->drag_threshold = 4.0;
    for (;;) {
        XNextEvent (dnd->display, &xevent);
        if (xevent.type == MotionNotify)
            if (xdnd_sqrt ((x_mouse - xevent.xmotion.x_root) * (x_mouse - xevent.xmotion.x_root) +
                           (y_mouse - xevent.xmotion.y_root) * (y_mouse - xevent.xmotion.y_root)) > dnd->drag_threshold)
                break;
        if (xevent.type == ButtonRelease) {
            XSendEvent (dnd->display, xevent.xany.window, 0, ButtonReleaseMask, &xevent);
            return 0;
        }
    }

    dnd_debug1 ("moved 5 pixels - going to drag");

    n = array_length (typelist);
    if (n > XDND_THREE)
        xdnd_set_type_list (dnd, from, typelist);

    xdnd_reset (dnd);

    dnd->stage = XDND_DRAG_STAGE_DRAGGING;

    for (cursor = &dnd->cursors[0]; cursor->width; cursor++)
        if (cursor->action == action)
            break;
    if (!cursor->width)
        cursor = &dnd->cursors[0];

/* the mouse has been dragged a little, so this is a drag proper */
    if (XGrabPointer (dnd->display, dnd->root_window, False,
                      ButtonMotionMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
                      GrabModeAsync, GrabModeAsync, None,
                      cursor->cursor, CurrentTime) != GrabSuccess)
        dnd_debug1 ("Unable to grab pointer");


    while (xevent.xany.type != ButtonRelease) {
        XAllowEvents (dnd->display, SyncPointer, CurrentTime);
        XNextEvent (dnd->display, &xevent);
        switch (xevent.type) {
        case Expose:
            if (dnd->handle_expose_events)
                (*dnd->handle_expose_events) (dnd, &xevent);
            break;
        case EnterNotify:
/* this event is not actually reported, so we find out by ourselves from motion events */
            break;
        case LeaveNotify:
/* this event is not actually reported, so we find out by ourselves from motion events */
            break;
        case ButtonRelease:
/* done, but must send a leave event */
            dnd_debug1 ("ButtonRelease - exiting event loop");
            break;
        case MotionNotify:
            dnd_aware = 0;
            dnd->dropper_toplevel = 0;
            memcpy (&xevent_temp, &xevent, sizeof (xevent));
            xevent.xmotion.subwindow = xevent.xmotion.window;
            {
                Window root_return, child_return;
                int x_temp, y_temp;
                unsigned int mask_return;
                while (XQueryPointer (dnd->display, xevent.xmotion.subwindow, &root_return, &child_return,
                                      &x_temp, &y_temp, &xevent.xmotion.x,
                                      &xevent.xmotion.y, &mask_return)) {
#if XDND_VERSION >= 3
                    if (!dnd_aware) {
                        if ((dnd_aware = xdnd_is_dnd_aware (dnd, xevent.xmotion.subwindow, &dnd->dragging_version, typelist))) {
                            dnd->dropper_toplevel = xevent.xmotion.subwindow;
                            xevent.xmotion.x_root = x_temp;
                            xevent.xmotion.y_root = y_temp;
                        }
                    }
#else
                    xevent.xmotion.x_root = x_temp;
                    xevent.xmotion.y_root = y_temp;
#endif
                    if (!child_return)
                        goto found_descendent;
                    xevent.xmotion.subwindow = child_return;
                }
                break;
            }
          found_descendent:

/* last_window is just for debug purposes */
            if (last_window != xevent.xmotion.subwindow) {
                dnd_debug2 ("window crossing to %ld", xevent.xmotion.subwindow);
                dnd_debug2 ("  current window is %ld", over_window);
                dnd_debug3 ("     last_window = %ld, xmotion.subwindow = %ld", last_window, xevent.xmotion.subwindow);
#if XDND_VERSION >= 3
                dnd_debug3 ("     dropper_toplevel = %ld, last_dropper_toplevel.subwindow = %ld", dnd->dropper_toplevel, last_dropper_toplevel);
#endif
                dnd_debug3 ("     dnd_aware = %d, dnd->options & XDND_OPTION_NO_HYSTERESIS = %ld", dnd_aware, (long) dnd->options & XDND_OPTION_NO_HYSTERESIS);
            }

#if XDND_VERSION < 3
/* is the new window dnd aware? if not stay in the old window */
            if (over_window != xevent.xmotion.subwindow &&
                last_window != xevent.xmotion.subwindow &&
                (
                    (dnd_aware = xdnd_is_dnd_aware (dnd, xevent.xmotion.subwindow, &dnd->dragging_version, typelist))
                    ||
                    (dnd->options & XDND_OPTION_NO_HYSTERESIS)
                ))
#else
            internal_dropable = 1;
            if (dnd->widget_exists && (*dnd->widget_exists) (dnd, xevent.xmotion.subwindow))
                if (!xdnd_is_dnd_aware (dnd, xevent.xmotion.subwindow, &dnd->dragging_version, typelist))
                    internal_dropable = 0;
            dnd_debug3 ("dnd->dropper_toplevel = %ld, last_dropper_toplevel = %ld\n", dnd->dropper_toplevel, last_dropper_toplevel);
            if ((dnd->dropper_toplevel != last_dropper_toplevel ||
                last_window != xevent.xmotion.subwindow) && internal_dropable &&
                (
                    (dnd_aware)
                    ||
                    (dnd->options & XDND_OPTION_NO_HYSTERESIS)
                ))
#endif
            {
/* leaving window we were over */
                if (over_window) {
                    if (dnd->stage == XDND_DRAG_STAGE_ENTERED) {
                        dnd_debug1 ("got leave at right stage");
                        dnd->stage = XDND_DRAG_STAGE_DRAGGING;
                        if (dnd->internal_drag) {
                            dnd_debug1 ("  our own widget");
                            if (dnd->widget_apply_leave)
                                (*dnd->widget_apply_leave) (dnd, over_window);
                        } else {
                            dnd_debug1 ("  not our widget - sending XdndLeave");
#if XDND_VERSION < 3
                            xdnd_send_leave (dnd, over_window, from);
#else
                            if (dnd->dropper_toplevel != last_dropper_toplevel) {
                                xdnd_send_leave (dnd, last_dropper_toplevel, from);
                            } else {
                                dnd_debug1 ("    not sending leave --> dnd->dropper_toplevel == last_dropper_toplevel");
                            }
#endif
                        }
                        dnd->internal_drag = 0;
                        dnd->dropper_window = 0;
                        dnd->ready_to_drop = 0;
                    } else {
                        dnd_debug1 ("got leave at wrong stage - ignoring");
                    }
                }
/* entering window we are currently over */
                over_window = xevent.xmotion.subwindow;
                if (dnd_aware) {
                    dnd_debug1 ("  is dnd aware");
                    dnd->stage = XDND_DRAG_STAGE_ENTERED;
                    if (dnd->widget_exists && (*dnd->widget_exists) (dnd, over_window))
                        dnd->internal_drag = 1;
                    if (dnd->internal_drag) {
                        dnd_debug1 ("    our own widget");
                    } else {
                        dnd_debug2 ("    not our widget - sending XdndEnter to %ld", over_window);
#if XDND_VERSION < 3
                        xdnd_send_enter (dnd, over_window, from, typelist);
#else
                        if (dnd->dropper_toplevel != last_dropper_toplevel)
                            xdnd_send_enter (dnd, dnd->dropper_toplevel, from, typelist);
#endif
                    }
                    dnd->want_position = 1;
                    dnd->ready_to_drop = 0;
                    dnd->rectangle.width = dnd->rectangle.height = 0;
                    dnd->dropper_window = over_window;
/* we want an additional motion event in case the pointer enters and then stops */
                    XSendEvent (dnd->display, from, 0, ButtonMotionMask, &xevent_temp);
                    XSync (dnd->display, 0);
                }
#if XDND_VERSION >= 3
                last_dropper_toplevel = dnd->dropper_toplevel;
#endif
/* we are now officially in a new window */
            } else {
/* got here, so we are just moving `inside' the same window */
                if (dnd->stage == XDND_DRAG_STAGE_ENTERED) {
                    dnd->supported_action = dnd->XdndActionCopy;
                    dnd_debug1 ("got motion at right stage");
                    dnd->x = xevent.xmotion.x_root;
                    dnd->y = xevent.xmotion.y_root;
                    if (dnd->want_position || outside_rectangle (dnd->x, dnd->y, &dnd->rectangle)) {
                        dnd_debug1 ("  want position and outside rectangle");
                        if (dnd->internal_drag) {
                            dnd_debug1 ("    our own widget");
                            dnd->ready_to_drop = (*dnd->widget_apply_position) (dnd, over_window, from,
                                                                                action, dnd->x, dnd->y, xevent.xmotion.time, typelist,
                                                                                &dnd->want_position, &dnd->supported_action, &dnd->desired_type, &dnd->rectangle);
                            /* if not ready, keep sending positions, this check is repeated below for XdndStatus from external widgets */
                            if (!dnd->ready_to_drop) {
                                dnd->want_position = 1;
                                dnd->rectangle.width = dnd->rectangle.height = 0;
                            }
                            dnd_debug2 ("      return action=%ld", dnd->supported_action);
                        } else {
#if XDND_VERSION < 3
                            dnd_debug3 ("    not our own widget - sending XdndPosition to %ld, action %ld", over_window, action);
                            xdnd_send_position (dnd, over_window, from, action, dnd->x, dnd->y, xevent.xmotion.time);
#else
                            dnd_debug3 ("    not our own widget - sending XdndPosition to %ld, action %ld", dnd->dropper_toplevel, action);
                            xdnd_send_position (dnd, dnd->dropper_toplevel, from, action, dnd->x, dnd->y, xevent.xmotion.time);
#endif
                        }
                    } else if (dnd->want_position) {
                        dnd_debug1 ("  inside rectangle");
                    } else {
                        dnd_debug1 ("  doesn't want position");
                    }
                }
            }
            last_window = xevent.xmotion.subwindow;
            break;
        case ClientMessage:
            dnd_debug1 ("ClientMessage recieved");
            if (xevent.xclient.message_type == dnd->XdndStatus && !dnd->internal_drag) {
                dnd_debug1 ("  XdndStatus recieved");
                if (dnd->stage == XDND_DRAG_STAGE_ENTERED 
#if XDND_VERSION < 3
                        && XDND_STATUS_TARGET_WIN (&xevent) == dnd->dropper_window
#endif
                ) {
                    dnd_debug1 ("    XdndStatus stage correct, dropper window correct");
                    dnd->want_position = XDND_STATUS_WANT_POSITION (&xevent);
                    dnd->ready_to_drop = XDND_STATUS_WILL_ACCEPT (&xevent);
                    dnd->rectangle.x = XDND_STATUS_RECT_X (&xevent);
                    dnd->rectangle.y = XDND_STATUS_RECT_Y (&xevent);
                    dnd->rectangle.width = XDND_STATUS_RECT_WIDTH (&xevent);
                    dnd->rectangle.height = XDND_STATUS_RECT_HEIGHT (&xevent);
                    dnd->supported_action = dnd->XdndActionCopy;
                    if (dnd_version_at_least (dnd->dragging_version, 2))
                        dnd->supported_action = XDND_STATUS_ACTION (&xevent);
                    dnd_debug3 ("      return action=%ld, ready=%d", dnd->supported_action, dnd->ready_to_drop);
                    /* if not ready, keep sending positions, this check is repeated above for internal widgets */
                    if (!dnd->ready_to_drop) {
                        dnd->want_position = 1;
                        dnd->rectangle.width = dnd->rectangle.height = 0;
                    }
                    dnd_debug3 ("      rectangle = (x=%d, y=%d, ", dnd->rectangle.x, dnd->rectangle.y);
                    dnd_debug4                               ("w=%d, h=%d), want_position=%d\n", dnd->rectangle.width, dnd->rectangle.height, dnd->want_position);
                }
#if XDND_VERSION < 3
                else if (XDND_STATUS_TARGET_WIN (&xevent) != dnd->dropper_window) {
                    dnd_debug3 ("    XdndStatus XDND_STATUS_TARGET_WIN (&xevent) = %ld, dnd->dropper_window = %ld", XDND_STATUS_TARGET_WIN (&xevent), dnd->dropper_window);
                }
#endif
                else {
                    dnd_debug2 ("    XdndStatus stage incorrect dnd->stage = %d", dnd->stage);
                }
            }
            break;
        case SelectionRequest:{
/* the target widget MAY request data, so wait for SelectionRequest */
                int length = 0;
                unsigned char *data = 0;
                dnd_debug1 ("SelectionRequest - getting widget data");

                (*dnd->widget_get_data) (dnd, from, &data, &length, xevent.xselectionrequest.target);
                if (data) {
                    dnd_debug1 ("  sending selection");
                    xdnd_selection_send (dnd, &xevent.xselectionrequest, data, length);
                    xdnd_xfree (data);
                }
            }
            break;
        }
    }

    if (dnd->ready_to_drop) {
        Time time;
        dnd_debug1 ("ready_to_drop - sending XdndDrop");
        time = xevent.xbutton.time;
        if (dnd->internal_drag) {
/* we are dealing with our own widget, no need to send drop events, just put the data straight */
            int length = 0;
            unsigned char *data = 0;
            if (dnd->widget_insert_drop) {
                (*dnd->widget_get_data) (dnd, from, &data, &length, dnd->desired_type);
                if (data) {
                    if (!(*dnd->widget_insert_drop) (dnd, data, length, 0, dnd->dropper_window, from, dnd->desired_type)) {
                        result = dnd->supported_action;                /* success - so return action to caller */
                        dnd_debug1 ("  inserted data into widget - success");
                    } else {
                        dnd_debug1 ("  inserted data into widget - failed");
                    }
                    xdnd_xfree (data);
                } else {
                    dnd_debug1 ("  got data from widget, but data is null");
                }
            }
        } else {
            xdnd_set_selection_owner (dnd, from, dnd->desired_type, time);
#if XDND_VERSION < 3
            xdnd_send_drop (dnd, dnd->dropper_window, from, time);
#else
            xdnd_send_drop (dnd, dnd->dropper_toplevel, from, time);
#endif
        }
        if (!dnd->internal_drag)
            for (;;) {
                XAllowEvents (dnd->display, SyncPointer, CurrentTime);
                XNextEvent (dnd->display, &xevent);
                if (xevent.type == ClientMessage && xevent.xclient.message_type == dnd->XdndFinished) {
                    dnd_debug1 ("XdndFinished");
#if XDND_VERSION < 3
                    if (XDND_FINISHED_TARGET_WIN (&xevent) == dnd->dropper_window) {
#endif
                        dnd_debug2 ("  source correct - exiting event loop, action=%ld", dnd->supported_action);
                        result = dnd->supported_action;                /* success - so return action to caller */
                        break;
#if XDND_VERSION < 3
                    }
#endif
                } else if (xevent.type == Expose) {
                    if (dnd->handle_expose_events)
                        (*dnd->handle_expose_events) (dnd, &xevent);
                } else if (xevent.type == MotionNotify) {
                    if (xevent.xmotion.time > time + (dnd->time_out ? dnd->time_out * 1000 : 10000)) {        /* allow a ten second timeout as default */
                        dnd_debug1 ("timeout - exiting event loop");
                        break;
                    }
                } else if (xevent.type == SelectionRequest && xevent.xselectionrequest.selection == dnd->XdndSelection) {
/* the target widget is going to request data, so check for SelectionRequest events */
                    int length = 0;
                    unsigned char *data = 0;

                    dnd_debug1 ("SelectionRequest - getting widget data");
                    (*dnd->widget_get_data) (dnd, from, &data, &length, xevent.xselectionrequest.target);
                    if (data) {
                        dnd_debug1 ("  sending selection");
                        xdnd_selection_send (dnd, &xevent.xselectionrequest, data, length);
                        xdnd_xfree (data);
                    }
/* don't wait for a XdndFinished event */
                    if (!dnd_version_at_least (dnd->dragging_version, 2))
                        break;
                }
            }
    } else {
        dnd_debug1 ("not ready_to_drop - ungrabbing pointer");
    }
    XUngrabPointer (dnd->display, CurrentTime);
    xdnd_reset (dnd);
    return result;
}

/* returns non-zero if event is handled */
int xdnd_handle_drop_events (DndClass * dnd, XEvent * xevent)
{
    int result = 0;
    if (xevent->type == SelectionNotify) {
        dnd_debug1 ("got SelectionNotify");
        if (xevent->xselection.property == dnd->Xdnd_NON_PROTOCOL_ATOM && dnd->stage == XDND_DROP_STAGE_CONVERTING) {
            int error;
            dnd_debug1 ("  property is Xdnd_NON_PROTOCOL_ATOM - getting selection");
            error = xdnd_get_selection (dnd, dnd->dragger_window, xevent->xselection.property, xevent->xany.window);
/* error is not actually used, i think future versions of the protocol maybe should return 
   an error status to the calling window with the XdndFinished client message */
            if (dnd_version_at_least (dnd->dragging_version, 2)) {
#if XDND_VERSION >= 3
                xdnd_send_finished (dnd, dnd->dragger_window, dnd->dropper_toplevel, error);
#else
                xdnd_send_finished (dnd, dnd->dragger_window, dnd->dropper_window, error);
#endif
                dnd_debug1 ("    sending finished");
            }
            xdnd_xfree (dnd->dragger_typelist);
            xdnd_reset (dnd);
            dnd->stage = XDND_DROP_STAGE_IDLE;
            result = 1;
        } else {
            dnd_debug1 ("  property is not Xdnd_NON_PROTOCOL_ATOM - ignoring");
        }
    } else if (xevent->type == ClientMessage) {
        dnd_debug2 ("got ClientMessage to xevent->xany.window = %ld", xevent->xany.window);
        if (xevent->xclient.message_type == dnd->XdndEnter) {
            dnd_debug2 ("  message_type is XdndEnter, version = %ld", XDND_ENTER_VERSION (xevent));
#if XDND_VERSION >= 3
            if (XDND_ENTER_VERSION (xevent) < 3)
                return 0;
#endif
            xdnd_reset (dnd);
            dnd->dragger_window = XDND_ENTER_SOURCE_WIN (xevent);
#if XDND_VERSION >= 3
            dnd->dropper_toplevel = xevent->xany.window;
            dnd->dropper_window = 0;     /* enter goes to the top level window only,
                                            so we don't really know what the
                                            sub window is yet */
#else
            dnd->dropper_window = xevent->xany.window;
#endif
            xdnd_xfree (dnd->dragger_typelist);
            if (XDND_ENTER_THREE_TYPES (xevent)) {
                dnd_debug1 ("    three types only");
                xdnd_get_three_types (dnd, xevent, &dnd->dragger_typelist);
            } else {
                dnd_debug1 ("    more than three types - getting list");
                xdnd_get_type_list (dnd, dnd->dragger_window, &dnd->dragger_typelist);
            }
            if (dnd->dragger_typelist)
                dnd->stage = XDND_DROP_STAGE_ENTERED;
            else
                dnd_debug1 ("      typelist returned as zero!");
            dnd->dragging_version = XDND_ENTER_VERSION (xevent);
            result = 1;
        } else if (xevent->xclient.message_type == dnd->XdndLeave) {
#if XDND_VERSION >= 3
            if (xevent->xany.window == dnd->dropper_toplevel && dnd->dropper_window)
                xevent->xany.window = dnd->dropper_window;
#endif
            dnd_debug1 ("  message_type is XdndLeave");
            if (dnd->dragger_window == XDND_LEAVE_SOURCE_WIN (xevent) && dnd->stage == XDND_DROP_STAGE_ENTERED) {
                dnd_debug1 ("    leaving");
                if (dnd->widget_apply_leave)
                    (*dnd->widget_apply_leave) (dnd, xevent->xany.window);
                dnd->stage = XDND_DROP_STAGE_IDLE;
                xdnd_xfree (dnd->dragger_typelist);
                result = 1;
                dnd->dropper_toplevel = dnd->dropper_window = 0;
            } else {
                dnd_debug1 ("    wrong stage or from wrong window");
            }
        } else if (xevent->xclient.message_type == dnd->XdndPosition) {
            dnd_debug2 ("  message_type is XdndPosition to %ld", xevent->xany.window);
            if (dnd->dragger_window == XDND_POSITION_SOURCE_WIN (xevent) && dnd->stage == XDND_DROP_STAGE_ENTERED) {
                int want_position;
                Atom action;
                XRectangle rectangle;
                Window last_window;
                last_window = dnd->dropper_window;
#if XDND_VERSION >= 3
/* version 3 gives us the top-level window only. WE have to find the child that the pointer is over: */
                if (1 || xevent->xany.window != dnd->dropper_toplevel || !dnd->dropper_window) {
                    Window parent, child, new_child = 0;
                    dnd->dropper_toplevel = xevent->xany.window;
                    parent = dnd->root_window;
                    child = dnd->dropper_toplevel;
                    for (;;) {
                        int xd, yd;
                        new_child = 0;
                        if (!XTranslateCoordinates (dnd->display, parent, child, 
                                    XDND_POSITION_ROOT_X (xevent), XDND_POSITION_ROOT_Y (xevent),
                                    &xd, &yd, &new_child))
                            break;
                        if (!new_child)
                            break;
                        child = new_child;
                    }
                    dnd->dropper_window = xevent->xany.window = child;
                    dnd_debug2 ("   child window translates to %ld", dnd->dropper_window);
                } else if (xevent->xany.window == dnd->dropper_toplevel && dnd->dropper_window) {
                    xevent->xany.window = dnd->dropper_window;
                    dnd_debug2 ("   child window previously found: %ld", dnd->dropper_window);
                }
#endif
                action = dnd->XdndActionCopy;
                dnd->supported_action = dnd->XdndActionCopy;
                dnd->x = XDND_POSITION_ROOT_X (xevent);
                dnd->y = XDND_POSITION_ROOT_Y (xevent);
                dnd->time = CurrentTime;
                if (dnd_version_at_least (dnd->dragging_version, 1))
                    dnd->time = XDND_POSITION_TIME (xevent);
                if (dnd_version_at_least (dnd->dragging_version, 1))
                    action = XDND_POSITION_ACTION (xevent);
#if XDND_VERSION >= 3
                if (last_window && last_window != xevent->xany.window)
                    if (dnd->widget_apply_leave)
                        (*dnd->widget_apply_leave) (dnd, last_window);
#endif
                dnd->will_accept = (*dnd->widget_apply_position) (dnd, xevent->xany.window, dnd->dragger_window,
                action, dnd->x, dnd->y, dnd->time, dnd->dragger_typelist,
                                                                  &want_position, &dnd->supported_action, &dnd->desired_type, &rectangle);
                dnd_debug2 ("    will accept = %d", dnd->will_accept);
#if XDND_VERSION >= 3
                dnd_debug2 ("    sending status of %ld", dnd->dropper_toplevel);
                xdnd_send_status (dnd, dnd->dragger_window, dnd->dropper_toplevel, dnd->will_accept,
                                  want_position, rectangle.x, rectangle.y, rectangle.width, rectangle.height, dnd->supported_action);
#else
                dnd_debug2 ("    sending status of %ld", xevent->xany.window);
                xdnd_send_status (dnd, dnd->dragger_window, xevent->xany.window, dnd->will_accept,
                                  want_position, rectangle.x, rectangle.y, rectangle.width, rectangle.height, dnd->supported_action);
#endif
                result = 1;
            } else {
                dnd_debug1 ("    wrong stage or from wrong window");
            }
        } else if (xevent->xclient.message_type == dnd->XdndDrop) {
#if XDND_VERSION >= 3
            if (xevent->xany.window == dnd->dropper_toplevel && dnd->dropper_window)
                xevent->xany.window = dnd->dropper_window;
#endif
            dnd_debug1 ("  message_type is XdndDrop");
            if (dnd->dragger_window == XDND_DROP_SOURCE_WIN (xevent) && dnd->stage == XDND_DROP_STAGE_ENTERED) {
                dnd->time = CurrentTime;
                if (dnd_version_at_least (dnd->dragging_version, 1))
                    dnd->time = XDND_DROP_TIME (xevent);
                if (dnd->will_accept) {
                    dnd_debug1 ("    will_accept is true - converting selectiong");
                    dnd_debug2 ("      my window is %ld", dnd->dropper_window);
                    dnd_debug2 ("        source window is %ld", dnd->dragger_window);
                    xdnd_convert_selection (dnd, dnd->dragger_window, dnd->dropper_window, dnd->desired_type);
                    dnd->stage = XDND_DROP_STAGE_CONVERTING;
                } else {
                    dnd_debug1 ("    will_accept is false - sending finished");
                    if (dnd_version_at_least (dnd->dragging_version, 2)) {
#if XDND_VERSION >= 3
                        xdnd_send_finished (dnd, dnd->dragger_window, dnd->dropper_toplevel, 1);
#else
                        xdnd_send_finished (dnd, dnd->dragger_window, xevent->xany.window, 1);
#endif
                    }
                    xdnd_xfree (dnd->dragger_typelist);
                    xdnd_reset (dnd);
                    dnd->stage = XDND_DROP_STAGE_IDLE;
                }
                result = 1;
            } else {
                dnd_debug1 ("    wrong stage or from wrong window");
            }
        }
    }
    return result;
}

/*
   Following here is a sample implementation: Suppose we want a window
   to recieve drops, but do not want to be concerned with setting up all
   the DndClass methods. All we then do is call xdnd_get_drop() whenever a
   ClientMessage is recieved. If the message has nothing to do with XDND,
   xdnd_get_drop quickly returns 0. If it is a XdndEnter message, then
   xdnd_get_drop enters its own XNextEvent loop and handles all XDND
   protocol messages internally, returning the action requested.

   You should pass a desired typelist and actionlist to xdnd_get_type.
   These must be null terminated arrays of atoms, or a null pointer
   if you would like any action or type to be accepted. If typelist
   is null then the first type of the dragging widgets typelist will
   be the one used. If actionlist is null, then only XdndActionCopy will
   be accepted.

   The result is stored in *data, length, type, x and y.
   *data must be free'd.
 */

struct xdnd_get_drop_info {
    unsigned char *drop_data;
    int drop_data_length;
    int x, y;
    Atom return_type;
    Atom return_action;
    Atom *typelist;
    Atom *actionlist;
};

static int widget_insert_drop (DndClass * dnd, unsigned char *data, int length, int remaining, Window into, Window from, Atom type)
{
    struct xdnd_get_drop_info *i;
    i = (struct xdnd_get_drop_info *) dnd->user_hook1;
    if (!i->drop_data) {
        i->drop_data = malloc (length);
        if (!i->drop_data)
            return 1;
        memcpy (i->drop_data, data, length);
        i->drop_data_length = length;
    } else {
        unsigned char *t;
        t = malloc (i->drop_data_length + length);
        if (!t) {
            free (i->drop_data);
            i->drop_data = 0;
            return 1;
        }
        memcpy (t, i->drop_data, i->drop_data_length);
        memcpy (t + i->drop_data_length, data, length);
        free (i->drop_data);
        i->drop_data = t;
        i->drop_data_length += length;
    }
    return 0;
}

static int widget_apply_position (DndClass * dnd, Window widgets_window, Window from,
                      Atom action, int x, int y, Time t, Atom * typelist,
 int *want_position, Atom * supported_action_return, Atom * desired_type,
                                  XRectangle * rectangle)
{
    int i, j;
    struct xdnd_get_drop_info *info;
    Atom *dropper_typelist, supported_type = 0;
    Atom *supported_actions, supported_action = 0;

    info = (struct xdnd_get_drop_info *) dnd->user_hook1;
    dropper_typelist = info->typelist;
    supported_actions = info->actionlist;

    if (dropper_typelist) {
/* find a correlation: */
        for (j = 0; dropper_typelist[j]; j++) {
            for (i = 0; typelist[i]; i++) {
                if (typelist[i] == dropper_typelist[j]) {
                    supported_type = typelist[i];
                    break;
                }
            }
            if (supported_type)
                break;
        }
    } else {
/* user did not specify, so return first type */
        supported_type = typelist[0];
    }
/* not supported, so return false */
    if (!supported_type)
        return 0;

    if (supported_actions) {
        for (j = 0; supported_actions[j]; j++) {
            if (action == supported_actions[j]) {
                supported_action = action;
                break;
            }
        }
    } else {
/* user did not specify */
        if (action == dnd->XdndActionCopy)
            supported_action = action;
    }
    if (!supported_action)
        return 0;

    *want_position = 1;
    rectangle->x = rectangle->y = 0;
    rectangle->width = rectangle->height = 0;

    info->return_action = *supported_action_return = supported_action;
    info->return_type = *desired_type = supported_type;
    info->x = x;
    info->y = y;

    return 1;
}

Atom xdnd_get_drop (Display * display, XEvent * xevent, Atom * typelist, Atom * actionlist,
          unsigned char **data, int *length, Atom * type, int *x, int *y)
{
    Atom action = 0;
    static int initialised = 0;
    static DndClass dnd;
    if (!initialised) {
        xdnd_init (&dnd, display);
        initialised = 1;
    }
    if (xevent->type != ClientMessage || xevent->xclient.message_type != dnd.XdndEnter) {
        return 0;
    } else {
        struct xdnd_get_drop_info i;

/* setup user structure */
        memset (&i, 0, sizeof (i));
        i.actionlist = actionlist;
        i.typelist = typelist;
        dnd.user_hook1 = &i;

/* setup methods */
        dnd.widget_insert_drop = widget_insert_drop;
        dnd.widget_apply_position = widget_apply_position;

/* main loop */
        for (;;) {
            xdnd_handle_drop_events (&dnd, xevent);
            if (dnd.stage == XDND_DROP_STAGE_IDLE)
                break;
            XNextEvent (dnd.display, xevent);
        }

/* return results */
        if (i.drop_data) {
            *length = i.drop_data_length;
            *data = i.drop_data;
            action = i.return_action;
            *type = i.return_type;
            *x = i.x;
            *y = i.y;
        }
    }
    return action;
}