/* 

 * 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: DNDIcon2.c /main/11 1996/10/07 14:51:28 drk $"

#endif

#endif

/*

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

/*

 *	file: DNDIcon2.c

 *

 *	This tests the various Icons used during a Drag and Drop transaction.

 *	This test needs to be expanded to include changing of icons on the fly,

 *	and test that the new icons correctly override the default icons.

 *

 */

#include <signal.h>

#include <stdio.h>

#include <testlib.h>

#include <Xm/Screen.h>

#include <Xm/DragDrop.h>

#include <X11/keysym.h>

#include <X11/Xatom.h>

#include <X11/cursorfont.h>

#include "DNDIcons.h"

#define	MAX_DROPSITES	100

static Widget   CreatePushButton();

static void	 	Quit();

static void	 	StartDrag();

enum {DEFAULT_OP, OP_ICON1, OP_ICON2, OP_ICON3};

enum {DEFAULT_STATE, STATE_ICON1, STATE_ICON2, STATE_ICON3};

enum {DEFAULT_SRC, SRC_ICON1, SRC_ICON2, SRC_ICON3};

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;

Widget	xmScreen;

Widget	defCopyIcon, defMoveIcon, defLinkIcon;

Widget	defVIcon, defInvIcon, defNoneIcon, defSrcIcon;

Widget	opIcon1, opIcon2, opIcon3;

Widget	stateIcon1, stateIcon2, stateIcon3;

Widget	srcIcon1, srcIcon2, srcIcon3;

Widget	opIcon, stateIcon, srcIcon;

int		opIcon_value, stateIcon_value, srcIcon_value;

Boolean	use_instruction_box;

unsigned char	initiatorProtocolStyle;

unsigned char	receiverProtocolStyle;

Boolean	use_small_icons;

Boolean	no_background;

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  WhichBlend_Pulldown;

Widget  WhichBlend_Option;

Widget	blendAll, blendStateSource, blendJustSource, blendNone;

Widget  WhichOpAttach_Pulldown;

Widget  WhichOpAttach_Option;

Widget	Op_northwest, Op_north, Op_northeast, Op_east, Op_southeast, 

		Op_south, Op_southwest, Op_west, Op_center;

Widget  WhichStateAttach_Pulldown;

Widget  WhichStateAttach_Option;

Widget	State_northwest, State_north, State_northeast, State_east, 

		State_southeast, State_south, State_southwest, State_west, State_center;

Widget  WhichForeground_Pulldown;

Widget  WhichForeground_Option;

Widget	redFG, blackFG, yellowFG, greenFG, whiteFG;

Widget  WhichBackground_Pulldown;

Widget  WhichBackground_Option;

Widget	redBG, blackBG, yellowBG, greenBG, whiteBG;

Widget  WhichOpIcon_Pulldown;

Widget  WhichOpIcon_Option;

Widget	OpIcon1, OpIcon2, OpIcon3, defOpIcon;

Widget  WhichStateIcon_Pulldown;

Widget  WhichStateIcon_Option;

Widget	StateIcon1, StateIcon2, StateIcon3, defStateIcon;

Widget  WhichSrcIcon_Pulldown;

Widget  WhichSrcIcon_Option;

Widget	SrcIcon1, SrcIcon2, SrcIcon3, defSrcIcon;

Widget  ApplyChanges;

unsigned char	animationStyle;

unsigned char	dropActivity;

unsigned char	dropOperations;

unsigned char	dragOperations;

unsigned char	blendModel;

unsigned char	Op_attachment, State_attachment;

Pixel			cursorForeground;

Pixel			cursorBackground;

Pixel	redPixel, blackPixel, yellowPixel, greenPixel, whitePixel;

Widget	dropSites[MAX_DROPSITES];

int		numDropSites;

#ifdef DEBUG

FILE	*outfp;

#endif

Boolean	change_op = False;

/*ARGSUSED*/

static void Quit (void )

{

	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);

	}

}

