/* $TOG: SpinB.c /main/27 1999/04/16 08:48:58 mgreess $ */

/*

 * 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

 */

/*

 * (c) Copyright 1995 Digital Equipment Corporation.

 * (c) Copyright 1995 Hewlett-Packard Company.

 * (c) Copyright 1995 International Business Machines Corp.

 * (c) Copyright 1995 Sun Microsystems, Inc.

 * (c) Copyright 1995 Novell, Inc. 

 * (c) Copyright 1995 FUJITSU LIMITED.

 * (c) Copyright 1995 Hitachi.

 */

/*

 * HISTORY

 */

/*

 * (c) Copyright 1989, 1990, 1991, 1992, 1993 OPEN SOFTWARE FOUNDATION, INC. 

 * ALL RIGHTS RESERVED 

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <X11/StringDefs.h>

#include <X11/Intrinsic.h>

#include <X11/IntrinsicP.h>

#include <X11/cursorfont.h>

#include <X11/Shell.h>

#include <X11/Xutil.h>

#include <X11/keysym.h>

#include <Xm/AccTextT.h>

#include <Xm/DrawP.h>

#include <Xm/NavigatorT.h>

#include <Xm/PrimitiveP.h>

#include <Xm/Text.h>

#include <Xm/TextF.h>

#include <Xm/TraitP.h>

#include <Xm/TransltnsP.h>

#include <Xm/VaSimpleP.h>

#include "GeoUtilsI.h"

#include "GMUtilsI.h"

#include "MessagesI.h"

#include "RepTypeI.h"

#include "ScreenI.h"

#include "TravActI.h"

#include "TraversalI.h"

#include "XmI.h"

#include <Xm/SpinBP.h>

#define FIX_1519

static void ClassInitialize(void);

static void ClassPartInitialize(WidgetClass classPart);

static void Initialize(Widget req, Widget w,

		       ArgList args, Cardinal *num_args);

static void Destroy(Widget w);

static void Resize(Widget w);

static void Redisplay(Widget w, XEvent *event, Region region);

static Boolean SetValues(Widget old, Widget req, Widget new_w,

			 ArgList args, Cardinal *num_args);

static XtGeometryResult QueryGeometry(Widget w,

				      XtWidgetGeometry*req,

				      XtWidgetGeometry*rep );

static XtGeometryResult GeometryManager(Widget w,

					XtWidgetGeometry *req,

					XtWidgetGeometry *rep);

static void ChangeManaged(Widget w);

static void InsertChild(Widget newChild);

static void ConstraintInitialize(Widget req, Widget new_w,

				 ArgList args, Cardinal *num_args);

static void ConstraintDestroy(Widget w);

static Boolean ConstraintSetValues(Widget old, Widget req, Widget new_w,

				   ArgList args, Cardinal *num_args);

static void SpinChildFocusChange(Widget    focusWidget, XtPointer focusClient,

				 XEvent    *focusEvent,

				 Boolean   *focusContinue);

static void SpinBArm(Widget   armWidget, XEvent   *armEvent,

		     String   *armParams, Cardinal *armCount );

static void SpinBDisarm(Widget   disarmWidget, XEvent   *disarmEvent,

			String   *disarmParams, Cardinal *disarmCount);

static void SpinBFirst(Widget   firstWidget, XEvent   *firstEvent,

		       String   *firstParams, Cardinal *firstCount );

static void SpinBLast(Widget   lastWidget, XEvent   *lastEvent,

		      String   *lastParams, Cardinal *lastCount );

static void SpinBLeft(Widget   leftWidget, XEvent   *leftEvent,

		      String   *leftParams, Cardinal *leftCount );

static void SpinBNext(Widget   nextWidget, XEvent   *nextEvent,

		      String   *nextParams, Cardinal *nextCount );

static void SpinBPrior(Widget   priorWidget, XEvent   *priorEvent,

		       String   *priorParams, Cardinal *priorCount );

static void SpinBRight(Widget   rightWidget, XEvent   *rightEvent, 

		       String   *rightParams, Cardinal *rightCount );

static void SpinBEnter(Widget, XEvent*, String*, Cardinal*);

static void SpinBLeave(Widget, XEvent*, String*, Cardinal*);

static void ClearArrows(Widget clearW);

static Boolean UpArrowSensitive(XmSpinBoxWidget spinW);

static Boolean DownArrowSensitive(XmSpinBoxWidget spinW);

static int NumericChildCount(XmSpinBoxWidget spinW);

static Boolean WidgetIsChild(XmSpinBoxWidget spinW, Widget child);

static Boolean ChildIsTraversable(Widget w);

static int GetArrowDirection(Widget w, int spinDir);

static void LayoutSpinBox(Widget w, XtWidgetGeometry *spinG, Widget child);

static void NumToString(char **buffer, int min, int max,

			int decimal, int value );

static void DrawSpinArrow(Widget arrowWidget, int arrowFlag);

static void SpinTimeOut(Widget w, int spinDelay);

static void UpdateChildText(Widget textW);

static Boolean ArrowWasHit(Widget arrowW, int arrowType, XEvent *arrowEvent);

static void SpinBArrow(XtPointer spinData, XtIntervalId *spinInterval);

static void SpinBAction(Widget   actionWidget, short    arrowHit );

static void FireCallbacks(XmSpinBoxCallbackStruct   *spinBoxCallData,

			  XtCallbackList callbackList,

			  Widget arrowWidget,

			  XEvent *arrowEvent,

			  int    arrowReason);

static void ArrowCallback(Widget arrowWidget,

			  XEvent *arrowEvent,

			  int    arrowReason);

static Boolean ArrowVerify(Widget arrowWidget,

			   XEvent *arrowEvent,

			   int    arrowReason );

static void ArrowSpinUp(Widget w, XEvent *callEvent);

static void ArrowSpinDown(Widget w, XEvent *callEvent);

static void GetSpinSize(Widget w, Dimension *wide, Dimension *high);

static void SpinNChangeMoveCB(Widget nav, XtCallbackProc moveCB,

			      XtPointer closure, Boolean setunset );

static void SpinNSetValue(Widget nav, XmNavigatorData nav_data, 

			  Boolean notify );

static void SpinNGetValue(Widget nav, XmNavigatorData nav_data );

static void GetPositionValue(Widget w, int offset, XtArgVal *value);

static XmImportOperator SetPositionValue(Widget w, int offset, XtArgVal *value);

static int GetMaximumPositionValue(XmSpinBoxConstraint sc);

static int GetMinimumPositionValue(XmSpinBoxConstraint sc);

static char * ValidatePositionValue(XmSpinBoxConstraint sc, int *position);

static Boolean CvtStringToPositionValue(Display *dpy,

                                        XrmValue *args,

                                        Cardinal *num_args,

                                        XrmValue *from,

                                        XrmValue *to,

                                        XtPointer *converter_data);

/* Macros */

