/* 

 * 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[] = "$TOG: Screen.c /main/16 1997/06/18 17:41:50 samborn $"

#endif

#endif

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

/* (c) Copyright 1987, 1988, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */

/* (c) Copyright 1988 MASSACHUSETTS INSTITUTE OF TECHNOLOGY */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdio.h>

#include <X11/Xatom.h>

#include <Xm/Xm.h>		/* To make cpp on Sun happy. CR 5943 */

#include <Xm/AtomMgr.h>

#include <Xm/DisplayP.h>

#include "DragIconI.h"

#include "HashI.h"

#include "ImageCachI.h"

#include "MessagesI.h"

#include "RepTypeI.h"

#include "ScreenI.h"

#include "PixConvI.h"

#define DEFAULT_QUAD_WIDTH 10

#define RESOURCE_DEFAULT  (-1)

#define MESSAGE1	_XmMMsgScreen_0000

#define MESSAGE2        _XmMMsgScreen_0001

/********    Static Function Declarations    ********/

static void ClassPartInitialize( 

                        WidgetClass wc) ;

static void ClassInitialize( void ) ;

static void GetUnitFromFont( 

                        Display *display,

                        XFontStruct *fst,

                        int *ph_unit,

                        int *pv_unit) ;

static void Initialize( 

                        Widget requested_widget,

                        Widget new_widget,

                        ArgList args,

                        Cardinal *num_args) ;