static void DragMotionCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	Widget					dc;

	Widget					opIcon, stateIcon;

	XmDragMotionCallback	DragMotion;

	Arg						args[MAX_ARGS];

	Cardinal				n;

	static int				count = 0;

	dc = w;

	DragMotion = (XmDragMotionCallback )call_data;

	if (change_op == True) {

		if (count == 0) {

			n = 0;

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

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

			XtGetValues(dc, args, n);

			n = 0;

			XtSetArg(args[n], XmNattachment, Op_attachment); n++;

			XtSetValues(opIcon, args, n);

			n = 0;

			XtSetArg(args[n], XmNattachment, State_attachment); n++;

			XtSetValues(stateIcon, args, n);

			count++;

		}

	}

#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

}

static void DnDFinishCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragContext				dc;

	XmDragDropFinishCallback	DndFinish;

	Widget						source_icon, state_icon, op_icon;

	Arg							args[MAX_ARGS];

	int							n;

	dc = (XmDragContext)w;

	DndFinish = (XmDragDropFinishCallback )call_data;

	source_icon = state_icon = op_icon = NULL;

#ifdef DEBUG

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

#endif

}

static void DropFinishCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragContext			dc;

	XmDropFinishCallback	DropFinish;

	Widget					source_icon, state_icon, op_icon;

	Arg						args[MAX_ARGS];

	int						n;

	dc = (XmDragContext)w;

	DropFinish = (XmDropFinishCallback )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((Widget) dc, args, n);

#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

}

static void DropSiteEnterCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragContext			dc;

	XmDropSiteEnterCallback	DropSiteEnter;

	dc = (XmDragContext)w;

	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

}

static void DropSiteLeaveCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragContext			dc;

	XmDropSiteLeaveCallback	DropSiteLeave;

	Arg						args[MAX_ARGS];

	int						n;

	dc = (XmDragContext)w;

	DropSiteLeave = (XmDropSiteLeaveCallback )call_data;

#ifdef DEBUG

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

#endif

}

static void DropStartCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragContext		dc;

	XmDropStartCallback	DropStart;

	dc = (XmDragContext)w;

	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

}

static void TopLEnterCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragContext			dc;

	XmTopLevelEnterCallback	TopLEnter;

	dc = (XmDragContext)w;

	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

}

static void TopLLeaveCallback(w, client_data, call_data)

Widget		w;

XtPointer	client_data, call_data;

{

	XmDragContext			dc;

	XmTopLevelLeaveCallback	TopLLeave;

	dc = (XmDragContext)w;

	TopLLeave = (XmTopLevelLeaveCallback )call_data;

#ifdef DEBUG

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

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

#endif

}

static void CreateDefaultDragIcons(w)

Widget	w;