#define SB_ArrowLayout(w)	(((XmSpinBoxWidget) (w))->spinBox.arrow_layout)

#define SB_ArrowsAreStacked(w) \

	((SB_ArrowLayout(w) == XmARROWS_END) || \

	 (SB_ArrowLayout(w) == XmARROWS_BEGINNING))

#define SB_NumArrowsWide(w)	((SB_ArrowsAreStacked(w)) ? 1 : 2)

#define SB_NumArrowsHigh(w)	((SB_ArrowsAreStacked(w)) ? 2 : 1)

#define SB_ShadowMargin		2

#define SB_ShadowPixels(w) \

    ( (((XmSpinBoxWidget) (w))->manager.shadow_thickness) ? \

       (((XmSpinBoxWidget) (w))->manager.shadow_thickness + SB_ShadowMargin) : \

       0 )

/* Actions table */

static XtActionsRec actionsTable [] =

{

  {"SpinBArm",	           SpinBArm },

  {"SpinBDisarm",	   SpinBDisarm },

  {"SpinBPrior",	   SpinBPrior },

  {"SpinBNext",		   SpinBNext },

  {"SpinBLeft",		   SpinBLeft },

  {"SpinBRight",	   SpinBRight },

  {"SpinBFirst",	   SpinBFirst },

  {"SpinBLast",		   SpinBLast },

  {"SpinBEnter",	   SpinBEnter },

  {"SpinBLeave",	   SpinBLeave },

};