static Boolean SetValues( 

                        Widget current,

                        Widget requested,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void Destroy( 

                        Widget widget) ;

static void InsertChild( 

                        Widget wid) ;

static void DeleteChild( 

                        Widget wid) ;

static Boolean MatchPixmap(XmHashKey, XmHashKey) ;

static XmHashValue HashPixmap(XmHashKey) ;

static Boolean FreePixmap(XmHashKey k, XtPointer p, XtPointer client_data) ;

/********    End Static Function Declarations    ********/

#define Offset(x) (XtOffsetOf(XmScreenRec, x))

static XtResource resources[] = {

    {

	XmNdarkThreshold, XmCDarkThreshold, XmRInt,

	sizeof(int), Offset(screen.darkThreshold), 

	XmRImmediate, (XtPointer)NULL, 

    },

    {

	XmNlightThreshold, XmCLightThreshold, XmRInt,

	sizeof(int), Offset(screen.lightThreshold), 

	XmRImmediate, (XtPointer)NULL, 

    },

    {

	XmNforegroundThreshold, XmCForegroundThreshold, XmRInt,

	sizeof(int), Offset(screen.foregroundThreshold), 

	XmRImmediate, (XtPointer)NULL, 

    },

    {

	XmNdefaultNoneCursorIcon, XmCDefaultNoneCursorIcon, XmRWidget,

	sizeof(Widget), Offset(screen.defaultNoneCursorIcon), 

	XmRImmediate, (XtPointer)NULL, 

    },

    {

	XmNdefaultValidCursorIcon, XmCDefaultValidCursorIcon,

	XmRWidget, sizeof(Widget), Offset(screen.defaultValidCursorIcon), 

	XmRImmediate, (XtPointer)NULL, 

    },

    {

	XmNdefaultInvalidCursorIcon, XmCDefaultInvalidCursorIcon, XmRWidget,

	sizeof(Widget), Offset(screen.defaultInvalidCursorIcon),

	XmRImmediate, (XtPointer)NULL, 

    },   

    {

	XmNdefaultMoveCursorIcon, XmCDefaultMoveCursorIcon, XmRWidget,

	sizeof(Widget), Offset(screen.defaultMoveCursorIcon), 

	XmRImmediate, (XtPointer)NULL, 

    },

    {

	XmNdefaultLinkCursorIcon, XmCDefaultLinkCursorIcon,

	XmRWidget, sizeof(Widget), Offset(screen.defaultLinkCursorIcon), 

	XmRImmediate, (XtPointer)NULL, 

    },

    {

	XmNdefaultCopyCursorIcon, XmCDefaultCopyCursorIcon, XmRWidget,

	sizeof(Widget), Offset(screen.defaultCopyCursorIcon),

	XmRImmediate, (XtPointer)NULL, 

    },   

    {

	XmNdefaultSourceCursorIcon, XmCDefaultSourceCursorIcon, XmRWidget,

	sizeof(Widget), Offset(screen.defaultSourceCursorIcon),

	XmRImmediate, (XtPointer)NULL, 

    },   

    {

	XmNmenuCursor, XmCCursor, XmRCursor,

	sizeof(Cursor), Offset(screen.menuCursor),

	XmRString, "arrow",

    },

    {

	XmNunpostBehavior, XmCUnpostBehavior, XmRUnpostBehavior,

	sizeof(unsigned char), Offset(screen.unpostBehavior),

	XmRImmediate, (XtPointer)XmUNPOST_AND_REPLAY,

    },

    {

	XmNfont, XmCFont, XmRFontStruct,

	sizeof(XFontStruct *), Offset(screen.font_struct),

	XmRString, XmDEFAULT_FONT,

    },

    {

	XmNhorizontalFontUnit, XmCHorizontalFontUnit, XmRInt,

	sizeof(int), Offset(screen.h_unit),

	XmRImmediate, (XtPointer) RESOURCE_DEFAULT,

    },

    {

	XmNverticalFontUnit, XmCVerticalFontUnit, XmRInt,

	sizeof(int), Offset(screen.v_unit),

	XmRImmediate, (XtPointer) RESOURCE_DEFAULT,

    },

    {

        XmNmoveOpaque, XmCMoveOpaque, XmRBoolean,

        sizeof(unsigned char), Offset(screen.moveOpaque),

        XmRImmediate, (XtPointer) False,

    },

    {

        XmNcolorCalculationProc, XmCColorCalculationProc, XmRProc,

        sizeof(XtProc), Offset(screen.color_calc_proc),

        XmRImmediate, (XtPointer) NULL,

    },

    {

        XmNcolorAllocationProc, XmCColorAllocationProc, XmRProc,

        sizeof(XtProc), Offset(screen.color_alloc_proc),

        XmRImmediate, (XtPointer) NULL,

    },

    {

        XmNbitmapConversionModel, XmCBitmapConversionModel, 

        XmRBitmapConversionModel,

        sizeof(XtEnum), Offset(screen.bitmap_conversion_model),

        XmRImmediate, (XtPointer) XmMATCH_DEPTH,

    },

    {

        XmNuserData, XmCUserData, XmRPointer, 

        sizeof(XtPointer), Offset(screen.user_data),

        XmRPointer, (XtPointer) NULL

    },

    {

	XmNinsensitiveStippleBitmap, XmCInsensitiveStippleBitmap,

	XmRNoScalingBitmap,

	sizeof(Pixmap), Offset(screen.insensitive_stipple_bitmap),

	XmRString, XmS50_foreground

    },

#ifdef DEFAULT_GLYPH_PIXMAP

    {

        XmNdefaultGlyphPixmap, XmCDefaultGlyphPixmap,

	/* if you move this one as a real pixmap,

	   change the code in the buttons as well, 

	   move the copyplane into a copyarea */

	XmRBitmap,

	sizeof (Pixmap), Offset(screen.default_glyph_pixmap),

	XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

     },

#endif

};

#undef Offset

/***************************************************************************

 *

 * Class Record

 *

 ***************************************************************************/

/***************************************************************************

 *

 * Class Record

 *

 ***************************************************************************/

static XmBaseClassExtRec baseClassExtRec = {

    NULL,

    NULLQUARK,

    XmBaseClassExtVersion,

    sizeof(XmBaseClassExtRec),

    NULL,				/* InitializePrehook	*/

    NULL,				/* SetValuesPrehook	*/

    NULL,				/* InitializePosthook	*/

    NULL,				/* SetValuesPosthook	*/

    NULL,				/* secondaryObjectClass	*/

    NULL,				/* secondaryCreate	*/

    NULL,          		        /* getSecRes data	*/

    { 0 },     			        /* fastSubclass flags	*/

    NULL,				/* getValuesPrehook	*/

    NULL,				/* getValuesPosthook	*/

    NULL,               /* classPartInitPrehook */

    NULL,               /* classPartInitPosthook*/

    NULL,               /* ext_resources        */

    NULL,               /* compiled_ext_resources*/

    0,                  /* num_ext_resources    */

    FALSE,              /* use_sub_resources    */

    NULL,               /* widgetNavigable      */

    NULL                /* focusChange          */

};

externaldef(xmscreenclassrec)

XmScreenClassRec xmScreenClassRec = {

    {	

	(WidgetClass) &coreClassRec, /* superclass		*/   

	"XmScreen",			/* class_name 		*/   

	sizeof(XmScreenRec), 		/* size 		*/   

	ClassInitialize,		/* Class Initializer 	*/   

	ClassPartInitialize,		/* class_part_init 	*/ 

	FALSE, 				/* Class init'ed ? 	*/   

	Initialize,		        /* initialize         	*/   

	NULL, 				/* initialize_notify    */ 

	NULL,	 			/* realize            	*/   

	NULL,	 			/* actions            	*/   

	0,				/* num_actions        	*/   

	resources,			/* resources          	*/   

	XtNumber(resources),		/* resource_count     	*/   

	NULLQUARK, 			/* xrm_class          	*/   

	FALSE, 				/* compress_motion    	*/   

	FALSE, 				/* compress_exposure  	*/   

	FALSE, 				/* compress_enterleave	*/   

	FALSE, 				/* visible_interest   	*/   

	Destroy,			/* destroy            	*/   

	NULL,		 		/* resize             	*/   

	NULL, 				/* expose             	*/   

	SetValues, 		        /* set_values         	*/   

	NULL, 				/* set_values_hook      */ 

	NULL,			 	/* set_values_almost    */ 

	NULL,				/* get_values_hook      */ 

	NULL, 				/* accept_focus       	*/   

	XtVersion, 			/* intrinsics version 	*/   

	NULL, 				/* callback offsets   	*/   

	NULL,				/* tm_table           	*/   

	NULL, 				/* query_geometry       */ 

	NULL, 				/* screen_accelerator  */ 

	(XtPointer)&baseClassExtRec,	/* extension            */ 

    },	

    {					/* desktop		*/

	NULL,				/* child_class		*/

	InsertChild,		        /* insert_child		*/

	DeleteChild,		        /* delete_child		*/

	NULL,				/* extension		*/

    },

    {	

	NULL,

    },

};

externaldef(xmscreenclass) WidgetClass 

      xmScreenClass = (WidgetClass) (&xmScreenClassRec);

externaldef(xmscreenquark) XrmQuark	_XmInvalidCursorIconQuark = NULLQUARK;

externaldef(xmscreenquark) XrmQuark	_XmValidCursorIconQuark = NULLQUARK;

externaldef(xmscreenquark) XrmQuark	_XmNoneCursorIconQuark = NULLQUARK;

externaldef(xmscreenquark) XrmQuark	_XmDefaultDragIconQuark = NULLQUARK;

externaldef(xmscreenquark) XrmQuark	_XmMoveCursorIconQuark = NULLQUARK;

externaldef(xmscreenquark) XrmQuark	_XmCopyCursorIconQuark = NULLQUARK;

externaldef(xmscreenquark) XrmQuark	_XmLinkCursorIconQuark = NULLQUARK;

static void 

ClassInitialize( void )

{

  baseClassExtRec.record_type = XmQmotif;

  _XmInvalidCursorIconQuark = XrmPermStringToQuark("defaultInvalidCursorIcon");

  _XmValidCursorIconQuark = XrmPermStringToQuark("defaultValidCursorIcon");

  _XmNoneCursorIconQuark = XrmPermStringToQuark("defaultNoneCursorIcon");

  _XmDefaultDragIconQuark = XrmPermStringToQuark("defaultSourceCursorIcon"); 

  _XmMoveCursorIconQuark = XrmPermStringToQuark("defaultMoveCursorIcon"); 

  _XmCopyCursorIconQuark = XrmPermStringToQuark("defaultCopyCursorIcon"); 

  _XmLinkCursorIconQuark = XrmPermStringToQuark("defaultLinkCursorIcon"); 

}    

static void 

ClassPartInitialize( 

	WidgetClass wc )

{

    _XmFastSubclassInit(wc, XmSCREEN_BIT);

}    

/************************************************************************

 *

 *  GetUnitFromFont

 *

 ************************************************************************/

static void 

GetUnitFromFont(

	Display * display,

	XFontStruct * fst,

	int * ph_unit,

	int * pv_unit)

{

    enum { XmAAVERAGE_WIDTH, XmAPIXEL_SIZE, XmARESOLUTION_Y, NUM_ATOMS };

    static char *atom_names[] = { 

      XmIAVERAGE_WIDTH, XmIPIXEL_SIZE, XmIRESOLUTION_Y };

    Atom atoms[XtNumber(atom_names)];

    unsigned long pixel_s, avg_w, point_s, resolution_y;

    unsigned long font_unit_return;

    if (fst) {

      assert(XtNumber(atom_names) == NUM_ATOMS);

      XInternAtoms(display, atom_names, XtNumber(atom_names), TRUE, atoms);

              /* Horizontal units */

      if (ph_unit) {

	  if (atoms[XmAAVERAGE_WIDTH] && 

	      XGetFontProperty(fst, atoms[XmAAVERAGE_WIDTH], &avg_w)) {

	      *ph_unit = (int) ((float) (avg_w / 10) + 0.5) ;

	  } else if (XGetFontProperty (fst, XA_QUAD_WIDTH, &font_unit_return)){

	      *ph_unit = font_unit_return ;

	  } else {

	      *ph_unit = (int) ((fst->min_bounds.width + 

				 fst-> max_bounds.width) / 2.3) + 0.5;

	  }

      }

              /* Vertical units */

      if (pv_unit) {

	  if (XGetFontProperty(fst, atoms[XmAPIXEL_SIZE], &pixel_s)) {

	      *pv_unit = (int) (((float) pixel_s) / 1.8) + 0.5;

	  } else if ((XGetFontProperty(fst, XA_POINT_SIZE, &point_s)) &&

		     (XGetFontProperty(fst, atoms[XmARESOLUTION_Y], 

				       &resolution_y))) {

	      float ps, ry, tmp;

	      ps = point_s;

	      ry = resolution_y;

	      tmp = (ps * ry) / 1400.0;

	      *pv_unit = (int) (tmp + 0.5) ;

	  } else {

	      *pv_unit = (int) ((float) (fst->max_bounds.ascent + 

					 fst->max_bounds.descent) / 2.2) + 0.5;

	  }

      }

    } else {  /* no X fontstruct */

      if (ph_unit) *ph_unit = DEFAULT_QUAD_WIDTH ;

      if (pv_unit) *pv_unit = DEFAULT_QUAD_WIDTH ;

    }

}

/************************************************************************

 *

 *  ScreenInitialize

 *

 ************************************************************************/

/* ARGSUSED */

static void 

Initialize(

        Widget requested_widget,

        Widget new_widget,

        ArgList args,

        Cardinal *num_args )

{

    XmScreen     xmScreen = (XmScreen)new_widget;

    Display      *display = XtDisplay(new_widget);

    xmScreen->screen.screenInfo = NULL;

    XQueryBestCursor(display,

		     RootWindowOfScreen(XtScreen(xmScreen)),

		     1024, 1024,

		     &xmScreen->screen.maxCursorWidth, 

		     &xmScreen->screen.maxCursorHeight);

    xmScreen->screen.nullCursor = None;

    xmScreen->screen.cursorCache = NULL;

    xmScreen->screen.scratchPixmaps = (XtPointer)

      _XmAllocHashTable(20, MatchPixmap, HashPixmap);

    xmScreen->screen.inUsePixmaps = (XtPointer) 

      _XmAllocHashTable(20, NULL, NULL);

    xmScreen->screen.xmStateCursorIcon = NULL;

    xmScreen->screen.xmMoveCursorIcon = NULL;

    xmScreen->screen.xmCopyCursorIcon = NULL;

    xmScreen->screen.xmLinkCursorIcon = NULL;

    xmScreen->screen.xmSourceCursorIcon = NULL;

    xmScreen->screen.mwmPresent = XmIsMotifWMRunning( new_widget) ;

    xmScreen->screen.numReparented = 0;

    xmScreen->desktop.num_children = 0;

    xmScreen->desktop.children = NULL;

    xmScreen->desktop.num_slots = 0;

    if(!XmRepTypeValidValue(XmRID_UNPOST_BEHAVIOR,

                          xmScreen->screen.unpostBehavior,

                          new_widget)) {

      xmScreen->screen.unpostBehavior = XmUNPOST_AND_REPLAY;

    }

    /* font unit stuff, priority to actual unit values, if they haven't

     been set yet, compute from the font, otherwise, stay unchanged */

    if (xmScreen->screen.h_unit == RESOURCE_DEFAULT) 

	GetUnitFromFont(display, xmScreen->screen.font_struct, 

			&xmScreen->screen.h_unit, NULL);

    if (xmScreen->screen.v_unit == RESOURCE_DEFAULT)

	GetUnitFromFont(display, xmScreen->screen.font_struct, 

			NULL, &xmScreen->screen.v_unit);

    xmScreen->screen.screenInfo = (XtPointer) XtNew(XmScreenInfo);

    ((XmScreenInfo *)(xmScreen->screen.screenInfo))->menu_state = 

		(XtPointer)NULL;

    ((XmScreenInfo *)(xmScreen->screen.screenInfo))->destroyCallbackAdded = 

		False;

#ifdef DEFAULT_GLYPH_PIXMAP

    if (xmScreen->screen.default_glyph_pixmap != XmUNSPECIFIED_PIXMAP) {

	(void) XmeGetPixmapData(XtScreen(new_widget),

			 xmScreen->screen.default_glyph_pixmap,

			 NULL, NULL, NULL, NULL, NULL, NULL, 

			 &(xmScreen->screen.default_glyph_pixmap_width), 

			 &(xmScreen->screen.default_glyph_pixmap_height));

    }

#endif

}

/************************************************************************

 *

 *  SetValues

 *

 ************************************************************************/

/* ARGSUSED */

static Boolean

SetValues(

        Widget current,

        Widget requested,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

    XmScreen		newScr = (XmScreen)new_w;

    XmScreen		oldScr = (XmScreen)current;

    Display * display = XtDisplay( new_w);

    if(!XmRepTypeValidValue(XmRID_UNPOST_BEHAVIOR,

                          newScr->screen.unpostBehavior, new_w)) {

      newScr->screen.unpostBehavior = XmUNPOST_AND_REPLAY;

    }

    /*

     *  If we are setting a default cursor icon, verify that

     *  it has the same screen as the new XmScreen.

     */

    /* defaultNoneCursorIcon */

    if (newScr->screen.defaultNoneCursorIcon != 

	    oldScr->screen.defaultNoneCursorIcon &&

	newScr->screen.defaultNoneCursorIcon != NULL &&

	XtScreenOfObject (XtParent (newScr->screen.defaultNoneCursorIcon)) !=

	     XtScreen (newScr)) {

	XmeWarning( (Widget) new_w, MESSAGE1);

	newScr->screen.defaultNoneCursorIcon =

	    oldScr->screen.defaultNoneCursorIcon;

    }

    /* defaultValidCursorIcon */

    if (newScr->screen.defaultValidCursorIcon != 

	    oldScr->screen.defaultValidCursorIcon &&

	newScr->screen.defaultValidCursorIcon != NULL &&

	XtScreenOfObject (XtParent (newScr->screen.defaultValidCursorIcon)) !=

	     XtScreen (newScr)) {

	XmeWarning( (Widget) new_w, MESSAGE1);

	newScr->screen.defaultValidCursorIcon =

	    oldScr->screen.defaultValidCursorIcon;

    }

    /* defaultInvalidCursorIcon */

    if (newScr->screen.defaultInvalidCursorIcon != 

	    oldScr->screen.defaultInvalidCursorIcon &&

	newScr->screen.defaultInvalidCursorIcon != NULL &&

	XtScreenOfObject (XtParent (newScr->screen.defaultInvalidCursorIcon)) !=

	     XtScreen (newScr)) {

	XmeWarning( (Widget) new_w, MESSAGE1);

	newScr->screen.defaultInvalidCursorIcon =

	    oldScr->screen.defaultInvalidCursorIcon;

    }

    /* defaultMoveCursorIcon */

    if (newScr->screen.defaultMoveCursorIcon != 

	    oldScr->screen.defaultMoveCursorIcon &&

	newScr->screen.defaultMoveCursorIcon != NULL &&

	XtScreenOfObject (XtParent (newScr->screen.defaultMoveCursorIcon)) !=

	     XtScreen (newScr)) {

	XmeWarning( (Widget) new_w, MESSAGE1);

	newScr->screen.defaultMoveCursorIcon =

	    oldScr->screen.defaultMoveCursorIcon;

    }

    /* defaultCopyCursorIcon */

    if (newScr->screen.defaultCopyCursorIcon != 

	    oldScr->screen.defaultCopyCursorIcon &&

	newScr->screen.defaultCopyCursorIcon != NULL &&

	XtScreenOfObject (XtParent (newScr->screen.defaultCopyCursorIcon)) !=

	     XtScreen (newScr)) {

	XmeWarning( (Widget) new_w, MESSAGE1);

	newScr->screen.defaultCopyCursorIcon =

	    oldScr->screen.defaultCopyCursorIcon;

    }

    /* defaultLinkCursorIcon */

    if (newScr->screen.defaultLinkCursorIcon != 

	    oldScr->screen.defaultLinkCursorIcon &&

	newScr->screen.defaultLinkCursorIcon != NULL &&

	XtScreenOfObject (XtParent (newScr->screen.defaultLinkCursorIcon)) !=

	     XtScreen (newScr)) {

	XmeWarning( (Widget) new_w, MESSAGE1);

	newScr->screen.defaultLinkCursorIcon =

	    oldScr->screen.defaultLinkCursorIcon;

    }

    /* defaultSourceCursorIcon */

    if (newScr->screen.defaultSourceCursorIcon != 

	    oldScr->screen.defaultSourceCursorIcon &&

	newScr->screen.defaultSourceCursorIcon != NULL &&

	XtScreenOfObject (XtParent (newScr->screen.defaultSourceCursorIcon)) !=

	     XtScreen (newScr)) {

	XmeWarning( (Widget) new_w, MESSAGE1);

	newScr->screen.defaultSourceCursorIcon =

	    oldScr->screen.defaultSourceCursorIcon;

    }

    /* font unit stuff, priority to actual unit values, if the

       font has changed but not the unit values, report the change,

       otherwise, use the unit value - i.e do nothing */

    if (newScr->screen.font_struct->fid != 

	oldScr->screen.font_struct->fid) {

	if (newScr->screen.h_unit == oldScr->screen.h_unit) {

	    GetUnitFromFont(display, newScr->screen.font_struct, 

			    &newScr->screen.h_unit, NULL);

	}

	if (newScr->screen.v_unit == oldScr->screen.v_unit) {

	    GetUnitFromFont(display, newScr->screen.font_struct, 

			    NULL, &newScr->screen.v_unit);

	}

    }    

    return FALSE ;

}

/************************************************************************

 *

 *  Destroy

 *

 ************************************************************************/

/* ARGSUSED */

static void 

Destroy(

        Widget widget )

{

    XmScreen		xmScreen = (XmScreen)widget;

    XmDragCursorCache 	prevCache, cache;

    XmHashTable		tab;

    /* destroy any default icons created by Xm */

    if (xmScreen->screen.xmStateCursorIcon != NULL) {

	_XmDestroyDefaultDragIcon (xmScreen->screen.xmStateCursorIcon);

    }

    if (xmScreen->screen.xmMoveCursorIcon != NULL) {

	_XmDestroyDefaultDragIcon (xmScreen->screen.xmMoveCursorIcon);

    }

    if (xmScreen->screen.xmCopyCursorIcon != NULL) {

	_XmDestroyDefaultDragIcon (xmScreen->screen.xmCopyCursorIcon);

    }

    if (xmScreen->screen.xmLinkCursorIcon != NULL) {

	_XmDestroyDefaultDragIcon (xmScreen->screen.xmLinkCursorIcon);

    }

    if (xmScreen->screen.xmSourceCursorIcon != NULL) {

	_XmDestroyDefaultDragIcon (xmScreen->screen.xmSourceCursorIcon);

    }

    XtFree((char *) xmScreen->desktop.children);

    /* free the cursorCache and the pixmapCache */

    cache = xmScreen->screen.cursorCache;

    while(cache) {

	prevCache = cache;

	if (cache->cursor)

	  XFreeCursor(XtDisplay(xmScreen), cache->cursor);

	cache = cache->next;

	XtFree((char *)prevCache);

    }

    _XmProcessLock();

    tab = (XmHashTable) xmScreen->screen.scratchPixmaps;

    _XmMapHashTable(tab, FreePixmap, xmScreen);

    _XmFreeHashTable(tab);

    _XmFreeHashTable((XmHashTable) xmScreen->screen.inUsePixmaps);

    _XmProcessUnlock();

    XtFree((char *) xmScreen->screen.screenInfo);

    /* need to remove pixmap and GC related to this screen */

    _XmCleanPixmapCache (XtScreen(widget), NULL);

}

static void 

InsertChild(

        Widget wid )

{

    XmDesktopObject w = (XmDesktopObject) wid ;

    register Cardinal	     	position;

    register Cardinal        	i;

    register XmScreen 	cw;

    register WidgetList      	children;

    cw = (XmScreen) w->desktop.parent;

    children = cw->desktop.children;

    position = cw->desktop.num_children;

    if (cw->desktop.num_children == cw->desktop.num_slots) {

	/* Allocate more space */

	cw->desktop.num_slots +=  (cw->desktop.num_slots / 2) + 2;

	cw->desktop.children = children = 

	  (WidgetList) XtRealloc((char *) children,

		(unsigned) (cw->desktop.num_slots) * sizeof(Widget));

    }

    /* Ripple children up one space from "position" */

    for (i = cw->desktop.num_children; i > position; i--) {

	children[i] = children[i-1];

    }

    children[position] = (Widget)w;

    cw->desktop.num_children++;

}

static void 

DeleteChild(

        Widget wid )

{

    XmDesktopObject w = (XmDesktopObject) wid ;

    register Cardinal	     	position;

    register Cardinal	     	i;

    register XmScreen 	cw;

    cw = (XmScreen) w->desktop.parent;

    for (position = 0; position < cw->desktop.num_children; position++) {

        if (cw->desktop.children[position] == (Widget)w) {

	    break;

	}

    }

    if (position == cw->desktop.num_children) return;

    /* Ripple children down one space from "position" */

    cw->desktop.num_children--;

    for (i = position; i < cw->desktop.num_children; i++) {

        cw->desktop.children[i] = cw->desktop.children[i+1];

    }

}

/************************************************************************

 *

 *  _XmScreenRemoveFromCursorCache

 *

 *  Mark any cursor cache reference to the specified icon as deallocated.

 ************************************************************************/

void 

_XmScreenRemoveFromCursorCache(

    XmDragIconObject	icon )

{

    XmScreen	       xmScreen = (XmScreen) XmGetXmScreen(XtScreen(icon));

    XmDragCursorCache  ptr = xmScreen->screen.cursorCache;

    XmDragCursorCache  previous = xmScreen->screen.cursorCache;

    XmDragCursorCache  next;

    while (ptr) {

	next = ptr->next;

	if ((ptr->sourceIcon == icon) ||

	    (ptr->stateIcon == icon) ||

	    (ptr->opIcon == icon))

	  {

	    if (ptr->cursor)

	      XFreeCursor (XtDisplay(icon), ptr->cursor);

	    if ( xmScreen->screen.cursorCache == ptr )

		xmScreen->screen.cursorCache = ptr->next;

	    else

		previous->next = ptr->next;

	    XtFree ((char*)ptr);

	  }

	else

	    previous = ptr;

	ptr = next;

    }

}

static Boolean

FreePixmap(XmHashKey k, XtPointer p, XtPointer client_data) 

{

  XmScreen	xmScreen = (XmScreen) client_data;

  XtFree((char*) k);

  XFreePixmap(XtDisplay(xmScreen), (Pixmap) p);

  return False;

}

/************************************************************************

 *

 *  _XmScreenGetOperationIcon ()

 *

 *  Returns one of the three XmScreen operation cursor types. These aren't

 *  created ahead of time in order to let the client specify its own.

 *  If they haven't by now (a drag is in process) then we create our

 *  own. The name of the OperatonIcon can cause the built-in cursor data

 *  to get loaded in (if not specified in the resource file).

 ************************************************************************/

XmDragIconObject 

_XmScreenGetOperationIcon(

        Widget w,

#if NeedWidePrototypes

        unsigned int operation )

#else

        unsigned char operation )

