
#include "WINGsP.h"
#include <X11/Xatom.h>

#define XDND_SOURCE_RESPONSE_MAX_DELAY 3000

#define XDND_PROPERTY_FORMAT 32
#define XDND_ACTION_DESCRIPTION_FORMAT 8

#define XDND_SOURCE_VERSION(dragInfo) dragInfo->protocolVersion
#define XDND_DEST_INFO(dragInfo) dragInfo->destInfo
#define XDND_AWARE_VIEW(dragInfo) dragInfo->destInfo->xdndAwareView
#define XDND_SOURCE_WIN(dragInfo) dragInfo->destInfo->sourceWindow
#define XDND_DEST_VIEW(dragInfo) dragInfo->destInfo->destView
#define XDND_DEST_STATE(dragInfo) dragInfo->destInfo->state
#define XDND_SOURCE_ACTION_CHANGED(dragInfo) dragInfo->destInfo->sourceActionChanged
#define XDND_SOURCE_TYPES(dragInfo) dragInfo->destInfo->sourceTypes
#define XDND_TYPE_LIST_AVAILABLE(dragInfo) dragInfo->destInfo->typeListAvailable
#define XDND_REQUIRED_TYPES(dragInfo) dragInfo->destInfo->requiredTypes
#define XDND_SOURCE_ACTION(dragInfo) dragInfo->sourceAction
#define XDND_DEST_ACTION(dragInfo) dragInfo->destinationAction
#define XDND_SOURCE_OPERATIONS(dragInfo) dragInfo->destInfo->sourceOperations
#define XDND_DROP_DATAS(dragInfo) dragInfo->destInfo->dropDatas
#define XDND_DROP_DATA_COUNT(dragInfo) dragInfo->destInfo->dropDataCount
#define XDND_DEST_VIEW_IS_REGISTERED(dragInfo) ((dragInfo->destInfo) != NULL)\
    && ((dragInfo->destInfo->destView->dragDestinationProcs) != NULL)

static const unsigned char XDNDversion = XDND_VERSION;
static WMHandlerID dndDestinationTimer = NULL;

static void *idleState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
static void *waitEnterState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
static void *inspectDropDataState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
static void *dropAllowedState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
static void *dropNotAllowedState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);
static void *waitForDropDataState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info);

/* ----- Types & datas list ----- */
static void freeSourceTypeArrayItem(void *type)
{
	XFree(type);
}

static WMArray *createSourceTypeArray(int initialSize)
{
	return WMCreateArrayWithDestructor(initialSize, freeSourceTypeArrayItem);
}

static void freeDropDataArrayItem(void *data)
{
	if (data != NULL)
		WMReleaseData((WMData *) data);
}

static WMArray *createDropDataArray(WMArray * requiredTypes)
{
	if (requiredTypes != NULL)
		return WMCreateArrayWithDestructor(WMGetArrayItemCount(requiredTypes), freeDropDataArrayItem);

	else
		return WMCreateArray(0);
}

static WMArray *getTypesFromTypeList(WMScreen * scr, Window sourceWin)
{
	Atom dataType;
	Atom *typeAtomList;
	WMArray *typeList;
	int i, format;
	unsigned long count, remaining;
	unsigned char *data = NULL;

	XGetWindowProperty(scr->display, sourceWin, scr->xdndTypeListAtom,
			   0, 0x8000000L, False, XA_ATOM, &dataType, &format, &count, &remaining, &data);

	if (dataType != XA_ATOM || format != XDND_PROPERTY_FORMAT || count == 0 || !data) {
		if (data) {
			XFree(data);
		}
		return createSourceTypeArray(0);
	}

	typeList = createSourceTypeArray(count);
	typeAtomList = (Atom *) data;
	for (i = 0; i < count; i++) {
		WMAddToArray(typeList, XGetAtomName(scr->display, typeAtomList[i]));
	}

	XFree(data);

	return typeList;
}

static WMArray *getTypesFromThreeTypes(WMScreen * scr, XClientMessageEvent * event)
{
	WMArray *typeList;
	Atom atom;
	int i;

	typeList = createSourceTypeArray(3);
	for (i = 2; i < 5; i++) {
		if (event->data.l[i] != None) {
			atom = (Atom) event->data.l[i];
			WMAddToArray(typeList, XGetAtomName(scr->display, atom));
		}
	}

	return typeList;
}