#define BAD_SPIN_VALUES			_XmMMsgSpinB_0003

#define BAD_SPIN_INCREMENT		_XmMMsgSpinB_0004

#define BAD_SPIN_DIRECTION		_XmMMsgSpinB_0005

#define BAD_SPIN_POSITION_MIN		_XmMMsgSpinB_0006

#define BAD_SPIN_POSITION_MAX		_XmMMsgSpinB_0007

#define BAD_SPIN_POSITION_TYPE		_XmMMsgSpinB_0008

#define DEFAULT_ARROW_SIZE 16

#define defaultTranslations _XmSpinB_defaultTranslations

static XtAccelerators    spinAccel;

/* Resources */

#define Offset(field) XtOffsetOf(XmSpinBoxRec,spinBox.field)

static XtResource resources[] = {

  { XmNarrowLayout, XmCArrowLayout, XmRArrowLayout,

    sizeof(unsigned char), Offset(arrow_layout),

    XmRImmediate, (XtPointer) XmARROWS_END

  },

  { XmNarrowOrientation, XmCArrowOrientation, XmRArrowOrientation,

    sizeof(unsigned char), Offset(arrow_orientation),

    XmRImmediate, (XtPointer) XmARROWS_VERTICAL

  },

  { XmNarrowSize, XmCArrowSize, XmRHorizontalDimension,

    sizeof(Dimension), Offset(arrow_size),

    XmRImmediate, (XtPointer) DEFAULT_ARROW_SIZE

  },

  { XmNmarginWidth, XmCMarginWidth, XmRHorizontalDimension,

    sizeof(Dimension), Offset(margin_width),

    XmRImmediate, (XtPointer) 2

  },

  { XmNmarginHeight, XmCMarginHeight, XmRVerticalDimension,

    sizeof(Dimension), Offset(margin_height),

    XmRImmediate, (XtPointer) 2

  },

  { XmNspacing, XmCSpacing, XmRHorizontalDimension,

    sizeof(Dimension), Offset(spacing),

    XmRImmediate, (XtPointer) 0

  },

  { XmNinitialDelay, XmCInitialDelay, XmRInt,

    sizeof(unsigned int), Offset(initial_delay),

    XmRImmediate, (XtPointer) 250

  },

  { XmNrepeatDelay, XmCRepeatDelay, XmRInt,

    sizeof(unsigned int), Offset(repeat_delay),

    XmRImmediate, (XtPointer) 200

  },

  { XmNdefaultArrowSensitivity, XmCDefaultArrowSensitivity, 

    XmRArrowSensitivity,

    sizeof(unsigned char), Offset(default_arrow_sensitivity),

    XmRImmediate, (XtPointer) XmARROWS_SENSITIVE

  },

  { XmNmodifyVerifyCallback, XmCCallback, XmRCallback,

    sizeof(XtCallbackList), Offset(modify_verify_cb),

    XmRPointer, NULL

  },

  { XmNvalueChangedCallback, XmCCallback, XmRCallback, 

    sizeof(XtCallbackList), Offset(value_changed_cb), 

    XmRPointer, NULL, 

  },

  { XmNdetailShadowThickness, XmCShadowThickness, XmRHorizontalDimension,

    sizeof(Dimension), Offset(detail_shadow_thickness),

    XmRCallProc, (XtPointer) _XmSetThickness

  }

};

/* Resources */

#define ConstraintOffset(field)\

  XtOffsetOf(XmSpinBoxConstraintRec,spinBox.field)