#endif /* NeedWidePrototypes */

{

    XmScreen		xmScreen = (XmScreen) XmGetXmScreen(XtScreenOfObject(w));

    XrmQuark		nameQuark = NULLQUARK;

    XmDragIconObject	*ptr = NULL;

    XmDragIconObject	*pt2 = NULL;

    switch ((int) operation) {

	case XmDROP_MOVE:

	    ptr = &xmScreen->screen.defaultMoveCursorIcon;

	    pt2 = &xmScreen->screen.xmMoveCursorIcon;

	    nameQuark = _XmMoveCursorIconQuark;

	    break;

	case XmDROP_COPY:

	    ptr = &xmScreen->screen.defaultCopyCursorIcon;

	    pt2 = &xmScreen->screen.xmCopyCursorIcon;

	    nameQuark = _XmCopyCursorIconQuark;

	    break;

	case XmDROP_LINK:

	    ptr = &xmScreen->screen.defaultLinkCursorIcon;

	    pt2 = &xmScreen->screen.xmLinkCursorIcon;

	    nameQuark = _XmLinkCursorIconQuark;

	    break;

	default:

	    return (NULL);

    }

    if (*ptr == NULL) {

	if (*pt2 == NULL) {

	    *pt2 = (XmDragIconObject)

	        XmCreateDragIcon ((Widget) xmScreen,

			          XrmQuarkToString(nameQuark), NULL, 0);

	}

	*ptr = *pt2;

    }

    return *ptr;

}

/************************************************************************

 *

 *  _XmScreenGetStateIcon ()

 *

 *  Returns one of the three XmScreen state cursor types. These aren't

 *  created ahead of time in order to let the client specify its own.

 *  If they haven't by now (a drag is in process) then we create our

 *  own. The name of the StateIcon can cause the built-in cursor data

 *  to get loaded in (if not specified in the resource file).

 *  The default state cursors are the same XmDragIcon object.

 ************************************************************************/

XmDragIconObject 

_XmScreenGetStateIcon(

        Widget w,

#if NeedWidePrototypes

        unsigned int state )

#else

        unsigned char state )

#endif /* NeedWidePrototypes */

{

    XmScreen		xmScreen = (XmScreen) XmGetXmScreen(XtScreenOfObject(w));

    XrmQuark		nameQuark = NULLQUARK;

    XmDragIconObject	icon = NULL;

    switch(state) {

	default:

	case XmNO_DROP_SITE:

	    icon = xmScreen->screen.defaultNoneCursorIcon;

	    nameQuark = _XmNoneCursorIconQuark;

	    break;