static void storeRequiredTypeList(WMDraggingInfo * info)
{
	WMView *destView = XDND_DEST_VIEW(info);
	WMScreen *scr = W_VIEW_SCREEN(destView);
	WMArray *requiredTypes;

	/* First, see if the stored source types are enough for dest requirements */
	requiredTypes = destView->dragDestinationProcs->requiredDataTypes(destView,
									  W_ActionToOperation(scr,
											      XDND_SOURCE_ACTION
											      (info)),
									  XDND_SOURCE_TYPES(info));

	if (requiredTypes == NULL && XDND_TYPE_LIST_AVAILABLE(info)) {
		/* None of the stored source types fits, but the whole type list
		   hasn't been retrieved yet. */
		WMFreeArray(XDND_SOURCE_TYPES(info));
		XDND_SOURCE_TYPES(info) = getTypesFromTypeList(scr, XDND_SOURCE_WIN(info));
		/* Don't retrieve the type list again */
		XDND_TYPE_LIST_AVAILABLE(info) = False;

		requiredTypes =
		    destView->dragDestinationProcs->requiredDataTypes(destView,
								      W_ActionToOperation(scr,
											  XDND_SOURCE_ACTION
											  (info)),
								      XDND_SOURCE_TYPES(info));
	}

	XDND_REQUIRED_TYPES(info) = requiredTypes;
}

static char *getNextRequestedDataType(WMDraggingInfo * info)
{
	/* get the type of the first data not yet retrieved from selection */
	int nextTypeIndex;

	if (XDND_REQUIRED_TYPES(info) != NULL) {
		nextTypeIndex = WMGetArrayItemCount(XDND_DROP_DATAS(info));
		return WMGetFromArray(XDND_REQUIRED_TYPES(info), nextTypeIndex);
		/* NULL if no more type */
	} else
		return NULL;
}

/* ----- Action list ----- */

static WMArray *sourceOperationList(WMScreen * scr, Window sourceWin)
{
	Atom dataType, *actionList;
	int i, size;
	unsigned long count, remaining;
	unsigned char *actionDatas = NULL;
	unsigned char *descriptionList = NULL;
	WMArray *operationArray;
	WMDragOperationItem *operationItem;
	char *description;

	remaining = 0;
	XGetWindowProperty(scr->display, sourceWin, scr->xdndActionListAtom,
			   0, 0x8000000L, False, XA_ATOM, &dataType, &size, &count, &remaining, &actionDatas);

	if (dataType != XA_ATOM || size != XDND_PROPERTY_FORMAT || count == 0 || !actionDatas) {
		wwarning("Cannot read action list");
		if (actionDatas) {
			XFree(actionDatas);
		}
		return NULL;
	}

	actionList = (Atom *) actionDatas;

	XGetWindowProperty(scr->display, sourceWin, scr->xdndActionDescriptionAtom,
			   0, 0x8000000L, False, XA_STRING, &dataType, &size,
			   &count, &remaining, &descriptionList);

	if (dataType != XA_STRING || size != XDND_ACTION_DESCRIPTION_FORMAT || count == 0 || !descriptionList) {
		wwarning("Cannot read action description list");
		if (actionList) {
			XFree(actionList);
		}
		if (descriptionList) {
			XFree(descriptionList);
		}
		return NULL;
	}

	operationArray = WMCreateDragOperationArray(count);
	description = (char *)descriptionList;

	for (i = 0; count > 0; i++) {
		size = strlen(description);
		operationItem = WMCreateDragOperationItem(W_ActionToOperation(scr, actionList[i]),
							  wstrdup(description));

		WMAddToArray(operationArray, operationItem);
		count -= (size + 1);	/* -1 : -NULL char */

		/* next description */
		description = &(description[size + 1]);
	}

	XFree(actionList);
	XFree(descriptionList);

	return operationArray;
}

/* ----- Dragging Info ----- */
static void updateSourceWindow(WMDraggingInfo * info, XClientMessageEvent * event)
{
	XDND_SOURCE_WIN(info) = (Window) event->data.l[0];
}