static XtResource constraints[] = {

  { XmNspinBoxChildType, XmCSpinBoxChildType, XmRSpinBoxChildType,

    sizeof(unsigned char), ConstraintOffset(sb_child_type),

    XmRImmediate, (XtPointer) XmSTRING

  },

  { XmNpositionType, XmCPositionType, XmRPositionType,

    sizeof(unsigned char), ConstraintOffset(position_type),

    XmRImmediate, (XtPointer) XmPOSITION_VALUE

  },

  { XmNnumValues, XmCNumValues, XmRInt,

    sizeof(int), ConstraintOffset(num_values),

    XmRImmediate, (XtPointer) 0

  },

  { XmNvalues, XmCValues, XmRXmStringTable, 

    sizeof(XmStringTable), ConstraintOffset(values), 

    XmRStringTable, NULL

  },

  { XmNminimumValue, XmCMinimumValue, XmRInt, 

    sizeof(int), ConstraintOffset(minimum_value), 

    XmRImmediate, (XtPointer) 0

  },

  { XmNmaximumValue, XmCMaximumValue, XmRInt, 

    sizeof(int), ConstraintOffset(maximum_value), 

    XmRImmediate, (XtPointer) 10

  },

  { XmNincrementValue, XmCIncrementValue, XmRInt, 

    sizeof(int), ConstraintOffset(increment_value), 

    XmRImmediate, (XtPointer) 1

  },

  { XmNdecimalPoints, XmCDecimalPoints, XmRShort,

    sizeof(short), ConstraintOffset(decimal_points), 

    XmRImmediate, (XtPointer) 0

  },

  { XmNarrowSensitivity, XmCArrowSensitivity, XmRArrowSensitivity,

    sizeof(unsigned char), ConstraintOffset(arrow_sensitivity), 

    XmRImmediate, (XtPointer) XmARROWS_DEFAULT_SENSITIVITY

  },

  { XmNwrap, XmCWrap, XmRBoolean,

    sizeof(Boolean), ConstraintOffset(wrap), 

    XmRImmediate, (XtPointer) True

  },

  { XmNposition, XmCPosition, XmRPositionValue,

    sizeof(int), ConstraintOffset(position),

    XmRImmediate, (XtPointer) 0

  }

};

static XmSyntheticResource syn_resources[] = 

{

  { XmNspacing, sizeof(Dimension),

    Offset(spacing),

    XmeFromHorizontalPixels,

    XmeToHorizontalPixels

  },

  { XmNmarginHeight, sizeof(Dimension),

    Offset(margin_height),

    XmeFromVerticalPixels,

    XmeToVerticalPixels

  },

  { XmNmarginWidth, sizeof(Dimension),

    Offset(margin_width), 

    XmeFromHorizontalPixels,

    XmeToHorizontalPixels

  },

  { XmNdetailShadowThickness, sizeof(Dimension), 

    Offset(detail_shadow_thickness),

    XmeFromHorizontalPixels,

    XmeToHorizontalPixels

  }

};

static XmSyntheticResource syn_constraints[] = 

{

  { XmNposition, sizeof(int), 

    ConstraintOffset(position),

    GetPositionValue,

    SetPositionValue

  }

};

static XmBaseClassExtRec spinBoxBaseClassExtRec = {

  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    */

  XmInheritWidgetNavigable,     /* widgetNavigable      */

  NULL                          /* focusChange          */

  };

/*  The Spin class record definition  */

