/* $TOG: SSpinB.c /main/14 1999/04/15 10:29:50 mgreess $ */

/*

 * (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.

 */

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

 *

 *	File:	SSpinB.c

 *	Date:	June 1, 1995

 *	Author:	Mitchell Greess

 *

 *	Contents:

 *		Implements the XmSimpleSpinBox widget.

 *

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

#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/TextF.h>

#include <Xm/VaSimpleP.h>

#include "MessagesI.h"

#include "XmI.h"

#include <Xm/SSpinBP.h>

#define FIX_1530

static void	Initialize(

			Widget		req,

			Widget		w,

			ArgList		args,

			Cardinal	*num_args);

static Boolean	SetValues(

			Widget		old,

			Widget		req,

			Widget		new_w,

			ArgList		args,

			Cardinal	*num_args);

static void	InsertChild(

			Widget		newChild);

static Widget	GetCallbackWidget(

			Widget		widget);

static void	SyntheticGetValue(

			Widget widget,

			int offset,

			XtArgVal *value);

/* Resources */

#define Offset(field) XtOffsetOf(XmSimpleSpinBoxRec,simpleSpinBox.field)

#define ManagerOffset(field) XtOffsetOf(XmSimpleSpinBoxRec,manager.field)

static XtResource resources[] = {

  /*

   * Inherited resources.

   */

  {

    XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension,

    sizeof(Dimension), ManagerOffset(shadow_thickness),

    XmRImmediate, (XtPointer) 1

  },

  /*

   * SimpleSpinBox resources.

   */

  {

    XmNarrowSensitivity, XmCArrowSensitivity, XmRArrowSensitivity,

    sizeof(unsigned char), Offset(arrow_sensitivity),

    XmRImmediate, (XtPointer) XmARROWS_DEFAULT_SENSITIVITY

  },

  {

    XmNcolumns, XmCColumns, XmRShort,

    sizeof(short), Offset(columns), 

    XmRImmediate, (XtPointer) 20

  },

  {

    XmNdecimalPoints, XmCDecimalPoints, XmRShort,

    sizeof(short), Offset(decimal_points), 

    XmRImmediate, (XtPointer) 0

  },

  {

    XmNeditable, XmCEditable, XmRBoolean,

    sizeof(Boolean), Offset(editable), 

    XmRImmediate, (XtPointer) True

  },

  {

    XmNincrementValue, XmCIncrementValue, XmRInt, 

    sizeof(int), Offset(increment_value), 

    XmRImmediate, (XtPointer) 1

  },

  {

    XmNmaximumValue, XmCMaximumValue, XmRInt, 

    sizeof(int), Offset(maximum_value), 

    XmRImmediate, (XtPointer) 10

  },

  {

    XmNminimumValue, XmCMinimumValue, XmRInt, 

    sizeof(int), Offset(minimum_value), 

    XmRImmediate, (XtPointer) 0

  },

  {

    XmNnumValues, XmCNumValues, XmRInt,

    sizeof(int), Offset(num_values),

    XmRImmediate, (XtPointer) 0

  },

  {

    XmNposition, XmCPosition, XmRInt,

    sizeof(int), Offset(position),

    XmRImmediate, (XtPointer) 0

  },

  {

    XmNpositionType, XmCPositionType, XmRPositionType,

    sizeof(unsigned char), Offset(position_type),

    XmRImmediate, (XtPointer) XmPOSITION_VALUE

  },

  {

    XmNspinBoxChildType, XmCSpinBoxChildType, XmRSpinBoxChildType,

    sizeof(unsigned char), Offset(sb_child_type),

    XmRImmediate, (XtPointer) XmSTRING

  },

  {

    XmNtextField, XmCTextField, XmRWidget,

    sizeof(Widget), Offset(text_field),

    XmRImmediate, (XtPointer) NULL

  },

  {

    XmNvalues, XmCValues, XmRXmStringTable, 

    sizeof(XmStringTable), Offset(values), 

    XmRStringTable, NULL

  },

  {

    XmNwrap, XmCWrap, XmRBoolean,

    sizeof(Boolean), Offset(wrap),

    XmRImmediate, (XtPointer) True

  }

};