static WMView *findChildInView(WMView * parent, int x, int y)
{
	if (parent->childrenList == NULL)
		return parent;
	else {
		WMView *child = parent->childrenList;

		while (child != NULL
		       && (!child->flags.mapped
			   || x < WMGetViewPosition(child).x
			   || x > WMGetViewPosition(child).x + WMGetViewSize(child).width
			   || y < WMGetViewPosition(child).y
			   || y > WMGetViewPosition(child).y + WMGetViewSize(child).height))

			child = child->nextSister;

		if (child == NULL)
			return parent;
		else
			return findChildInView(child,
					       x - WMGetViewPosition(child).x, y - WMGetViewPosition(child).y);
	}
}

static WMView *findDestinationViewInToplevel(WMView * toplevel, int x, int y)
{
	WMScreen *scr = W_VIEW_SCREEN(toplevel);
	Window toplevelWin = WMViewXID(toplevel);
	int xInToplevel, yInToplevel;
	Window foo;

	XTranslateCoordinates(scr->display, scr->rootWin, toplevelWin, x, y, &xInToplevel, &yInToplevel, &foo);
	return findChildInView(toplevel, xInToplevel, yInToplevel);
}

/* Clear datas only used by current destination view */
static void freeDestinationViewInfos(WMDraggingInfo * info)
{
	if (XDND_SOURCE_TYPES(info) != NULL) {
		WMFreeArray(XDND_SOURCE_TYPES(info));
		XDND_SOURCE_TYPES(info) = NULL;
	}

	if (XDND_DROP_DATAS(info) != NULL) {
		WMFreeArray(XDND_DROP_DATAS(info));
		XDND_DROP_DATAS(info) = NULL;
	}

	XDND_REQUIRED_TYPES(info) = NULL;
}

void W_DragDestinationInfoClear(WMDraggingInfo * info)
{
	W_DragDestinationStopTimer();

	if (XDND_DEST_INFO(info) != NULL) {
		freeDestinationViewInfos(info);

		wfree(XDND_DEST_INFO(info));
		XDND_DEST_INFO(info) = NULL;
	}
}

static void initDestinationDragInfo(WMDraggingInfo * info, WMView * destView)
{
	wassertr(destView != NULL);

	XDND_DEST_INFO(info) = (W_DragDestinationInfo *) wmalloc(sizeof(W_DragDestinationInfo));

	XDND_DEST_STATE(info) = idleState;
	XDND_DEST_VIEW(info) = destView;

	XDND_SOURCE_ACTION_CHANGED(info) = False;
	XDND_SOURCE_TYPES(info) = NULL;
	XDND_REQUIRED_TYPES(info) = NULL;
	XDND_DROP_DATAS(info) = NULL;
}

void W_DragDestinationStoreEnterMsgInfo(WMDraggingInfo * info, WMView * toplevel, XClientMessageEvent * event)
{
	WMScreen *scr = W_VIEW_SCREEN(toplevel);

	if (XDND_DEST_INFO(info) == NULL)
		initDestinationDragInfo(info, toplevel);

	XDND_SOURCE_VERSION(info) = (event->data.l[1] >> 24);
	XDND_AWARE_VIEW(info) = toplevel;
	updateSourceWindow(info, event);

#if 0
    if (event->data.l[1] & 1)
        /* XdndTypeList property is available */
        XDND_SOURCE_TYPES(info) = getTypesFromTypeList(scr, XDND_SOURCE_WIN(info));
    else
        XDND_SOURCE_TYPES(info) = getTypesFromThreeTypes(scr, event);
#endif
	XDND_SOURCE_TYPES(info) = getTypesFromThreeTypes(scr, event);

	/* to use if the 3 types are not enough */
	XDND_TYPE_LIST_AVAILABLE(info) = (event->data.l[1] & 1);
}

