/* 

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them 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.

 *

 * These libraries and programs are distributed in the hope that

 * they 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 these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

*/ 

/* 

 * HISTORY

*/ 

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$XConsortium: DNDProt1.c /main/10 1996/10/07 14:49:40 drk $"

#endif

#endif

/*

*  (c) Copyright 1987, 1988, 1989 HEWLETT-PACKARD COMPANY */

/*

 *	file: DNDProt1.c

 *

 *	Program to test the different protocols being used in DND transactions.

 *	The resources:

 *		initiatorProtocolStyle

 *		receiverProtocolStyle

 *

 *	This basically tests the fact that unless the client application

 *	specifies its own animationStyle, there should be no user-perceptible

 *	difference during a DND transaction, irrespective of whether the

 *	active Protocol style is DYNAMIC or PRE-REGISTER.

 *

 */

#include <signal.h>

#include <stdio.h>

#include <testlib.h>

#include <Xm/DragDrop.h>

#include <X11/keysym.h>

#include <X11/Xatom.h>

#define	MAX_DROPSITES	100

static Widget   CreatePushButton();

static void	 	Quit();

static void	 	StartDrag();

static char translations[] = 

"#override \

  Ctrl<Key>t: XtDisplayTranslations()\n\

  Ctrl<Key>a: XtDisplayAccelerators()\n\

  Ctrl<Key>i: XtDisplayInstalledAccelerators()\n\

  Ctrl<Key>q: Quit()";

static char dragTranslations[] =

"#override \

  Ctrl<Key>t: XtDisplayTranslations()\n\

  Ctrl<Key>a: XtDisplayAccelerators()\n\

  Ctrl<Key>i: XtDisplayInstalledAccelerators()\n\

  <Btn2Down>: StartDrag()\n\

  Ctrl<Key>q: Quit()";

static XtActionsRec myactions[] = {

	{"Quit", (XtActionProc)Quit},

	{"StartDrag", (XtActionProc)StartDrag},

};

typedef struct _XlationRepRec{

	String		str;

	XtTranslations	xlation;

}XlationRepRec, *XlationRep;

typedef struct _AppDataRec{

	XlationRepRec	xlation1;

	XlationRepRec	xlation2;

	Cardinal		numShells, numRows, numCols;

	Boolean		applyAccelerators;

	Boolean		applyOverrides;

}AppDataRec, *AppData;

XtResource	appResources[] = {

	{

	"xlations1", XtCTranslations, XtRString, 

	sizeof(String), XtOffset(AppData, xlation1.str),

	XtRString, (XtPointer)translations,

	},

	{

	"xlations1", XtCTranslations, XtRTranslationTable, 

	sizeof(XtTranslations), XtOffset(AppData, xlation1.xlation),

	XtRString, (XtPointer)translations,

	},

	{

	"xlations2", XtCTranslations, XtRString, 

	sizeof(String), XtOffset(AppData, xlation2.str),

	XtRString, (XtPointer)dragTranslations,

	},

	{

	"xlations2", XtCTranslations, XtRTranslationTable, 

	sizeof(XtTranslations), XtOffset(AppData, xlation2.xlation),

	XtRString, (XtPointer)dragTranslations,

	},

	{

	"applyAccelerators", "ApplyAccelerators", XtRBoolean,

	sizeof(Boolean), XtOffset(AppData, applyAccelerators),

	XtRImmediate, (XtPointer) True,

	},

	{

	"applyOverrides", "ApplyOverrides", XtRBoolean,

	sizeof(Boolean), XtOffset(AppData, applyOverrides),

	XtRImmediate, (XtPointer) True,

	},

	{

	"numShells", "NumShells", XtRCardinal,

	sizeof(Cardinal), XtOffset(AppData, numShells),

	XtRImmediate, (XtPointer) 1,

	},

	{

	"numRows", "NumRows", XtRInt,

	sizeof(Cardinal), XtOffset(AppData, numRows),

	XtRImmediate, (XtPointer) 2,

	},

	{

	"numCols", "NumCols", XtRInt,

	sizeof(Cardinal), XtOffset(AppData, numCols),

	XtRImmediate, (XtPointer) 3,

	},

};