static XmSyntheticResource syn_resources[] = 

{

  {

    XmNarrowSensitivity, sizeof(unsigned char), Offset(arrow_sensitivity),

    SyntheticGetValue, NULL

  },

  {

    XmNcolumns, sizeof(short), Offset(columns), 

    SyntheticGetValue, NULL

  },

  {

    XmNdecimalPoints, sizeof(short), Offset(decimal_points), 

    SyntheticGetValue, NULL

  },

  {

    XmNeditable, sizeof(Boolean), Offset(editable), 

    SyntheticGetValue, NULL

  },

  {

    XmNincrementValue, sizeof(int), Offset(increment_value), 

    SyntheticGetValue, NULL

  },

  {

    XmNmaximumValue, sizeof(int), Offset(maximum_value), 

    SyntheticGetValue, NULL

  },

  {

    XmNminimumValue, sizeof(int), Offset(minimum_value), 

    SyntheticGetValue, NULL

  },

  {

    XmNnumValues, sizeof(int), Offset(num_values),

    SyntheticGetValue, NULL

  },

  {

    XmNposition, sizeof(int), Offset(position),

    SyntheticGetValue, NULL

  },

  {

    XmNpositionType, sizeof(unsigned char), Offset(position_type),

    SyntheticGetValue, NULL

  },

  {

    XmNspinBoxChildType, sizeof(unsigned char), Offset(sb_child_type),

    SyntheticGetValue, NULL

  },

  {

    XmNvalues, sizeof(XmStringTable), Offset(values), 

    SyntheticGetValue, NULL

  },

  {

    XmNwrap, sizeof(Boolean), Offset(wrap),

    SyntheticGetValue, NULL

  }

};

/*  The Spin class record definition  */

externaldef (xmspinboxclassrec) XmSimpleSpinBoxClassRec xmSimpleSpinBoxClassRec= {

  {

    (WidgetClass)&xmSpinBoxClassRec,    /* superclass */   

    "XmSimpleSpinBox",                  /* class_name */	

    sizeof(XmSimpleSpinBoxRec),         /* widget_size */	

    (XtProc) NULL,		    	/* class_initialize */    

    (XtWidgetClassProc) NULL,		/* class_part_initialize */

    FALSE,    		                /* class_inited */	

    Initialize,    	                /* initialize */	

    NULL,    		                /* initialize_hook */

    XtInheritRealize,		        /* realize */	

    NULL, 	     	                /* actions */

    0,					/* num_actions */	

    resources,    	                /* resources */

    XtNumber(resources),                /* num_resources */

    NULLQUARK,    	                /* xrm_class */	

    TRUE,    		                /* compress_motion */	

    XtExposeCompressMaximal,           	/* compress_exposure */	

    TRUE,    		              	/* compress_enterleave */

    FALSE,    		              	/* visible_interest */	

    (XtWidgetProc) NULL,		/* destroy */	

    XtInheritResize,		      	/* resize */

    XtInheritExpose,   	              	/* expose */	

    SetValues,    	              	/* set_values */	

    (XtArgsFunc) NULL,			/* set_values_hook */

    XtInheritSetValuesAlmost,          	/* set_values_almost */

    (XtArgsProc) NULL,			/* get_values_hook */

    XtInheritAcceptFocus,	      	/* accept_focus */	

    XtVersion,    	              	/* version */

    (XtPointer) NULL,			/* callback proc list */

    XtInheritTranslations,	        /* tm_table */

    XtInheritQueryGeometry, 	      	/* query_geometry */

    (XtStringProc) NULL,		/* display_accelerator */

    (XtPointer) NULL,			/* extension */

  },

  {    /* composite_class fields */

    XtInheritGeometryManager,          	/* geometry_manager */

    XtInheritChangeManaged,            	/* change_managed */

    InsertChild,		        /* insert_child */

    XtInheritDeleteChild,	        /* delete_child */

    (XtPointer) NULL,			/* extension */

  },

  {    /* constraint_class fields */

    (XtResourceList) NULL,     		/* resource_list */

    (Cardinal) 0,		      	/* num_resources */

    (Cardinal) sizeof(

        XmSimpleSpinBoxConstraintRec),	/* constraint_size */

    (XtInitProc) NULL,			/* init_proc */

    (XtWidgetProc) NULL,		/* destroy_proc */

    (XtSetValuesFunc) NULL,		/* set_values_proc */

    (XtPointer) NULL,    		/* extension */

  },

      /* manager_class fields */

  {

    XtInheritTranslations,		/* translations */

    (XmSyntheticResource *) syn_resources, /* syn_resources */

    XtNumber(syn_resources),           	/* num_syn_resources */

    (XmSyntheticResource *) NULL,	/* syn_cont_resources */

    0,    		              	/* num_syn_cont_resources */

    (XmParentProcessProc) NULL,		/* parent_process */

    (XtPointer) NULL,			/* extension */

  },

      /* spinbox_class fields */

  {

    (XmGetCallbackWidgetProc)

        GetCallbackWidget,		/* get_callback_widget */

    (XtPointer) NULL,			/* extension */

  },

      /* simple_spinbox_class fields */

  {

    (XtPointer) NULL,			/* extension */

  }

};