externaldef (xmspinboxclassrec) XmSpinBoxClassRec xmSpinBoxClassRec= {

  {

    (WidgetClass)&xmManagerClassRec,    /* superclass */   

    "XmSpinBox",                        /* class_name */	

    sizeof(XmSpinBoxRec),               /* widget_size */	

    ClassInitialize,    		/* class_initialize */    

    ClassPartInitialize,                /* class_part_initialize */

    FALSE,    		                /* class_inited */	

    Initialize,    	                /* initialize */	

    NULL,    		                /* initialize_hook */

    XtInheritRealize,		        /* realize */	

    actionsTable,      	                /* actions */

    XtNumber(actionsTable),             /* num_actions */	

    resources,    	                /* resources */

    XtNumber(resources),                /* num_resources */

    NULLQUARK,    	                /* xrm_class */	

    TRUE,    		                /* compress_motion */	

    XtExposeCompressMaximal |          	/* compress_exposure */	

	XtExposeNoRegion,

    TRUE,    		              	/* compress_enterleave */

    FALSE,    		              	/* visible_interest */	

    Destroy,    		      	/* destroy */	

    Resize,			      	/* resize */

    Redisplay,    	              	/* expose */	

    SetValues,    	              	/* set_values */	

    NULL,    		              	/* set_values_hook */

    XtInheritSetValuesAlmost,          	/* set_values_almost */

    NULL,    		              	/* get_values_hook */

    XtInheritAcceptFocus,	      	/* accept_focus */	

    XtVersion,    	              	/* version */

    NULL,    		              	/* callback private */

    defaultTranslations,	        /* tm_table */

    QueryGeometry,    		      	/* query_geometry */

    NULL,    		              	/* display_accelerator */

    (XtPointer)&spinBoxBaseClassExtRec,	/* extension */

  },

  {    /* composite_class fields */

    GeometryManager,                	/* geometry_manager */

    ChangeManaged,    	              	/* change_managed */

    InsertChild,		        /* insert_child */

    XtInheritDeleteChild,	        /* delete_child */

    NULL,    		                /* extension */

  },

  {    /* constraint_class fields */

    constraints,    		      	/* resource list */

    XtNumber(constraints),	      	/* num resources */

    sizeof(XmSpinBoxConstraintRec),    	/* constraint size */

    ConstraintInitialize,              	/* init proc */

    ConstraintDestroy,			/* destroy proc */

    ConstraintSetValues,		/* set values proc */

    NULL,    		             	/* extension */

  },

      /* manager_class fields */

  {

    NULL,    		              	/* translations */

    syn_resources,              	/* syn_resources */

    XtNumber(syn_resources),           	/* num_syn_resources */

    syn_constraints,	              	/* syn_cont_resources */

    XtNumber(syn_constraints),         	/* num_syn_cont_resources */

    NULL,    		              	/* parent_process */

    NULL,    		              	/* extension */

  },

      /* spinbox_class fields */

  {

    NULL,    		              	/* get_callback_widget */

    NULL    		              	/* extension */

  }

};

externaldef(xmspinboxwidgetclass) WidgetClass xmSpinBoxWidgetClass =

       (WidgetClass)&xmSpinBoxClassRec;

static XmConst XmNavigatorTraitRec spinBoxNT =

{

  0,

  SpinNChangeMoveCB,

  SpinNSetValue,

  SpinNGetValue,

};

static XtConvertArgRec selfConvertArgs[] = {

    { XtBaseOffset, (XtPointer) 0, sizeof(int) }

};

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

 **

 ***			METHODS

 **

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

static void 

ClassInitialize(void)

{

  spinAccel = XtParseAcceleratorTable(_XmSpinB_defaultAccelerators);

  /* set up base class extension quark */

  spinBoxBaseClassExtRec.record_type = XmQmotif;

}

static void

ClassPartInitialize(WidgetClass classPart)

{

  XmSpinBoxWidgetClass spinC;

  spinC = (XmSpinBoxWidgetClass) classPart;

  _XmFastSubclassInit(classPart, XmSPINBOX_BIT);

  /* Install the navigator trait for all subclasses */

  XmeTraitSet((XtPointer)spinC, XmQTnavigator, (XtPointer) &spinBoxNT);

  XtSetTypeConverter( XmRString, XmRPositionValue, CvtStringToPositionValue,

                      selfConvertArgs, XtNumber(selfConvertArgs),

                      XtCacheNone, (XtDestructor) NULL) ;

}

/*ARGSUSED*/

static void