{

	Pixmap	defCopyPix, defMovePix, defLinkPix;

	Pixmap	defVPix, defInvPix, defNonePix, defSrcPix;

	int		n;

	Arg		args[MAX_ARGS];

	static int	count = 0;

	if (count == 0) {

		if (use_small_icons == False) {

			defCopyPix = XCreateBitmapFromData(display, XtWindow(w), 

											   defCopy_bits,

									   		   defCopy_width, defCopy_height);

			defMovePix = XCreateBitmapFromData(display, XtWindow(w), 

											   defMove_bits, defMove_width, 

											   defMove_height);

			defLinkPix = XCreateBitmapFromData(display, XtWindow(w), 

											   defLink_bits, defLink_width, 

											   defLink_height);

			defVPix = XCreateBitmapFromData(display, XtWindow(w), defV_bits,

											defV_width, defV_height);

			defInvPix = XCreateBitmapFromData(display, XtWindow(w), defInv_bits,

									  		  defInv_width, defInv_height);

			defNonePix = XCreateBitmapFromData(display, XtWindow(w), 

											   defNone_bits,

									   		   defNone_width, defNone_height);

			defSrcPix = XCreateBitmapFromData(display, XtWindow(w), defSrc_bits,

									  		  defSrc_width, defSrc_height);

			n = 0;

			XtSetArg(args[n], XmNwidth, defCopy_width); n++;

			XtSetArg(args[n], XmNheight, defCopy_height); n++;

			XtSetArg(args[n], XmNhotX, defCopy_x_hot); n++;

			XtSetArg(args[n], XmNhotY, defCopy_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defCopyPix); n++;

			XtSetArg(args[n], XmNattachment, Op_attachment); n++;

			defCopyIcon = XmCreateDragIcon(w, "defCopyIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, defMove_width); n++;

			XtSetArg(args[n], XmNheight, defMove_height); n++;

			XtSetArg(args[n], XmNhotX, defMove_x_hot); n++;

			XtSetArg(args[n], XmNhotY, defMove_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defMovePix); n++;

			XtSetArg(args[n], XmNattachment, Op_attachment); n++;

			defMoveIcon = XmCreateDragIcon(w, "defMoveIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, defLink_width); n++;

			XtSetArg(args[n], XmNheight, defLink_height); n++;

			XtSetArg(args[n], XmNhotX, defLink_x_hot); n++;

			XtSetArg(args[n], XmNhotY, defLink_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defLinkPix); n++;

			XtSetArg(args[n], XmNattachment, Op_attachment); n++;

			defLinkIcon = XmCreateDragIcon(w, "defLinkIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, defV_width); n++;

			XtSetArg(args[n], XmNheight, defV_height); n++;

			XtSetArg(args[n], XmNhotX, defV_x_hot); n++;

			XtSetArg(args[n], XmNhotY, defV_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defVPix); n++;

			XtSetArg(args[n], XmNattachment, State_attachment); n++;

			defVIcon = XmCreateDragIcon(w, "defVIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, defInv_width); n++;

			XtSetArg(args[n], XmNheight, defInv_height); n++;

			XtSetArg(args[n], XmNhotX, defInv_x_hot); n++;

			XtSetArg(args[n], XmNhotY, defInv_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defInvPix); n++;

			XtSetArg(args[n], XmNattachment, State_attachment); n++;

			defInvIcon = XmCreateDragIcon(w, "defInvIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, defNone_width); n++;

			XtSetArg(args[n], XmNheight, defNone_height); n++;

			XtSetArg(args[n], XmNhotX, defNone_x_hot); n++;

			XtSetArg(args[n], XmNhotY, defNone_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defNonePix); n++;

			XtSetArg(args[n], XmNattachment, State_attachment); n++;

			defNoneIcon = XmCreateDragIcon(w, "defNoneIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, defSrc_width); n++;

			XtSetArg(args[n], XmNheight, defSrc_height); n++;

			XtSetArg(args[n], XmNhotX, defSrc_x_hot); n++;

			XtSetArg(args[n], XmNhotY, defSrc_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defSrcPix); n++;

			defSrcIcon = XmCreateDragIcon(w, "defSrcIcon", args, n);

		}

		else {

			defCopyPix = XCreateBitmapFromData(display, XtWindow(w), 

											   copy_bits,

									   		   copy_width, copy_height);

			defMovePix = XCreateBitmapFromData(display, XtWindow(w), 

											   move_bits, move_width, 

											   move_height);

			defLinkPix = XCreateBitmapFromData(display, XtWindow(w), 

											   link_bits, link_width, 

											   link_height);

			defVPix = XCreateBitmapFromData(display, XtWindow(w), valid_bits,

											valid_width, valid_height);

			defInvPix = XCreateBitmapFromData(display, XtWindow(w), 

											  invalid_bits, invalid_width, 

											  invalid_height);

			defNonePix = XCreateBitmapFromData(display, XtWindow(w), 

											   none_bits, none_width, 

											   none_height);

			defSrcPix = XCreateBitmapFromData(display, XtWindow(w), src_bits,

									  		  src_width, src_height);

			n = 0;

			XtSetArg(args[n], XmNwidth, copy_width); n++;

			XtSetArg(args[n], XmNheight, copy_height); n++;

			XtSetArg(args[n], XmNhotX, copy_x_hot); n++;

			XtSetArg(args[n], XmNhotY, copy_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defCopyPix); n++;

			XtSetArg(args[n], XmNattachment, Op_attachment); n++;

			defCopyIcon = XmCreateDragIcon(w, "defCopyIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, move_width); n++;

			XtSetArg(args[n], XmNheight, move_height); n++;

			XtSetArg(args[n], XmNhotX, move_x_hot); n++;

			XtSetArg(args[n], XmNhotY, move_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defMovePix); n++;

			XtSetArg(args[n], XmNattachment, Op_attachment); n++;

			defMoveIcon = XmCreateDragIcon(w, "defMoveIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, link_width); n++;

			XtSetArg(args[n], XmNheight, link_height); n++;

			XtSetArg(args[n], XmNhotX, link_x_hot); n++;

			XtSetArg(args[n], XmNhotY, link_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defLinkPix); n++;

			XtSetArg(args[n], XmNattachment, Op_attachment); n++;

			defLinkIcon = XmCreateDragIcon(w, "defLinkIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, valid_width); n++;

			XtSetArg(args[n], XmNheight, valid_height); n++;

			XtSetArg(args[n], XmNhotX, valid_x_hot); n++;

			XtSetArg(args[n], XmNhotY, valid_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defVPix); n++;

			XtSetArg(args[n], XmNattachment, State_attachment); n++;

			defVIcon = XmCreateDragIcon(w, "defVIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, invalid_width); n++;

			XtSetArg(args[n], XmNheight, invalid_height); n++;

			XtSetArg(args[n], XmNhotX, invalid_x_hot); n++;

			XtSetArg(args[n], XmNhotY, invalid_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defInvPix); n++;

			XtSetArg(args[n], XmNattachment, State_attachment); n++;

			defInvIcon = XmCreateDragIcon(w, "defInvIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, none_width); n++;

			XtSetArg(args[n], XmNheight, none_height); n++;

			XtSetArg(args[n], XmNhotX, none_x_hot); n++;

			XtSetArg(args[n], XmNhotY, none_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defNonePix); n++;

			XtSetArg(args[n], XmNattachment, State_attachment); n++;

			defNoneIcon = XmCreateDragIcon(w, "defNoneIcon", args, n);

			n = 0;

			XtSetArg(args[n], XmNwidth, src_width); n++;

			XtSetArg(args[n], XmNheight, src_height); n++;

			XtSetArg(args[n], XmNhotX, src_x_hot); n++;

			XtSetArg(args[n], XmNhotY, src_y_hot); n++;

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

			XtSetArg(args[n], XmNpixmap, defSrcPix); n++;

			defSrcIcon = XmCreateDragIcon(w, "defSrcIcon", args, n);

		}

		count++;

	}

	else {

		n = 0;

		XtSetArg(args[n], XmNattachment, Op_attachment); n++;

		XtSetValues(defCopyIcon, args, n);

		XtSetValues(defMoveIcon, args, n);

		XtSetValues(defLinkIcon, args, n);

		n = 0;

		XtSetArg(args[n], XmNattachment, State_attachment); n++;

		XtSetValues(defVIcon, args, n);

		XtSetValues(defInvIcon, args, n);

		XtSetValues(defNoneIcon, args, n);

	}

	n = 0;

	XtSetArg(args[n], XmNdefaultCopyCursorIcon, defCopyIcon); n++;

	XtSetArg(args[n], XmNdefaultMoveCursorIcon, defMoveIcon); n++;

	XtSetArg(args[n], XmNdefaultLinkCursorIcon, defLinkIcon); n++;

	XtSetArg(args[n], XmNdefaultValidCursorIcon, defVIcon); n++;

	XtSetArg(args[n], XmNdefaultInvalidCursorIcon, defInvIcon); n++;

	XtSetArg(args[n], XmNdefaultNoneCursorIcon, defNoneIcon); n++;

	XtSetArg(args[n], XmNdefaultSourceCursorIcon, defSrcIcon); n++;

	XtSetValues(xmScreen, args, n);

}

static void CreateOtherDragIcons(w)

Widget	w;

{

	Pixmap	opPix, statePix, srcPix;

	int		n;

	Arg		args[MAX_ARGS];

	static int	count = 0;

	if (count == 0) {

		opPix = XCreateBitmapFromData(display, XtWindow(w), opIcon1_bits,

									   opIcon1_width, opIcon1_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, opIcon1_width); n++;

		XtSetArg(args[n], XmNheight, opIcon1_height); n++;

		XtSetArg(args[n], XmNhotX, opIcon1_x_hot); n++;

		XtSetArg(args[n], XmNhotY, opIcon1_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, opPix); n++;

		opIcon1 = XmCreateDragIcon(w, "opIcon1", args, n);

		opPix = XCreateBitmapFromData(display, XtWindow(w), opIcon2_bits,

										   opIcon2_width, opIcon2_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, opIcon2_width); n++;

		XtSetArg(args[n], XmNheight, opIcon2_height); n++;

		XtSetArg(args[n], XmNhotX, opIcon2_x_hot); n++;

		XtSetArg(args[n], XmNhotY, opIcon2_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, opPix); n++;

		opIcon2 = XmCreateDragIcon(w, "opIcon2", args, n);

		opPix = XCreateBitmapFromData(display, XtWindow(w), opIcon3_bits,

										   opIcon3_width, opIcon3_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, opIcon3_width); n++;

		XtSetArg(args[n], XmNheight, opIcon3_height); n++;

		XtSetArg(args[n], XmNhotX, opIcon3_x_hot); n++;

		XtSetArg(args[n], XmNhotY, opIcon3_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, opPix); n++;

		opIcon3 = XmCreateDragIcon(w, "opIcon3", args, n);

		statePix = XCreateBitmapFromData(display, XtWindow(w), stateIcon1_bits,

									   stateIcon1_width, stateIcon1_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, stateIcon1_width); n++;

		XtSetArg(args[n], XmNheight, stateIcon1_height); n++;

		XtSetArg(args[n], XmNhotX, stateIcon1_x_hot); n++;

		XtSetArg(args[n], XmNhotY, stateIcon1_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, statePix); n++;

		stateIcon1 = XmCreateDragIcon(w, "stateIcon1", args, n);

		statePix = XCreateBitmapFromData(display, XtWindow(w), stateIcon2_bits,

										   stateIcon2_width, stateIcon2_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, stateIcon2_width); n++;

		XtSetArg(args[n], XmNheight, stateIcon2_height); n++;

		XtSetArg(args[n], XmNhotX, stateIcon2_x_hot); n++;

		XtSetArg(args[n], XmNhotY, stateIcon2_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, statePix); n++;

		stateIcon2 = XmCreateDragIcon(w, "stateIcon2", args, n);

		statePix = XCreateBitmapFromData(display, XtWindow(w), stateIcon3_bits,

										   stateIcon3_width, stateIcon3_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, stateIcon3_width); n++;

		XtSetArg(args[n], XmNheight, stateIcon3_height); n++;

		XtSetArg(args[n], XmNhotX, stateIcon3_x_hot); n++;

		XtSetArg(args[n], XmNhotY, stateIcon3_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, statePix); n++;

		stateIcon3 = XmCreateDragIcon(w, "stateIcon3", args, n);

		srcPix = XCreateBitmapFromData(display, XtWindow(w), 

									   srcIcon1_bits,

									   srcIcon1_width, 

									   srcIcon1_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, srcIcon1_width); n++;

		XtSetArg(args[n], XmNheight, srcIcon1_height); n++;

		XtSetArg(args[n], XmNhotX, srcIcon1_x_hot); n++;

		XtSetArg(args[n], XmNhotY, srcIcon1_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, srcPix); n++;

		srcIcon1 = XmCreateDragIcon(w, "srcIcon1", args, n);

		srcPix = XCreateBitmapFromData(display, XtWindow(w), srcIcon2_bits,

										   srcIcon2_width, srcIcon2_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, srcIcon2_width); n++;

		XtSetArg(args[n], XmNheight, srcIcon2_height); n++;

		XtSetArg(args[n], XmNhotX, srcIcon2_x_hot); n++;

		XtSetArg(args[n], XmNhotY, srcIcon2_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, srcPix); n++;

		srcIcon2 = XmCreateDragIcon(w, "srcIcon2", args, n);

		srcPix = XCreateBitmapFromData(display, XtWindow(w), srcIcon3_bits,

										   srcIcon3_width, srcIcon3_height);

		n = 0;

		XtSetArg(args[n], XmNwidth, srcIcon3_width); n++;

		XtSetArg(args[n], XmNheight, srcIcon3_height); n++;

		XtSetArg(args[n], XmNhotX, srcIcon3_x_hot); n++;

		XtSetArg(args[n], XmNhotY, srcIcon3_y_hot); n++;

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

		XtSetArg(args[n], XmNpixmap, srcPix); n++;

		srcIcon3 = XmCreateDragIcon(w, "srcIcon3", args, n);

		count++;

	}

	else {

		n = 0;

		XtSetArg(args[n], XmNattachment, Op_attachment); n++;

		XtSetValues(opIcon1, args, n);

		XtSetValues(opIcon2, args, n);

		XtSetValues(opIcon3, args, n);