externaldef(xmsimplespinboxwidgetclass) WidgetClass xmSimpleSpinBoxWidgetClass =

       (WidgetClass) &xmSimpleSpinBoxClassRec;

#define BAD_SSPIN_SET_TEXT_FIELD	_XmMMsgSSpinB_0001

#define BAD_SSPIN_SET_POSITION_TYPE	_XmMMsgSSpinB_0002

#define BAD_SSPIN_SET_ITEM		_XmMMsgSSpinB_0003

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

 **

 ***			MACROS

 **

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

#define SSB_TEXTFIELD_NAME_FORMAT	"%s_TF"

#define SSB_SIMPLE_SPIN_BOX_PART(w)	\

	(& ((XmSimpleSpinBoxWidget)(w))->simpleSpinBox)

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

 **

 ***			METHODS

 **

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

/*ARGSUSED*/

static void

Initialize(Widget	request,	/* unused */

	   Widget	new, 

	   ArgList	user_args,	/* unused */

	   Cardinal	*n_user_args)	/* unused */

{

    char			*widget_name;

    XmSimpleSpinBoxWidget	ssb_w;

    XmSimpleSpinBoxPart		*ssb_p;

    XmSpinBoxConstraint		textf_c;

    Arg				args[XtNumber(resources)];

    int				nargs = 0;

    ssb_w = (XmSimpleSpinBoxWidget) new;

    ssb_p = &ssb_w->simpleSpinBox;

    ssb_w->simpleSpinBox.text_field = (Widget) NULL;

    /*

     * Create and insert the text field child widget;

     */

    widget_name = XtMalloc(strlen(XtName(new)) + 10);

    sprintf(widget_name, SSB_TEXTFIELD_NAME_FORMAT, XtName(new));

    /*

     * Collect all the resources that apply to the TextField child,

     * and push include them in the creation call.

     * Allow the SpinBox widget worry about ensuring values are valid

     * and about saving values.

     * Once the child has been created, copy the relevant values out of

     * the constraint record for the TextField into our instance record.

     */

    XtSetArg(args[nargs], XmNarrowSensitivity,ssb_p->arrow_sensitivity);nargs++;

    XtSetArg(args[nargs], XmNdecimalPoints, ssb_p->decimal_points); nargs++;

    XtSetArg(args[nargs], XmNincrementValue, ssb_p->increment_value); nargs++;

    XtSetArg(args[nargs], XmNmaximumValue, ssb_p->maximum_value); nargs++;

    XtSetArg(args[nargs], XmNminimumValue, ssb_p->minimum_value); nargs++;

    XtSetArg(args[nargs], XmNnumValues, ssb_p->num_values); nargs++;

    XtSetArg(args[nargs], XmNposition, ssb_p->position); nargs++;

    XtSetArg(args[nargs], XmNpositionType, ssb_p->position_type); nargs++;

    XtSetArg(args[nargs], XmNspinBoxChildType, ssb_p->sb_child_type); nargs++;

    XtSetArg(args[nargs], XmNvalues, ssb_p->values); nargs++;

    XtSetArg(args[nargs], XmNwrap,ssb_p->wrap);nargs++;

    XtSetArg(args[nargs], XmNeditable, ssb_p->editable); nargs++;

    XtSetArg(args[nargs], XmNcolumns, ssb_p->columns); nargs++;

    ssb_p->text_field = XtCreateManagedWidget(	widget_name,

						xmTextFieldWidgetClass,

						(Widget) new,

						args, nargs);

    XtSetValues(ssb_p->text_field, args, nargs);

    textf_c = SB_GetConstraintRec(ssb_p->text_field);

    ssb_p->arrow_sensitivity = textf_c->arrow_sensitivity;

    ssb_p->decimal_points = textf_c->decimal_points;

    ssb_p->increment_value = textf_c->increment_value;

    ssb_p->maximum_value = textf_c->maximum_value;

    ssb_p->minimum_value = textf_c->minimum_value;

    ssb_p->num_values = textf_c->num_values;

    ssb_p->position = textf_c->position;

    ssb_p->position_type = textf_c->position_type;

    ssb_p->sb_child_type = textf_c->sb_child_type;

    ssb_p->values = textf_c->values;

    ssb_p->wrap = textf_c->wrap;

    XtVaGetValues(ssb_p->text_field,

		  XmNeditable, &ssb_p->editable,

		  XmNcolumns, &ssb_p->columns,

		  NULL);

    XtFree(widget_name);

}