void W_DragDestinationStorePositionMsgInfo(WMDraggingInfo * info, WMView * toplevel, XClientMessageEvent * event)
{
	int x = event->data.l[2] >> 16;
	int y = event->data.l[2] & 0xffff;
	WMView *newDestView;

	newDestView = findDestinationViewInToplevel(toplevel, x, y);

	if (XDND_DEST_INFO(info) == NULL) {
		initDestinationDragInfo(info, newDestView);
		XDND_AWARE_VIEW(info) = toplevel;
		updateSourceWindow(info, event);
	} else {
		if (newDestView != XDND_DEST_VIEW(info)) {
			updateSourceWindow(info, event);
			XDND_DEST_VIEW(info) = newDestView;
			XDND_SOURCE_ACTION_CHANGED(info) = False;

			if (XDND_DEST_STATE(info) != waitEnterState)
				XDND_DEST_STATE(info) = idleState;
		} else {
			XDND_SOURCE_ACTION_CHANGED(info) = (XDND_SOURCE_ACTION(info) != event->data.l[4]);
		}
	}

	XDND_SOURCE_ACTION(info) = event->data.l[4];

	/* note: source position is not stored */
}

/* ----- End of Dragging Info ----- */

/* ----- Messages ----- */

/* send a DnD message to the source window */
static void
sendDnDClientMessage(WMDraggingInfo * info, Atom message,
		     unsigned long data1, unsigned long data2, unsigned long data3, unsigned long data4)
{
	if (!W_SendDnDClientMessage(W_VIEW_SCREEN(XDND_AWARE_VIEW(info))->display,
				    XDND_SOURCE_WIN(info),
				    message, WMViewXID(XDND_AWARE_VIEW(info)), data1, data2, data3, data4)) {
		/* drop failed */
		W_DragDestinationInfoClear(info);
	}
}

/* send a xdndStatus message to the source, with position and size
   of the destination if it has no subwidget (requesting a position message
   on every move otherwise) */
static void sendStatusMessage(WMView * destView, WMDraggingInfo * info, Atom action)
{
	unsigned long data1;

	data1 = (action == None) ? 0 : 1;

	if (destView->childrenList == NULL) {
		WMScreen *scr = W_VIEW_SCREEN(destView);
		int destX, destY;
		WMSize destSize = WMGetViewSize(destView);
		Window foo;

		XTranslateCoordinates(scr->display, WMViewXID(destView), scr->rootWin, 0, 0, &destX, &destY, &foo);

		sendDnDClientMessage(info,
				     W_VIEW_SCREEN(destView)->xdndStatusAtom,
				     data1,
				     (destX << 16) | destY, (destSize.width << 16) | destSize.height, action);
	} else {
		/* set bit 1 to request explicitly position message on every move */
		data1 = data1 | 2;

		sendDnDClientMessage(info, W_VIEW_SCREEN(destView)->xdndStatusAtom, data1, 0, 0, action);
	}
}

static void
storeDropData(WMView * destView, Atom selection, Atom target, Time timestamp, void *cdata, WMData * data)
{
	WMScreen *scr = W_VIEW_SCREEN(destView);
	WMDraggingInfo *info = &(scr->dragInfo);
	WMData *dataToStore = NULL;

	/* Parameter not used, but tell the compiler that it is ok */
	(void) selection;
	(void) target;
	(void) timestamp;
	(void) cdata;

	if (data != NULL)
		dataToStore = WMRetainData(data);

	if (XDND_DEST_INFO(info) != NULL && XDND_DROP_DATAS(info) != NULL) {
		WMAddToArray(XDND_DROP_DATAS(info), dataToStore);
		W_SendDnDClientMessage(scr->display, WMViewXID(destView),
				       scr->xdndSelectionAtom, WMViewXID(destView), 0, 0, 0, 0);
	}
}

static Bool requestDropDataInSelection(WMView * destView, const char *type)
{
	WMScreen *scr = W_VIEW_SCREEN(destView);

	if (type != NULL) {
		if (!WMRequestSelection(destView,
					scr->xdndSelectionAtom,
					XInternAtom(scr->display, type, False),
					CurrentTime, storeDropData, NULL)) {
			wwarning("could not request data for dropped data");
			return False;
		}

		return True;
	}

	return False;
}

static Bool requestDropData(WMDraggingInfo * info)
{
	WMView *destView = XDND_DEST_VIEW(info);
	char *nextType = getNextRequestedDataType(info);

	while ((nextType != NULL)
	       && (!requestDropDataInSelection(destView, nextType))) {
		/* store NULL if request failed, and try with next type */
		WMAddToArray(XDND_DROP_DATAS(info), NULL);
		nextType = getNextRequestedDataType(info);
	}

	/* remains types to retrieve ? */
	return (nextType != NULL);
}