Initialize(Widget req,		/* unused */

	   Widget new_w, 

	   ArgList args,	/* unused */

	   Cardinal *num_args)	/* unused */

{

  XmSpinBoxWidget spinW = (XmSpinBoxWidget)new_w;

  XGCValues	  GCvalues;

  XtGCMask	  GCmask, unusedMask;

  spinW->spinBox.textw = 0;

  spinW->spinBox.dim_mask = 0;

  spinW->spinBox.last_hit = 0;

  spinW->spinBox.spin_timer = 0;

  spinW->spinBox.make_change = 0;

  spinW->spinBox.boundary = 0;

  spinW->spinBox.ideal_height = 0;

  spinW->spinBox.ideal_width = 0;

  spinW->spinBox.up_arrow_pressed = False;

  spinW->spinBox.down_arrow_pressed = False;

  spinW->spinBox.up_arrow_rect.x = 0;

  spinW->spinBox.up_arrow_rect.y = 0;

  spinW->spinBox.up_arrow_rect.width = 0;

  spinW->spinBox.up_arrow_rect.height = 0;

  spinW->spinBox.down_arrow_rect.x = 0;

  spinW->spinBox.down_arrow_rect.y = 0;

  spinW->spinBox.down_arrow_rect.width = 0;

  spinW->spinBox.down_arrow_rect.height = 0;

  if (!spinW->core.accelerators)

    spinW->core.accelerators = spinAccel;

  if (spinW->spinBox.initial_delay < 1)

    spinW->spinBox.initial_delay = spinW->spinBox.repeat_delay;

  /* Get arrow GC */

  GCmask = GCForeground | GCBackground | GCGraphicsExposures;

  GCvalues.foreground = spinW->core.background_pixel;

  GCvalues.background = spinW->manager.foreground;

  GCvalues.graphics_exposures = False;

  /* Share gc with scrollbar */

  spinW->spinBox.arrow_gc = XtAllocateGC(new_w, 0, GCmask, &GCvalues, 

					 0, GCFont);

  GCmask |= GCFillStyle | GCStipple;

  unusedMask = GCClipXOrigin | GCClipYOrigin | GCFont;

  GCvalues.background = spinW->core.background_pixel;

  GCvalues.foreground = spinW->manager.foreground;

  GCvalues.fill_style = FillOpaqueStippled;

  GCvalues.stipple = _XmGetInsensitiveStippleBitmap(new_w);

  /* share GC with ArrowButton */

  spinW->spinBox.insensitive_gc = XtAllocateGC(new_w, 0, GCmask, &GCvalues, 

					       GCClipMask, unusedMask);

}

static void

Destroy(Widget w)

{

  XmSpinBoxWidget spinW = (XmSpinBoxWidget)w;

  if (spinW->spinBox.arrow_gc != NULL)

    {

      XtReleaseGC(w, spinW->spinBox.arrow_gc);

      spinW->spinBox.arrow_gc = NULL;

    }

  if (spinW->spinBox.insensitive_gc != NULL)

    {

      XtReleaseGC(w, spinW->spinBox.insensitive_gc);

      spinW->spinBox.insensitive_gc = NULL;

    }

}

static void

Resize(Widget w)

{

  XtWidgetGeometry spinG;

  spinG.width = XtWidth(w);

  spinG.height = XtHeight(w);

  LayoutSpinBox(w, &spinG, NULL);

  if (XtIsRealized(w))

     XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, True);			/*  Force Redisplay */

}

/*ARGSUSED*/

static void

Redisplay(Widget w, 

	  XEvent *event,	/* unused */

	  Region region)	/* unused */