/*ARGSUSED*/

static Boolean

SetValues(Widget	current, 

	  Widget	request, 	/* unused */

	  Widget	new, 

	  ArgList	args,		/* unused */

	  Cardinal	*num_args)	/* unused */

{

    XmSimpleSpinBoxPart	*cur_ssbp = SSB_SIMPLE_SPIN_BOX_PART(current);

    XmSimpleSpinBoxPart	*new_ssbp = SSB_SIMPLE_SPIN_BOX_PART(new);

    XmSpinBoxConstraint	textf_c;

    Boolean		display_flag;

    Arg			changed_args[XtNumber(resources)];

    int			nchanged_args = 0;

    /*

     * These resources have CG permissions only:

     *	XmNpositionType, XmNspinBoxChildType, XmNtextField

     *

     * BINARY COMPATIBILITY with DTSPINBOX

     * However, DtSpinBox does not prevent setting XmNspinBoxChildType

     * so we have to allow it.

     *

     * new_ssbp->sb_child_type = cur_ssbp->sb_child_type;

     */

    if (new_ssbp->position_type != cur_ssbp->position_type) {

        new_ssbp->position_type = cur_ssbp->position_type;

	XmeWarning(new, BAD_SSPIN_SET_POSITION_TYPE);

    }

    if (new_ssbp->text_field != cur_ssbp->text_field) {

        new_ssbp->text_field = cur_ssbp->text_field;

	XmeWarning(new, BAD_SSPIN_SET_TEXT_FIELD);

    }

    /*

     * Collect changed args and push them onto the TextField child.

     * Let the SpinBox widget worry about ensuring values are valid

     * and about saving values.

     *

     * Later, we'll copy the relevant values back into the SimpleSpinBox

     * record to ensure consistancy.

     */

    XtVaSetValues(new_ssbp->text_field,

		  XmNarrowSensitivity, new_ssbp->arrow_sensitivity,

		  XmNdecimalPoints, new_ssbp->decimal_points,

		  XmNincrementValue, new_ssbp->increment_value,

		  XmNmaximumValue, new_ssbp->maximum_value,

		  XmNminimumValue, new_ssbp->minimum_value,

		  XmNnumValues, new_ssbp->num_values,

		  XmNposition, new_ssbp->position,

		  XmNspinBoxChildType, new_ssbp->sb_child_type,

		  XmNvalues, new_ssbp->values,

		  XmNwrap, new_ssbp->wrap,

		  XmNeditable, new_ssbp->editable,

		  XmNcolumns, new_ssbp->columns,

		  NULL);

    textf_c = SB_GetConstraintRec(new_ssbp->text_field);

    new_ssbp->arrow_sensitivity = textf_c->arrow_sensitivity;

    new_ssbp->decimal_points = textf_c->decimal_points;

    new_ssbp->increment_value = textf_c->increment_value;

    new_ssbp->maximum_value = textf_c->maximum_value;

    new_ssbp->minimum_value = textf_c->minimum_value;

    new_ssbp->num_values = textf_c->num_values;

    new_ssbp->position = textf_c->position;

    new_ssbp->sb_child_type = textf_c->sb_child_type;

    new_ssbp->values = textf_c->values;

    new_ssbp->wrap = textf_c->wrap;

    XtVaGetValues(new_ssbp->text_field,

		  XmNeditable, &new_ssbp->editable,

		  XmNcolumns, &new_ssbp->columns,

		  NULL);

    return FALSE;

}