static void concludeDrop(WMView * destView)
{
	destView->dragDestinationProcs->concludeDragOperation(destView);
}

/* send cancel message to the source */
static void cancelDrop(WMView * destView, WMDraggingInfo * info)
{
	sendStatusMessage(destView, info, None);
	concludeDrop(destView);
	freeDestinationViewInfos(info);
}

/* suspend drop, when dragged icon enter an unregistered view
   or a register view that doesn't accept the drop */
static void suspendDropAuthorization(WMView * destView, WMDraggingInfo * info)
{
	sendStatusMessage(destView, info, None);

	/* Free datas that depend on destination behaviour */
	if (XDND_DROP_DATAS(info) != NULL) {
		WMFreeArray(XDND_DROP_DATAS(info));
		XDND_DROP_DATAS(info) = NULL;
	}

	XDND_REQUIRED_TYPES(info) = NULL;
}

/* cancel drop on Enter message, if protocol version is nok */
void W_DragDestinationCancelDropOnEnter(WMView * toplevel, WMDraggingInfo * info)
{
	if (XDND_DEST_VIEW_IS_REGISTERED(info))
		cancelDrop(XDND_DEST_VIEW(info), info);
	else
		sendStatusMessage(toplevel, info, None);

	W_DragDestinationInfoClear(info);
}

static void finishDrop(WMView * destView, WMDraggingInfo * info)
{
	sendDnDClientMessage(info, W_VIEW_SCREEN(destView)->xdndFinishedAtom, 0, 0, 0, 0);
	concludeDrop(destView);
	W_DragDestinationInfoClear(info);
}

static Atom getAllowedAction(WMView * destView, WMDraggingInfo * info)
{
	WMScreen *scr = W_VIEW_SCREEN(destView);

	return W_OperationToAction(scr,
				   destView->dragDestinationProcs->allowedOperation(destView,
										    W_ActionToOperation(scr,
													XDND_SOURCE_ACTION
													(info)),
										    XDND_SOURCE_TYPES(info)));
}

static void *checkActionAllowed(WMView * destView, WMDraggingInfo * info)
{
	XDND_DEST_ACTION(info) = getAllowedAction(destView, info);

	if (XDND_DEST_ACTION(info) == None) {
		suspendDropAuthorization(destView, info);
		return dropNotAllowedState;
	}

	sendStatusMessage(destView, info, XDND_DEST_ACTION(info));
	return dropAllowedState;
}

static void *checkDropAllowed(WMView *destView, WMDraggingInfo *info)
{
	storeRequiredTypeList(info);

	if (destView->dragDestinationProcs->inspectDropData != NULL) {
		XDND_DROP_DATAS(info) = createDropDataArray(XDND_REQUIRED_TYPES(info));

		/* store first available data */
		if (requestDropData(info))
			return inspectDropDataState;

		/* no data retrieved, but inspect can allow it */
		if (destView->dragDestinationProcs->inspectDropData(destView, XDND_DROP_DATAS(info)))
			return checkActionAllowed(destView, info);

		suspendDropAuthorization(destView, info);
		return dropNotAllowedState;
	}

	return checkActionAllowed(destView, info);
}

static WMPoint *getDropLocationInView(WMView * view)
{
	Window rootWin, childWin;
	int rootX, rootY;
	unsigned int mask;
	WMPoint *location;

	location = (WMPoint *) wmalloc(sizeof(WMPoint));

	XQueryPointer(W_VIEW_SCREEN(view)->display,
		      WMViewXID(view), &rootWin, &childWin, &rootX, &rootY, &(location->x), &(location->y), &mask);

	return location;
}

static void callPerformDragOperation(WMView * destView, WMDraggingInfo * info)
{
	WMArray *operationList = NULL;
	WMScreen *scr = W_VIEW_SCREEN(destView);
	WMPoint *dropLocation;

	if (XDND_SOURCE_ACTION(info) == scr->xdndActionAsk)
		operationList = sourceOperationList(scr, XDND_SOURCE_WIN(info));

	dropLocation = getDropLocationInView(destView);
	destView->dragDestinationProcs->performDragOperation(destView,
							     XDND_DROP_DATAS(info), operationList, dropLocation);

	wfree(dropLocation);
	if (operationList != NULL)
		WMFreeArray(operationList);
}