Widget	myDC;

Atom	COMPOUND_TEXT;

Atom	DELETE;

Atom	NULL_ATOM;

Widget	xmDisplay;

Boolean	use_instruction_box;

unsigned char	initiatorProtocolStyle;

unsigned char	receiverProtocolStyle;

Widget	  Form;

Widget  Whichanim_Pulldown;

Widget  Whichanim_Option;

Widget  DragUnderHighLight, DragUnderShadowOut, DragUnderShadowIn, 

		DragUnderNone, DragUnderPixmap;

Widget  WhichdropAct_Pulldown;

Widget  WhichdropAct_Option;

Widget	dropActive, dropInactive;

Widget  WhichdropOp_Pulldown;

Widget  WhichdropOp_Option;

Widget	dropMoveCopy, dropMoveOnly, dropCopyOnly, dropLinkOnly,

		dropMoveLink, dropCopyLink, dropAll, dropNone;

Widget  WhichdragOp_Pulldown;

Widget  WhichdragOp_Option;

Widget	dragMoveCopy, dragMoveOnly, dragCopyOnly, dragLinkOnly,

		dragMoveLink, dragCopyLink, dragAll, dragNone;

Widget  ApplyChanges;

unsigned char	animationStyle;

unsigned char	dropActivity;

unsigned char	dropOperations;

unsigned char	dragOperations;

Widget	dropSites[MAX_DROPSITES];

int		numDropSites;

#ifdef DEBUG

FILE	*outfp;

#endif

static void Quit()

{

	printf("Begin exiting ... please standby ... \n");

#ifdef DEBUG

	fflush(outfp);

	fclose(outfp);

#endif

	exit(0);

}

/*ARGSUSED*/

static Boolean DragConvertProc(w, selection, target, typeRtn, valueRtn, 

							  lengthRtn, formatRtn, max_lengthRtn, 

							  client_data, request_id)

Widget              w;

Atom                *selection;

Atom                *target;

Atom                *typeRtn;

XtPointer           *valueRtn;

unsigned long       *lengthRtn;

int                 *formatRtn;

unsigned long       *max_lengthRtn;

XtPointer			client_data;

XtRequestId			*request_id;

{

	char	*string = "return value";

	int		ok;

	XTextProperty tmp_prop;

	if (*target != COMPOUND_TEXT && *target != DELETE)

		return(False);

	if (*target == COMPOUND_TEXT) {

		ok = 0;

		ok = XmbTextListToTextProperty(display, &string, 1, 

									   XCompoundTextStyle, &tmp_prop);

		if (ok != Success)

			return(False);

		*valueRtn = (char *) tmp_prop.value;

		*lengthRtn = tmp_prop.nitems;

		*typeRtn = COMPOUND_TEXT;

		*formatRtn = 8;

		return(True);

	}

	if (*target == DELETE) {

#ifdef DEBUG

		fprintf(outfp, "DELETE target encountered\n");

#endif

		*typeRtn = NULL_ATOM;

		*valueRtn = NULL;

		*lengthRtn = 0;

		*formatRtn = 8;

		return(True);

	}

}

/*ARGSUSED*/

static void DragMotionCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragMotionCallback	DragMotion;

	DragMotion = (XmDragMotionCallback )call_data;

#ifdef DEBUG

	fprintf(outfp, "Drag Motion! \n");

	fprintf(outfp, "operation = %d\n", DragMotion->operation);

	fprintf(outfp, "dropSiteStatus = %d\n", DragMotion->dropSiteStatus);

	fprintf(outfp, "x = %d\n", DragMotion->x);

	fprintf(outfp, "y = %d\n", DragMotion->y);

#endif

}

/*ARGSUSED*/