{

  XmSpinBoxWidget	spinW = (XmSpinBoxWidget) w;

  if (XtIsRealized(w))

    {

      ClearArrows(w);

      if (spinW->manager.shadow_thickness > 0)

	{

	  int	width, height;

	  width = (spinW->spinBox.ideal_width < XtWidth(spinW)) ? 

		  spinW->spinBox.ideal_width :

		  XtWidth(spinW);

	  height = (spinW->spinBox.ideal_height < XtHeight(spinW)) ? 

		  spinW->spinBox.ideal_height :

		  XtHeight(spinW);

	  XmeDrawShadows(

			 XtDisplay(w), XtWindow(w),

		         spinW->manager.top_shadow_GC,

		         spinW->manager.bottom_shadow_GC,

		         0, 0, width, height,

		         spinW->manager.shadow_thickness,

			 XmSHADOW_OUT

		        );

	}

      _XmSetFocusFlag(w,XmFOCUS_IGNORE, False);

      DrawSpinArrow(w, XmARROW_UP);

      DrawSpinArrow(w, XmARROW_DOWN);

    }

}

/*ARGSUSED*/

static Boolean

SetValues(Widget old, 

	  Widget req, 

	  Widget new_w, 

	  ArgList args,		/* unused */

	  Cardinal *num_args )	/* unused */

{

  XtWidgetGeometry spinG;

  XmSpinBoxWidget	 oldW = (XmSpinBoxWidget)old;

  XmSpinBoxWidget	 reqW = (XmSpinBoxWidget)req;

  XmSpinBoxWidget	 newW = (XmSpinBoxWidget)new_w;

  Boolean		 displayFlag;

  displayFlag = False;

  /*  Initial delay must be positive	*/

  if (newW->spinBox.initial_delay < 1)

    newW->spinBox.initial_delay = newW->spinBox.repeat_delay;

  if ((newW->core.sensitive != oldW->core.sensitive) ||

      (newW->core.ancestor_sensitive != oldW->core.ancestor_sensitive))

    displayFlag = True;				

  /*  Check for geo changes, if realized	*/

  if (XtIsRealized(new_w) &&

      (reqW->spinBox.arrow_layout  != oldW->spinBox.arrow_layout ||

      reqW->spinBox.margin_width  != oldW->spinBox.margin_width ||

      reqW->spinBox.margin_height != oldW->spinBox.margin_height ||

      reqW->spinBox.spacing       != oldW->spinBox.spacing ||

      reqW->spinBox.arrow_size    != oldW->spinBox.arrow_size))

    {

      spinG.width = 0;

      spinG.height = 0;

      GetSpinSize(new_w, &spinG.width, &spinG.height);

      XtWidth(new_w) = spinG.width;

      XtHeight(new_w) = spinG.height;

      if (XtIsRealized(old))

        ClearArrows(old);

      LayoutSpinBox(new_w, &spinG, NULL);

      displayFlag = True;

    }

  if (reqW->spinBox.default_arrow_sensitivity

      !=  oldW->spinBox.default_arrow_sensitivity ||

      reqW->spinBox.detail_shadow_thickness

      != oldW->spinBox.detail_shadow_thickness)

    displayFlag = True;

  return(displayFlag);

}

static XtGeometryResult

QueryGeometry(Widget w, XtWidgetGeometry *req, XtWidgetGeometry *rep)

{

  XmSpinBoxWidget	 spinW = (XmSpinBoxWidget)w;

  if (!XtIsRealized((Widget)spinW))

    {

      rep->width = XtWidth(w);

      rep->height = XtHeight(w);

    }

  else

    {

      rep->width = 0;

      rep->height = 0;

    }

  GetSpinSize(w, &rep->width, &rep->height);

  return(XmeReplyToQueryGeometry(w, req, rep));

}

/*ARGSUSED*/

static XtGeometryResult

GeometryManager(Widget w, 

		XtWidgetGeometry *req, 

		XtWidgetGeometry *rep) /* unused */