/*ARGSUSED*/

static void

InsertChild(Widget newChild)

{

    XmSimpleSpinBoxWidget	ssb_w;

    WidgetClass			super;

    XtWidgetProc 		insert_child;

    ssb_w = (XmSimpleSpinBoxWidget) XtParent(newChild);

    if (ssb_w->composite.num_children != 0) {

	XmeWarning((Widget) ssb_w, BAD_SSPIN_SET_TEXT_FIELD);

	return;

    }

    /* Call SpinBox's InsertChild method */

    _XmProcessLock();

    insert_child = ((XmSpinBoxWidgetClass)xmSpinBoxWidgetClass)->

	 			composite_class.insert_child;

    _XmProcessUnlock();

    (*insert_child)(newChild);

}

/*ARGSUSED*/

static Widget

GetCallbackWidget(Widget widget)

{

    XmSimpleSpinBoxWidget	ssb_w;

    WidgetClass			super;

    ssb_w = (XmSimpleSpinBoxWidget) widget;

    return((Widget) ssb_w->simpleSpinBox.text_field);

}

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

 * SyntheticGetValue

 *	XmExportProc conversion routine.

 *	Used to retrieve constraint resources from the spinbox for the

 *	textfield child.

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

/*ARGSUSED*/

static void

SyntheticGetValue(Widget widget, int offset, XtArgVal *value)

{

  XmSimpleSpinBoxWidget	ssb_w = (XmSimpleSpinBoxWidget) widget;

  switch (offset)

   {

     case Offset(arrow_sensitivity):

#ifdef FIX_1530

      {

        unsigned char new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNarrowSensitivity, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNarrowSensitivity, (unsigned char *) value,

		     NULL);

#endif

       break;

     case Offset(columns):

#ifdef FIX_1530

      {

        short new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNcolumns, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNcolumns, (short *) value,

		     NULL);

#endif

       break;

     case Offset(decimal_points):

#ifdef FIX_1530

      {

        short new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNdecimalPoints, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNdecimalPoints, (short *) value,

		     NULL);

#endif

       break;

     case Offset(editable):

#ifdef FIX_1530

      {

        Boolean new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNeditable, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNeditable, (Boolean *) value,

		     NULL);

#endif

       break;

     case Offset(increment_value):

#ifdef FIX_1530

      {

        short new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNincrementValue, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNincrementValue, (short *) value,

		     NULL);

#endif

       break;

     case Offset(minimum_value):

#ifdef FIX_1530

      {

        int new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNminimumValue, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNminimumValue, (int *) value,

		     NULL);

#endif

       break;

     case Offset(maximum_value):

#ifdef FIX_1530

      {

        int new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNmaximumValue, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNmaximumValue, (int *) value,

		     NULL);

#endif

       break;

     case Offset(num_values):

#ifdef FIX_1530

      {

        int new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNnumValues, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNnumValues, (int *) value,

		     NULL);

#endif

       break;

     case Offset(position):

#ifdef FIX_1530

      {

        int new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNposition, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNposition, (int *) value,

		     NULL);

#endif

       break;

     case Offset(position_type):

#ifdef FIX_1530

      {

        unsigned char new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNpositionType, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNpositionType, (unsigned char *) value,

		     NULL);

#endif

       break;

     case Offset(sb_child_type):

#ifdef FIX_1530

      {

        unsigned char new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNspinBoxChildType, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNspinBoxChildType, (unsigned char *) value,

		     NULL);

#endif

       break;

     case Offset(values):

#ifdef FIX_1530

      {

        XmStringTable new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNvalues, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNvalues, (XmStringTable *) value,

		     NULL);

#endif

       break;

     case Offset(wrap):

#ifdef FIX_1530

      {

        Boolean new_value;

        XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		      XmNwrap, &new_value,

		      NULL);

        *value = (XtArgVal)new_value;

      }

#else

       XtVaGetValues(ssb_w->simpleSpinBox.text_field,

		     XmNwrap, (Boolean *) value,

		     NULL);

#endif

       break;

     default:

       fprintf(stderr,

	       "SimpleSpinBox ERROR:  Invalid synthetic resource offset  %d\n",

	       offset);

       break;

   }

}

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

 **

 ***			EVENT HANDLERS

 **

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

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

 **

 ***			ACTIONS

 **

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

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

 **

 ***			OTHER FUNCTIONS

 **

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