static void DnDFinishCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	Widget						dc;

	XmDragDropFinishCallback	DndFinish;

	Widget						source_icon, state_icon, op_icon;

	Arg							args[MAX_ARGS];

	int							n;

	dc = w;

	DndFinish = (XmDragDropFinishCallback )call_data;

	source_icon = state_icon = op_icon = NULL;

	n = 0;

	XtSetArg(args[n], XmNsourceCursorIcon, &source_icon); n++;

	XtSetArg(args[n], XmNstateCursorIcon, &state_icon); n++;

	XtSetArg(args[n], XmNoperationCursorIcon, &op_icon); n++;

	XtGetValues(dc, args, n);

	if (source_icon != NULL)

		XtDestroyWidget(source_icon);

	if (state_icon != NULL)

		XtDestroyWidget(state_icon);

	if (op_icon != NULL)

		XtDestroyWidget(op_icon);

#ifdef DEBUG

	fprintf(outfp, "DND Finish! \n");

#endif

}

/*ARGSUSED*/

static void DropFinishCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDropFinishCallback	DropFinish;

	DropFinish = (XmDropFinishCallback )call_data;

#ifdef DEBUG

	fprintf(outfp, "Drop Finish! \n");

	fprintf(outfp, "operation = %d\n", DropFinish->operation);

	fprintf(outfp, "dropSiteStatus = %d\n", DropFinish->dropSiteStatus);

	fprintf(outfp, "dropAction = %d\n", DropFinish->dropAction);

	fprintf(outfp, "completionStatus = %d\n", DropFinish->completionStatus);

#endif

}

/*ARGSUSED*/

static void DropSiteEnterCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDropSiteEnterCallback	DropSiteEnter;

	DropSiteEnter = (XmDropSiteEnterCallback )call_data;

#ifdef DEBUG

	fprintf(outfp, "Drop Site Enter! \n");

	fprintf(outfp, "operation = %d\n", DropSiteEnter->operation);

	fprintf(outfp, "dropSiteStatus = %d\n", DropSiteEnter->dropSiteStatus);

	fprintf(outfp, "x = %d\n", DropSiteEnter->x);

	fprintf(outfp, "y = %d\n", DropSiteEnter->y);

#endif

}

/*ARGSUSED*/

static void DropSiteLeaveCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDropSiteLeaveCallback	DropSiteLeave;

	DropSiteLeave = (XmDropSiteLeaveCallback )call_data;

#ifdef DEBUG

	fprintf(outfp, "Drop Site Leave! \n");

#endif

}

/*ARGSUSED*/

static void DropStartCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDropStartCallback	DropStart;

	DropStart = (XmDropStartCallback )call_data;

#ifdef DEBUG

	fprintf(outfp, "Drop Start! \n");

	fprintf(outfp, "operation = %d\n", DropStart->operation);

	fprintf(outfp, "dropSiteStatus = %d\n", DropStart->dropSiteStatus);

	fprintf(outfp, "dropAction = %d\n", DropStart->dropAction);

	fprintf(outfp, "x = %d\n", DropStart->x);

	fprintf(outfp, "y = %d\n", DropStart->y);

#endif

}

/*ARGSUSED*/

static void TopLEnterCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmTopLevelEnterCallback	TopLEnter;

	TopLEnter = (XmTopLevelEnterCallback )call_data;

#ifdef DEBUG

	fprintf(outfp, "TopLevel Enter! \n");

	fprintf(outfp, "window = %ld\n", TopLEnter->window);

	fprintf(outfp, "x = %d\n", TopLEnter->x);

	fprintf(outfp, "y = %d\n", TopLEnter->y);

	fprintf(outfp, "dragProtocolStyle = %d\n", TopLEnter->dragProtocolStyle);

#endif

}

/*ARGSUSED*/

static void TopLLeaveCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmTopLevelLeaveCallback	TopLLeave;

	TopLLeave = (XmTopLevelLeaveCallback )call_data;

#ifdef DEBUG

	fprintf(outfp, "TopLevel Leave! \n");

	fprintf(outfp, "window = %ld\n", TopLLeave->window);

#endif

}

/*ARGSUSED*/

static void StartDrag(w, event)

Widget	w;

XEvent	*event;