/* ----- Destination timer ----- */
static void dragSourceResponseTimeOut(void *destView)
{
	WMView *view = (WMView *) destView;
	WMDraggingInfo *info;

	wwarning("delay for drag source response expired");
	info = &(W_VIEW_SCREEN(view)->dragInfo);
	if (XDND_DEST_VIEW_IS_REGISTERED(info))
		cancelDrop(view, info);
	else {
		sendStatusMessage(view, info, None);
	}

	W_DragDestinationInfoClear(info);
}

void W_DragDestinationStopTimer()
{
	if (dndDestinationTimer != NULL) {
		WMDeleteTimerHandler(dndDestinationTimer);
		dndDestinationTimer = NULL;
	}
}

void W_DragDestinationStartTimer(WMDraggingInfo * info)
{
	W_DragDestinationStopTimer();

	if (XDND_DEST_STATE(info) != idleState)
		dndDestinationTimer = WMAddTimerHandler(XDND_SOURCE_RESPONSE_MAX_DELAY,
							dragSourceResponseTimeOut, XDND_DEST_VIEW(info));
}

/* ----- End of Destination timer ----- */

/* ----- Destination states ----- */

#ifdef XDND_DEBUG
static const char *stateName(W_DndState * state)
{
	if (state == NULL)
		return "no state defined";

	if (state == idleState)
		return "idleState";

	if (state == waitEnterState)
		return "waitEnterState";

	if (state == inspectDropDataState)
		return "inspectDropDataState";

	if (state == dropAllowedState)
		return "dropAllowedState";

	if (state == dropNotAllowedState)
		return "dropNotAllowedState";

	if (state == waitForDropDataState)
		return "waitForDropDataState";

	return "unknown state";
}
#endif

static void *idleState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
{
	WMScreen *scr;
	Atom sourceMsg;

	if (destView->dragDestinationProcs != NULL) {
		scr = W_VIEW_SCREEN(destView);
		sourceMsg = event->message_type;

		if (sourceMsg == scr->xdndPositionAtom) {
			destView->dragDestinationProcs->prepareForDragOperation(destView);

			if (XDND_SOURCE_TYPES(info) != NULL) {
				/* enter message infos are available */
				return checkDropAllowed(destView, info);
			}

			/* waiting for enter message */
			return waitEnterState;
		}
	}

	suspendDropAuthorization(destView, info);
	return idleState;
}

/*  Source position and action are stored,
 waiting for xdnd protocol version and source type */
static void *waitEnterState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
{
	WMScreen *scr = W_VIEW_SCREEN(destView);
	Atom sourceMsg = event->message_type;

	if (sourceMsg == scr->xdndEnterAtom) {
		W_DragDestinationStoreEnterMsgInfo(info, destView, event);
		return checkDropAllowed(destView, info);
	}

	return waitEnterState;
}

/* We have requested a data, and have received it */
static void *inspectDropDataState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
{
	WMScreen *scr;
	Atom sourceMsg;

	scr = W_VIEW_SCREEN(destView);
	sourceMsg = event->message_type;

	if (sourceMsg == scr->xdndSelectionAtom) {
		/* a data has been retrieved, store next available */
		if (requestDropData(info))
			return inspectDropDataState;

		/* all required (and available) datas are stored */
		if (destView->dragDestinationProcs->inspectDropData(destView, XDND_DROP_DATAS(info)))
			return checkActionAllowed(destView, info);

		suspendDropAuthorization(destView, info);
		return dropNotAllowedState;
	}

	return inspectDropDataState;
}

static void *dropNotAllowedState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
{
	WMScreen *scr = W_VIEW_SCREEN(destView);
	Atom sourceMsg = event->message_type;

	if (sourceMsg == scr->xdndDropAtom) {
		finishDrop(destView, info);
		return idleState;
	}

	if (sourceMsg == scr->xdndPositionAtom) {
		if (XDND_SOURCE_ACTION_CHANGED(info)) {
			return checkDropAllowed(destView, info);
		} else {
			sendStatusMessage(destView, info, None);
			return dropNotAllowedState;
		}
	}

	return dropNotAllowedState;
}