/*

 * Public API

 */

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

 *  XmCreateSimpleSpinBox

 *	Create an instance of a Spin widget and return the widget id.

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

Widget 

XmCreateSimpleSpinBox(	Widget		parent,

			String		name, 

			ArgList		arglist,

			Cardinal	argcount)

{

    return(XtCreateWidget(name, xmSimpleSpinBoxWidgetClass, parent,

			  arglist, argcount));

}

Widget 

XmVaCreateSimpleSpinBox(

        Widget parent,

        char *name,

        ...)

{

    register Widget w;

    va_list var;

    int count;

    Va_start(var,name);

    count = XmeCountVaListSimple(var);

    va_end(var);

    Va_start(var, name);

    w = XmeVLCreateWidget(name, 

                         xmSimpleSpinBoxWidgetClass,

                         parent, False, 

                         var, count);

    va_end(var);   

    return w;

}

Widget

XmVaCreateManagedSimpleSpinBox(

        Widget parent,

        char *name,

        ...)

{

    Widget w = NULL;

    va_list var;

    int count;

    Va_start(var, name);

    count = XmeCountVaListSimple(var);

    va_end(var);

    Va_start(var, name);

    w = XmeVLCreateWidget(name, 

                         xmSimpleSpinBoxWidgetClass,

                         parent, True, 

                         var, count);

    va_end(var);   

    return w;

}

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

 *  XmSimpleSpinBoxAddItem

 *	Add an item to the list of strings at the specified position.

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

void 

XmSimpleSpinBoxAddItem(	Widget		ssb_w,

			XmString	item, 

			int	 	pos)

{

    XmSimpleSpinBoxPart	*ssb_p = SSB_SIMPLE_SPIN_BOX_PART(ssb_w);

    XmSpinBoxConstraint	textf_c;

    XmStringTable	values;

    int			new_nvalues;

    int			i;

    _XmWidgetToAppContext(ssb_w);

    _XmAppLock(app);

    /*

     * Get the latest resource values for the SimpleSpinBox child.

     * These may have been changed either by internal operation

     * of the SpinBox or by the application doing a SetValues on

     * the SimpleSpinBox child.

     */

    XtVaGetValues(ssb_p->text_field,

		  XmNarrowSensitivity, &ssb_p->arrow_sensitivity,

		  XmNdecimalPoints, &ssb_p->decimal_points,

		  XmNincrementValue, &ssb_p->increment_value,

		  XmNmaximumValue, &ssb_p->maximum_value,

		  XmNminimumValue, &ssb_p->minimum_value,

		  XmNnumValues, &ssb_p->num_values,

		  XmNposition, &ssb_p->position,

		  XmNspinBoxChildType, &ssb_p->sb_child_type,

		  XmNvalues, &ssb_p->values,

		  XmNwrap, &ssb_p->wrap,

		  XmNeditable, &ssb_p->editable,

		  XmNcolumns, &ssb_p->columns,

		  NULL);

    /*

     * Error checking.

     */

    if (ssb_p->sb_child_type != XmSTRING) {