{

	Arg			args[MAX_ARGS];

	Cardinal	n;

	Atom		exportList[1];

	static XtCallbackRec DragMotionCB[2] = 

	{

		{DragMotionCallback,NULL},

		{NULL, NULL}

	};

	static XtCallbackRec DnDFinishCB[2] = 

	{

		{DnDFinishCallback,NULL},

		{NULL, NULL}

	};

	static XtCallbackRec DropFinishCB[2] = 

	{

		{DropFinishCallback,NULL},

		{NULL, NULL}

	};

	static XtCallbackRec DropSiteEnterCB[2] = 

	{

		{DropSiteEnterCallback,NULL},

		{NULL, NULL}

	};

	static XtCallbackRec DropSiteLeaveCB[2] = 

	{

		{DropSiteLeaveCallback,NULL},

		{NULL, NULL}

	};

	static XtCallbackRec DropStartCB[2] = 

	{

		{DropStartCallback,NULL},

		{NULL, NULL}

	};

	static XtCallbackRec TopLEnterCB[2] = 

	{

		{TopLEnterCallback,NULL},

		{NULL, NULL}

	};

	static XtCallbackRec TopLLeaveCB[2] = 

	{

		{TopLLeaveCallback,NULL},

		{NULL, NULL}

	};

	exportList[0] = COMPOUND_TEXT;

	n = 0;

	XtSetArg(args[n], XmNconvertProc, DragConvertProc); n++;

	XtSetArg(args[n], XmNdragDropFinishCallback, DnDFinishCB); n++;

	XtSetArg(args[n], XmNdropFinishCallback, DropFinishCB); n++;

	XtSetArg(args[n], XmNdropSiteEnterCallback, DropSiteEnterCB); n++;

	XtSetArg(args[n], XmNdropSiteLeaveCallback, DropSiteLeaveCB); n++;

	XtSetArg(args[n], XmNdropStartCallback, DropStartCB); n++;

	XtSetArg(args[n], XmNtopLevelEnterCallback, TopLEnterCB); n++;

	XtSetArg(args[n], XmNtopLevelLeaveCallback, TopLLeaveCB); n++;

	XtSetArg(args[n], XmNexportTargets, exportList); n++;

	XtSetArg(args[n], XmNnumExportTargets, 1); n++;

	XtSetArg(args[n], XmNdragOperations, dragOperations); n++;

	myDC = XmDragStart(w, event, args, n);

}

/*ARGSUSED*/

static void HandleDrag(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragProcCallback	DragProc;

	DragProc = (XmDragProcCallback)call_data;

#ifdef DEBUG

	fprintf(outfp, "DragProc !\n");

	fprintf(outfp, "reason = %d\n", DragProc->reason);

#endif

}

/*ARGSUSED*/

static void DropTransferCallback(w, closure, seltype, type, value, 

								 length, format)

Widget 			w;

XtPointer 		closure ;

Atom 			*seltype ;

Atom 			*type ;

XtPointer 		value ;

unsigned long	*length ;

int 			*format ;