static void *dropAllowedState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
{
	WMScreen *scr = W_VIEW_SCREEN(destView);
	Atom sourceMsg = event->message_type;

	if (sourceMsg == scr->xdndDropAtom) {
		if (XDND_DROP_DATAS(info) != NULL) {
			/* drop datas were cached with inspectDropData call */
			callPerformDragOperation(destView, info);
		} else {
			XDND_DROP_DATAS(info) = createDropDataArray(XDND_REQUIRED_TYPES(info));

			/* store first available data */
			if (requestDropData(info))
				return waitForDropDataState;

			/* no data retrieved */
			callPerformDragOperation(destView, info);
		}

		finishDrop(destView, info);
		return idleState;
	}

	if (sourceMsg == scr->xdndPositionAtom) {
		if (XDND_SOURCE_ACTION_CHANGED(info)) {
			return checkDropAllowed(destView, info);
		} else {
			sendStatusMessage(destView, info, XDND_DEST_ACTION(info));
			return dropAllowedState;
		}
	}

	return dropAllowedState;
}

static void *waitForDropDataState(WMView * destView, XClientMessageEvent * event, WMDraggingInfo * info)
{
	WMScreen *scr = W_VIEW_SCREEN(destView);
	Atom sourceMsg = event->message_type;

	if (sourceMsg == scr->xdndSelectionAtom) {
		/* store next data */
		if (requestDropData(info))
			return waitForDropDataState;

		/* all required (and available) datas are stored */
		callPerformDragOperation(destView, info);

		finishDrop(destView, info);
		return idleState;
	}

	return waitForDropDataState;
}

/* ----- End of Destination states ----- */

void W_DragDestinationStateHandler(WMDraggingInfo * info, XClientMessageEvent * event)
{
	WMView *destView;
	W_DndState *newState;

	wassertr(XDND_DEST_INFO(info) != NULL);
	wassertr(XDND_DEST_VIEW(info) != NULL);

	destView = XDND_DEST_VIEW(info);
	if (XDND_DEST_STATE(info) == NULL)
		XDND_DEST_STATE(info) = idleState;

#ifdef XDND_DEBUG

	printf("current dest state: %s\n", stateName(XDND_DEST_STATE(info)));
#endif

	newState = (W_DndState *) XDND_DEST_STATE(info) (destView, event, info);

#ifdef XDND_DEBUG

	printf("new dest state: %s\n", stateName(newState));
#endif

	if (XDND_DEST_INFO(info) != NULL) {
		XDND_DEST_STATE(info) = newState;
		if (XDND_DEST_STATE(info) != idleState)
			W_DragDestinationStartTimer(info);
	}
}

static void realizedObserver(void *self, WMNotification * notif)
{
	WMView *view = (WMView *) WMGetNotificationObject(notif);
	WMScreen *scr = W_VIEW_SCREEN(view);

	XChangeProperty(scr->display, W_VIEW_DRAWABLE(view),
			scr->xdndAwareAtom, XA_ATOM, XDND_PROPERTY_FORMAT, PropModeReplace, &XDNDversion, 1);

	WMRemoveNotificationObserver(self);
}

static void W_SetXdndAwareProperty(WMScreen *scr, WMView *view)
{
	WMView *toplevel = W_TopLevelOfView(view);

	if (!toplevel->flags.xdndHintSet) {
		toplevel->flags.xdndHintSet = 1;

		if (toplevel->flags.realized) {
			XChangeProperty(scr->display, W_VIEW_DRAWABLE(toplevel),
					scr->xdndAwareAtom, XA_ATOM, XDND_PROPERTY_FORMAT,
					PropModeReplace, &XDNDversion, 1);
		} else {
			WMAddNotificationObserver(realizedObserver,
						  /* just use as an id */
						  &view->dragDestinationProcs,
						  WMViewRealizedNotification, toplevel);
		}
	}
}

void WMRegisterViewForDraggedTypes(WMView * view, WMArray * acceptedTypes)
{
	Atom *types;
	int typeCount;
	int i;

	typeCount = WMGetArrayItemCount(acceptedTypes);
	types = wmalloc(sizeof(Atom) * (typeCount + 1));

	for (i = 0; i < typeCount; i++) {
		types[i] = XInternAtom(W_VIEW_SCREEN(view)->display, WMGetFromArray(acceptedTypes, i), False);
	}
	types[i] = 0;

	view->droppableTypes = types;
	/* WMFreeArray(acceptedTypes); */

	W_SetXdndAwareProperty(W_VIEW_SCREEN(view), view);
}