{

  XtGeometryResult spinResult;

  XtWidgetGeometry spinG;

  XtWidgetGeometry origG;

  if (IsX(req))

    if (w->core.x != req->x)

      return(XtGeometryNo);

  if (IsY(req))

    if (w->core.y != req->y)

      return(XtGeometryNo);

  origG.width = w->core.width;

  origG.height = w->core.height;

  if (IsWidth(req))

    w->core.width = req->width;

  if (IsHeight(req))

    w->core.height = req->height;

  spinG.width = 0;

  spinG.height = 0;

  GetSpinSize(XtParent(w), &spinG.width, &spinG.height);

  spinG.request_mode = (CWWidth | CWHeight);

  spinResult = _XmMakeGeometryRequest(XtParent(w), &spinG);

  if (spinResult == XtGeometryYes)

   {

     LayoutSpinBox(XtParent(w), &spinG, w);

     /*  Force Redisplay */

     if (XtIsRealized(w))

       XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, True);

   }

  else

    {

      w->core.width = origG.width;

      w->core.height = origG.height;

      spinResult = XtGeometryNo;

    }

  return(spinResult);

}

static void

ChangeManaged(Widget w)

{

  XtWidgetGeometry spinG;

  XmSpinBoxWidget	 spinW = (XmSpinBoxWidget) w;

  int		 i;

  if (XtIsRealized(w))

    {

      spinG.width = 0; 

      spinG.height =  0;

    }

  else

    {

      spinG.width = XtWidth(w);

      spinG.height = XtHeight(w);

    }

  GetSpinSize(w, &spinG.width, &spinG.height);

  spinG.request_mode = CWWidth | CWHeight;

  _XmMakeGeometryRequest(w, &spinG);

  LayoutSpinBox(w, &spinG, NULL);

  /* Update managed children */

  /* Also make sure that focus is on the last created and managed

   * text/text_field child. If the last text/text_field child is not managed, 

   * focus should be on the one previous to that. XmQTaccessTextual trait can 

   * not be used to confirm the child to be text or text_field as this trait 

   * is held by other widgets such as label as well.

   */

  for (i = 0; i < SB_ChildCount(spinW); i++) {

    if (XtIsManaged(spinW->composite.children[i])) {

      if (XmIsTextField(spinW->composite.children[i]) ||

	  XmIsText(spinW->composite.children[i])) {

	 spinW->spinBox.textw  = spinW->composite.children[i];

     }

      UpdateChildText(spinW->composite.children[i]);

    }

  }

}

static void

InsertChild(Widget newChild)

{

  XmSpinBoxWidget      spinW = (XmSpinBoxWidget)XtParent(newChild);

  XtWidgetProc insert_child;

  /* call manager's InsertChild method */

  _XmProcessLock();

  insert_child = ((XmManagerWidgetClass)xmManagerWidgetClass)

     			->composite_class.insert_child;

  _XmProcessUnlock();

  (*insert_child)(newChild);

  if (XmeTraitGet((XtPointer)XtClass(newChild), XmQTaccessTextual) != NULL)

    {

      spinW->spinBox.textw  = newChild;

      XtInsertEventHandler(

			   newChild,

			   FocusChangeMask,

			   False,

			   SpinChildFocusChange,

			   (XtPointer) spinW,

			   XtListHead

			   );

      /* To handle implicit mode,  we also call the focus change

	 if a button is clicked.  The work is finished in the event

	 handler */

      XtInsertEventHandler(

			   newChild,

			   ButtonPressMask,

			   False,

			   SpinChildFocusChange,

			   (XtPointer) spinW,

			   XtListHead

			   );

    }

  XtInstallAccelerators(newChild, (Widget)spinW);

}

/*ARGSUSED*/

static void

ConstraintInitialize(Widget req, 

		     Widget new_w, 

		     ArgList args, /* unused */

		     Cardinal *num_args) /* unused */

{

  XmSpinBoxConstraint	newC = SB_GetConstraintRec(new_w);

  XmSpinBoxConstraint	reqC = SB_GetConstraintRec(req);

  XmSpinBoxWidget	spinW;

  int			valLoop;

  char			*error = (char *) NULL;

  spinW = (XmSpinBoxWidget)XtParent(new_w);

  /* Numeric Child*/

  if (SB_ChildIsNumeric(newC))

    {

      /* enforce reasonable parameters */

      if (newC->increment_value == 0)

	{