{

	XTextProperty	tmp_prop;

	int 			num_vals;

	int				ok;

	char 			*total_tmp_value = NULL;

	char 			**tmp_value;

	int 			malloc_size = 0;

	char 			*actual_value;

	int				actual_length = 0;

	Cardinal		i;

	if (*length)

		if (*type == COMPOUND_TEXT) {

       		tmp_prop.value = (unsigned char *) value;

	   		tmp_prop.encoding = *type;

			tmp_prop.format = 8;

			tmp_prop.nitems = *length;

			num_vals = 0;

			ok = 0;

			ok = XmbTextPropertyToTextList(display, &tmp_prop, &tmp_value,

										   &num_vals);

			if (num_vals && (ok == Success || ok > 0)) {

				for (i = 0; i < num_vals; i++)

					malloc_size += strlen(*tmp_value + i);

				total_tmp_value = XtMalloc ((unsigned) malloc_size + 1);

				total_tmp_value[0] = '\0';

				for (i = 0; i < num_vals ; i++)

					strcat(total_tmp_value, *tmp_value + i);

				actual_value = total_tmp_value;

				actual_length = strlen(total_tmp_value);

#ifdef DEBUG

				fprintf(stderr, "the transfer value is : %s\n", actual_value);

				fprintf(stderr, "the length of transfer is : %d\n", 

						actual_length);

#endif

				XFreeStringList(tmp_value);

			}

			else {

				if (value) {

					XtFree((char *)value);

					value = NULL;

				}

				actual_length = -1;

			}

		}

#ifdef DEBUG

	if (actual_length != -1) {

		if (*type == COMPOUND_TEXT)

			fprintf(outfp, "the transfer value is : %s\n", actual_value);

		else if (*type == XA_PIXMAP)

			fprintf(outfp, "the transfer value is of type pixmap\n");

		else if (*type == XA_BITMAP)

			fprintf(outfp, "the transfer value is of type bitmap\n");

		else if (*type == NULL_ATOM)

			fprintf(outfp, "the transfer value is of type NULL\n");

	}

#endif

	/* You no longer need it, so free it */

	if (total_tmp_value != NULL)

		XtFree(total_tmp_value);

}

/*ARGSUSED*/

static void HandleDrop(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDropProcCallback		DropProc;

	Widget				 	dc;

	XmDropTransferEntryRec	transferEntries[2];

	XmDropTransferEntry		transferList;

	Cardinal			 	numTransfers = 0;

	Cardinal			 	numExportTargets;

	Atom				 	*exportTargets;

	Cardinal			 	numImportTargets;

	Atom				 	*importTargets;

	Arg					 	args[MAX_ARGS];

	int						n;

	char					*string = "TestString";

#ifdef DEBUG

	unsigned char			dragOp, dropSiteOp;

#endif

	DropProc = (XmDropProcCallback)call_data;

	dc = DropProc->dragContext;

	n = 0;

	XtSetArg(args[n], XmNexportTargets, &exportTargets); n++;

	XtSetArg(args[n], XmNnumExportTargets, &numExportTargets); n++;

	XtGetValues(dc, args, n);

	n = 0;

	XtSetArg(args[n], XmNimportTargets, &importTargets); n++;

	XtSetArg(args[n], XmNnumImportTargets, &numImportTargets); n++;

	XmDropSiteRetrieve(w, args, n);

#ifdef DEBUG

	fprintf(outfp, "DropProc !\n");

	fprintf(outfp, "x = %d\n", DropProc->x);

	fprintf(outfp, "y = %d\n", DropProc->y);

	fprintf(outfp, "dropSiteStatus = %d\n", DropProc->dropSiteStatus);

	fprintf(outfp, "operations = %d\n", DropProc->operations);

	fprintf(outfp, "operation = %d\n", DropProc->operation);

	fprintf(outfp, "dropAction = %d\n", DropProc->dropAction);

#endif

	transferEntries[0].target = COMPOUND_TEXT;

	transferEntries[0].client_data = string;

#ifdef DEBUG

	n = 0;

	XtSetArg(args[n], XmNdropSiteOperations, &dropSiteOp); n++;

	XmDropSiteRetrieve(w, args, n);

	fprintf(outfp, "operations = %d\n", DropProc->operations);

	fprintf(outfp, "operation = %d\n", DropProc->operation);

	fprintf(outfp, "dragOp = %d\n", dragOp);

	fprintf(outfp, "dropSiteOp = %d\n", dropSiteOp);

#endif

	n = 0;

	if (XmTargetsAreCompatible(display, exportTargets, numExportTargets,

							   importTargets, numImportTargets) == False) {

		XtSetArg(args[n], XmNtransferStatus, XmTRANSFER_FAILURE); n++;

		XtSetArg(args[n], XmNnumDropTransfers, 0); n++;

	}

	else {

		if (DropProc->operation & XmDROP_MOVE || 

			DropProc->operation & XmDROP_COPY) {

			transferList = transferEntries;

			numTransfers = 1;

			XtSetArg(args[n], XmNdropTransfers, transferList); n++;

			XtSetArg(args[n], XmNnumDropTransfers, numTransfers); n++;

			XtSetArg(args[n], XmNtransferProc, DropTransferCallback); n++;

		} 

		else {

			if (DropProc->operation & XmDROP_LINK)

				fprintf(stderr, "Link Operation currently not supported\n");

			XtSetArg(args[n], XmNtransferStatus, XmTRANSFER_FAILURE); n++;

			XtSetArg(args[n], XmNnumDropTransfers, 0); n++;

		}

	}

	XmDropTransferStart(dc, args, n);

}