void WMUnregisterViewDraggedTypes(WMView * view)
{
	if (view->droppableTypes != NULL)
		wfree(view->droppableTypes);
	view->droppableTypes = NULL;
}

/*
 requestedOperation: operation requested by the source
 sourceDataTypes:  data types (mime-types strings) supported by the source
 (never NULL, destroyed when drop ends)
 return operation allowed by destination (self)
 */
static WMDragOperationType
defAllowedOperation(WMView * self, WMDragOperationType requestedOperation, WMArray * sourceDataTypes)
{
	/* Parameter not used, but tell the compiler that it is ok */
	(void) self;
	(void) requestedOperation;
	(void) sourceDataTypes;

	/* no operation allowed */
	return WDOperationNone;
}

/*
 requestedOperation: operation requested by the source
 sourceDataTypes:  data types (mime-types strings) supported by the source
 (never NULL, destroyed when drop ends)
 return data types (mime-types strings) required by destination (self)
 or NULL if no suitable data type is available (force
 to 2nd pass with full source type list).
 */
static WMArray *defRequiredDataTypes(WMView * self,
				     WMDragOperationType requestedOperation, WMArray * sourceDataTypes)
{
	/* Parameter not used, but tell the compiler that it is ok */
	(void) self;
	(void) requestedOperation;
	(void) sourceDataTypes;

	/* no data type allowed (NULL even at 2nd pass) */
	return NULL;
}

/*
 Executed when the drag enters destination (self)
 */
static void defPrepareForDragOperation(WMView * self)
{
	/* Parameter not used, but tell the compiler that it is ok */
	(void) self;
}

/*
 Checks datas to be dropped (optional).
 dropDatas: datas (WMData*) required by destination (self)
 (given in same order as returned by requiredDataTypes).
 A NULL data means it couldn't be retreived.
 Destroyed when drop ends.
 return true if data array is ok
 */
/* Bool (*inspectDropData)(WMView *self, WMArray *dropDatas); */

/*
 Process drop
 dropDatas: datas (WMData*) required by destination (self)
 (given in same order as returned by requiredDataTypes).
 A NULL data means it couldn't be retrieved.
 Destroyed when drop ends.
 operationList: if source operation is WDOperationAsk, contains
 operations (and associated texts) that can be asked
 to source. (destroyed after performDragOperation call)
 Otherwise this parameter is NULL.
 */
static void
defPerformDragOperation(WMView * self, WMArray * dropDatas, WMArray * operationList, WMPoint * dropLocation)
{
	/* Parameter not used, but tell the compiler that it is ok */
	(void) self;
	(void) dropDatas;
	(void) operationList;
	(void) dropLocation;
}

/* Executed after drop */
static void defConcludeDragOperation(WMView * self)
{
	/* Parameter not used, but tell the compiler that it is ok */
	(void) self;
}

void WMSetViewDragDestinationProcs(WMView * view, WMDragDestinationProcs * procs)
{
	if (view->dragDestinationProcs == NULL) {
		view->dragDestinationProcs = wmalloc(sizeof(WMDragDestinationProcs));
	}

	*view->dragDestinationProcs = *procs;

	/*XXX fill in non-implemented stuffs */
	if (procs->allowedOperation == NULL) {
		view->dragDestinationProcs->allowedOperation = defAllowedOperation;
	}
	if (procs->allowedOperation == NULL) {
		view->dragDestinationProcs->requiredDataTypes = defRequiredDataTypes;
	}

	/* note: inspectDropData can be NULL, if data consultation is not needed
	   to give drop permission */

	if (procs->prepareForDragOperation == NULL) {
		view->dragDestinationProcs->prepareForDragOperation = defPrepareForDragOperation;
	}
	if (procs->performDragOperation == NULL) {
		view->dragDestinationProcs->performDragOperation = defPerformDragOperation;
	}
	if (procs->concludeDragOperation == NULL) {
		view->dragDestinationProcs->concludeDragOperation = defConcludeDragOperation;
	}
}