/*************End of CALLBACK PROCEDURES****************/

static int ProtoError(dpy, ev)

Display		*dpy;

XErrorEvent	*ev;

{

	fprintf(stderr, "Proto Error\n");

#ifdef DEBUG

	fflush(outfp);

	fclose(outfp);

#endif

	exit(0);

}

/*ARGSUSED*/

static void DragUnderHighLightCB(Widget w, XtPointer client_data, 

								 XtPointer call_data)

{

	animationStyle = XmDRAG_UNDER_HIGHLIGHT;

	return;

}

/*ARGSUSED*/

static void DragUnderShadowOutCB(Widget w, XtPointer client_data, 

									 XtPointer call_data)

{

	animationStyle = XmDRAG_UNDER_SHADOW_OUT;

	return;

}

/*ARGSUSED*/

static void DragUnderShadowInCB(Widget w, XtPointer client_data, 

									 XtPointer call_data)

{

	animationStyle = XmDRAG_UNDER_SHADOW_IN;

	return;

}

/*ARGSUSED*/

static void DragUnderPixmapCB(Widget w, XtPointer client_data, 

									 XtPointer call_data)

{

	animationStyle = XmDRAG_UNDER_PIXMAP;

	return;

}

/*ARGSUSED*/

static void DragUnderNoneCB(Widget w, XtPointer client_data, 

									 XtPointer call_data)

{

	animationStyle = XmDRAG_UNDER_SHADOW_OUT;

	return;

}

/*ARGSUSED*/

static void dropActiveCB(Widget w, XtPointer client_data, 

							 XtPointer call_data)

{

	dropActivity = XmDROP_SITE_ACTIVE;

	return;

}

/*ARGSUSED*/

static void dropInactiveCB(Widget w, XtPointer client_data, 

						   XtPointer call_data)

{

	dropActivity = XmDROP_SITE_INACTIVE;

	return;

}

/*ARGSUSED*/

static void dropMoveCopyCB(Widget w, XtPointer client_data, 

						   XtPointer call_data)

{

	dropOperations = XmDROP_MOVE | XmDROP_COPY;

	return;

}

/*ARGSUSED*/

static void dropMoveOnlyCB(Widget w, XtPointer client_data, 

						   XtPointer call_data)

{

	dropOperations = XmDROP_MOVE;

	return;

}

/*ARGSUSED*/

static void dropCopyOnlyCB(Widget w, XtPointer client_data, 

						   XtPointer call_data)

{

	dropOperations = XmDROP_COPY;

	return;

}

/*ARGSUSED*/

static void dropLinkOnlyCB(Widget w, XtPointer client_data, 

						   XtPointer call_data)

{

	dropOperations = XmDROP_LINK;

	return;

}

/*ARGSUSED*/

static void dropMoveLinkCB(Widget w, XtPointer client_data, 

						   XtPointer call_data)

{

	dropOperations = XmDROP_MOVE | XmDROP_LINK;

	return;

}

/*ARGSUSED*/

static void dropCopyLinkCB(Widget w, XtPointer client_data, 

						   XtPointer call_data)

{

	dropOperations = XmDROP_COPY | XmDROP_LINK;

	return;

}

/*ARGSUSED*/

static void dropAllCB(Widget w, XtPointer client_data, 

						   XtPointer call_data)

{

	dropOperations = XmDROP_MOVE | XmDROP_COPY | XmDROP_LINK;

	return;