/* 

 * 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: Scale.c /main/31 1999/10/13 16:18:07 mgreess $"

#endif

#endif

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

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

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdio.h>

#include <limits.h>

#ifndef CSRG_BASED

/*

 * Modification by Integrated Computer Solutions, Inc.  May 2000

 *

 * Original:

 *

 * # ifdef linux

 * #  define RADIXCHAR MON_DECIMAL_POINT

 * # endif

 * # include <langinfo.h>

 *

 * glibc >= 2.0 defines RADIXCHAR in langinfo.h, simply make sure 

 * that it is not redefined here.

 */

# include <langinfo.h>

# if defined(linux) && !defined(RADIXCHAR)

#  define RADIXCHAR DECIMAL_POINT

# endif

# ifdef X_LOCALE

#  ifdef linux

   /* avoid conflicting with <X11/Xlocale.h> defines */

#   undef LC_ALL

#   undef LC_COLLATE

#   undef LC_CTYPE

#   undef LC_MONETARY

#   undef LC_NUMERIC

#   undef LC_TIME

#  endif

# endif

#else

# define nl_langinfo(radixchar)	"."

#endif

#ifdef __cplusplus

extern "C" { /* some 'locale.h' do not have prototypes (sun) */

#endif

#include <X11/Xlocale.h>

#ifdef __cplusplus

} /* Close scope of 'extern "C"' declaration */

#endif /* __cplusplus */

#include <Xm/AtomMgr.h>

#include <Xm/DisplayP.h>

#include <Xm/DragC.h>

#include <Xm/DragIconP.h>

#include <Xm/LabelG.h>

#include <Xm/ScaleP.h>

#include <Xm/ScrollBarP.h>	/* for slider geometrical data */

#include <Xm/TraitP.h>

#include <Xm/TransferT.h>

#include <Xm/XmosP.h>

#include <Xm/VaSimpleP.h>

#include "GeoUtilsI.h"

#include "GMUtilsI.h"

#include "MessagesI.h"

#include "RepTypeI.h"

#include "TransferI.h"

#include "TraversalI.h"

#include "XmI.h"

#define FIX_1528

#define state_flags last_value

#define MESSAGE1	_XmMMsgScale_0000

#define MESSAGE2	_XmMMsgScale_0001

#define MESSAGE3	_XmMMsgScale_0002

#define MESSAGE5	_XmMMsgScaleScrBar_0004

#define MESSAGE7	_XmMMsgScale_0006

#define MESSAGE8	_XmMMsgScale_0007

#define MESSAGE9	_XmMMsgScale_0008

static Region null_region = NULL;

/* Convenience macros and definitions */

#define TotalWidth(w)   (w->core.width + (w->core.border_width * 2))

#define TotalHeight(w)  (w->core.height + (w->core.border_width * 2))

#define SCROLLBAR_MAX	1000000000

#define SCALE_VALUE_MARGIN 3

#define SCALE_DEFAULT_MAJOR_SIZE \

	(100 + (2 * sw->scale.highlight_thickness))

#define SCALE_DEFAULT_MINOR_SIZE \

	(15 + (2 * sw->scale.highlight_thickness))

#define SLIDER_SIZE(sca)	((sca->scale.sliding_mode == XmTHERMOMETER)?\

				 0:sca->scale.slider_size)

/* this one is context dependent, args and n are used */

#define SET(name, val) {XtSetArg (args[n], (name), (val)); n++;}

#define LeadXTic(sb, sca) (sb->scrollBar.slider_area_x \

		     + (Dimension) (((float) SLIDER_SIZE(sca) / 2.0) + 0.5))

#define LeadYTic(sb, sca) (sb->scrollBar.slider_area_y \

		     + (Dimension) (((float) SLIDER_SIZE(sca) / 2.0) + 0.5))

#define TrailXTic(sb, sca) (sb->core.width - (sb->scrollBar.slider_area_x \

		     + sb->scrollBar.slider_area_width\

		      - (Dimension) (((float) SLIDER_SIZE(sca) / 2.0) + 0.5)))

#define TrailYTic(sb, sca) (sb->core.height - (sb->scrollBar.slider_area_y \

		     + sb->scrollBar.slider_area_height\

		      - (Dimension) (((float) SLIDER_SIZE(sca) / 2.0) + 0.5)))

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

static void ScaleGetTitleString( 

                        Widget wid,

                        int resource,

                        XtArgVal *value) ;

static void ClassInitialize( void ) ;

static void ClassPartInitialize( 

                        WidgetClass wc) ;

static void ProcessingDirectionDefault( 

                        XmScaleWidget widget,

                        int offset,

                        XrmValue *value) ;

static void SliderVisualDefault( 

                        XmScaleWidget widget,

                        int offset,

                        XrmValue *value) ;

static void SliderMarkDefault( 

                        XmScaleWidget widget,

                        int offset,

                        XrmValue *value) ;

static void EditableDefault( 

                        XmScaleWidget widget,

                        int offset,

                        XrmValue *value) ;

static void ValidateInitialState( 

                        XmScaleWidget req,

                        XmScaleWidget new_w) ;

static Widget CreateScaleTitle( 

                        XmScaleWidget new_w) ;

static Widget CreateScaleScrollBar( 

                        XmScaleWidget new_w) ;

static void Initialize( 

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static void GetForegroundGC( 

                        XmScaleWidget sw) ;

static void Redisplay( 

                        Widget wid,

                        XEvent *event,

                        Region region) ;

static void CalcScrollBarData( 

                        XmScaleWidget sw,

                        int *value,

                        int *slider_size,

                        int *increment,

                        int *page) ;

static void Resize( 

                        Widget wid) ;

static void ValidateInputs( 

                        XmScaleWidget cur,

                        XmScaleWidget new_w) ;

static void HandleTitle( 

                        XmScaleWidget cur,

                        XmScaleWidget req,

                        XmScaleWidget new_w) ;

static void HandleScrollBar( 

                        XmScaleWidget cur,

                        XmScaleWidget req,

                        XmScaleWidget new_w) ;

static Boolean SetValues( 

                        Widget cw,

                        Widget rw,

                        Widget nw,

                        ArgList args_in,

                        Cardinal *num_args_in) ;

static void Realize( 

                        register Widget w,

                        XtValueMask *p_valueMask,

                        XSetWindowAttributes *attributes) ;

static void Destroy( 

                        Widget wid) ;

static XtGeometryResult GeometryManager( 

                        Widget w,

                        XtWidgetGeometry *request,

                        XtWidgetGeometry *reply) ;

static Dimension MaxLabelWidth( 

                        XmScaleWidget sw) ;

static Dimension MaxLabelHeight( 

                        XmScaleWidget sw) ;

static Dimension ValueTroughWidth( 

                        XmScaleWidget sw) ;

static Dimension ValueTroughHeight( 

                        XmScaleWidget sw) ;

static Dimension ValueTroughAscent( 

                        XmScaleWidget sw) ;

static Dimension ValueTroughDescent( 

                        XmScaleWidget sw) ;

static Dimension TitleWidth( 

                        XmScaleWidget sw) ;

static Dimension TitleHeight( 

                        XmScaleWidget sw) ;

static Cardinal NumManaged(

			   XmScaleWidget sw,

			   Widget * first_man,

			   Widget * last_man);

static Dimension MajorLeadPad( 

                        XmScaleWidget sw) ;

static Dimension MajorTrailPad( 

                        XmScaleWidget sw) ;

static Dimension ScrollWidth( 

                        XmScaleWidget sw) ;

static Dimension ScrollHeight( 

                        XmScaleWidget sw) ;

static void GetScaleSize( 

                        XmScaleWidget sw,

                        Dimension *w,

                        Dimension *h) ;

static void LayoutHorizontalLabels( 

                        XmScaleWidget sw,

                        XRectangle *scrollBox,

                        XRectangle *labelBox,

                        Widget instigator) ;

static void LayoutHorizontalScale( 

                        XmScaleWidget sw,

                        XtWidgetGeometry * desired,

			Widget instigator) ;

static void LayoutVerticalLabels( 

                        XmScaleWidget sw,

                        XRectangle *scrollBox,

                        XRectangle *labelBox,

                        Widget instigator) ;

static void LayoutVerticalScale( 

                        XmScaleWidget sw,

                        XtWidgetGeometry * desired,

			Widget instigator) ;

static void ChangeManaged( 

                        Widget wid) ;

static void GetValueString(

                        XmScaleWidget sw,

                        int value,

                        String buffer);

static void ShowValue(

		        XmScaleWidget sw) ;

static void SetScrollBarData( 

                        XmScaleWidget sw) ;

static void ValueChanged( 

                        Widget wid,

                        XtPointer closure,

                        XtPointer call_data) ;

static XtGeometryResult QueryGeometry( 

                        Widget wid,

                        XtWidgetGeometry *intended,

                        XtWidgetGeometry *desired) ;

static XmNavigability WidgetNavigable( 

                        Widget wid) ;

static void StartDrag (Widget  w, 

                        XtPointer data, 

		        XEvent  *event, 

		        Boolean *cont) ;

static void DragConvertCallback (Widget w,

				 XtPointer client_data,

				 XmConvertCallbackStruct *cs);

static void CheckSetRenderTable(Widget wid,

				int offset,

				XrmValue *value); 

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

/*  Resource definitions for Scale class */

static XtResource resources[] =

{

   {

       XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension,

       sizeof (Dimension), XtOffsetOf(XmManagerRec, manager.shadow_thickness),

       XmRCallProc, (XtPointer) _XmSetThickness

   },

   {

       XmNvalue, XmCValue, XmRInt, 

       sizeof(int), XtOffsetOf(XmScaleRec,scale.value),

       XmRImmediate, (XtPointer) XmINVALID_DIMENSION

   },

   {

       XmNmaximum, XmCMaximum, XmRInt, 

       sizeof(int), XtOffsetOf(XmScaleRec,scale.maximum), 

       XmRImmediate, (XtPointer)100

   },

   {

       XmNminimum, XmCMinimum, XmRInt,

       sizeof(int), XtOffsetOf(XmScaleRec,scale.minimum), 

       XmRImmediate, (XtPointer)0

   },

   {

       XmNorientation, XmCOrientation, XmROrientation, 

       sizeof(unsigned char), XtOffsetOf(XmScaleRec,scale.orientation), 

       XmRImmediate, (XtPointer) XmVERTICAL

   },

   {

       XmNprocessingDirection, XmCProcessingDirection, XmRProcessingDirection,

       sizeof(unsigned char), 

       XtOffsetOf(XmScaleRec,scale.processing_direction), 

       XmRCallProc, (XtPointer) ProcessingDirectionDefault

   },

   {

       XmNtitleString, XmCTitleString, XmRXmString, 

       sizeof(XmString), XtOffsetOf(XmScaleRec,scale.title), 

       XmRImmediate, (XtPointer) NULL

   },

   {

	"pri.vate","Pri.vate",XmRInt,

	sizeof(int), XtOffsetOf(XmScaleRec,scale.last_value),

	XmRImmediate, (XtPointer) False

   },

   {

       XmNfontList, XmCFontList, XmRFontList, 

       sizeof(XmFontList), XtOffsetOf(XmScaleRec, scale.font_list), 

       XmRCallProc, (XtPointer)CheckSetRenderTable

   },

   {

       XmNrenderTable, XmCRenderTable, XmRRenderTable, 

       sizeof(XmRenderTable), XtOffsetOf(XmScaleRec, scale.font_list), 

       XmRCallProc, (XtPointer)CheckSetRenderTable

   },

   {

       XmNshowValue, XmCShowValue, XmRShowValue, 

       sizeof(XtEnum), XtOffsetOf(XmScaleRec,scale.show_value), 

       XmRImmediate, (XtPointer) XmNONE

   },

   {

       XmNdecimalPoints, XmCDecimalPoints, XmRShort, 

       sizeof(short), XtOffsetOf(XmScaleRec,scale.decimal_points), 

       XmRImmediate, (XtPointer) 0

   },

   {

       XmNscaleWidth, XmCScaleWidth, XmRHorizontalDimension,

       sizeof (Dimension), XtOffsetOf(XmScaleRec, scale.scale_width),

       XmRImmediate, (XtPointer) 0

   },

   {

       XmNscaleHeight, XmCScaleHeight, XmRVerticalDimension,

       sizeof (Dimension), XtOffsetOf(XmScaleRec, scale.scale_height),

       XmRImmediate, (XtPointer) 0

   },

   {

       XmNhighlightThickness, XmCHighlightThickness, XmRHorizontalDimension, 

       sizeof (Dimension), XtOffsetOf(XmScaleRec, scale.highlight_thickness),

       XmRCallProc, (XtPointer) _XmSetThickness

   },

   {

       XmNhighlightOnEnter, XmCHighlightOnEnter, XmRBoolean, 

       sizeof (Boolean), XtOffsetOf(XmScaleRec, scale.highlight_on_enter),

       XmRImmediate, (XtPointer) False

   },

   {

       XmNvalueChangedCallback, XmCCallback, XmRCallback, 

       sizeof(XtCallbackList), 

       XtOffsetOf(XmScaleRec,scale.value_changed_callback), 

       XmRCallback, (XtPointer) NULL

   },

   {

      XmNconvertCallback, XmCCallback, XmRCallback, sizeof(XtCallbackList),

      XtOffsetOf(XmScaleRec, scale.convert_callback),

      XmRCallback, (XtPointer) NULL

   },

   { 

       XmNdragCallback, XmCCallback, XmRCallback, 

       sizeof(XtCallbackList),

       XtOffsetOf(XmScaleRec,scale.drag_callback), 

       XmRCallback, (XtPointer) NULL

   },

   {

       XmNscaleMultiple, XmCScaleMultiple, XmRInt, 

       sizeof(int), XtOffsetOf(XmScaleRec,scale.scale_multiple), 

       XmRImmediate, (XtPointer) 0

   },

   {

       XmNslidingMode, XmCSlidingMode, XmRSlidingMode, 

       sizeof(XtEnum), XtOffsetOf(XmScaleRec,scale.sliding_mode), 

       XmRImmediate, (XtPointer) XmSLIDER

   },

   {

       XmNeditable, XmCEditable, XmRBoolean, 

       sizeof(XtEnum), XtOffsetOf(XmScaleRec,scale.editable), 

       XmRCallProc, (XtPointer) EditableDefault

   },

   {

       XmNsliderVisual, XmCSliderVisual, XmRSliderVisual,

       sizeof (XtEnum),

       XtOffsetOf(XmScaleRec, scale.slider_visual),

       XmRCallProc, (XtPointer) SliderVisualDefault

   },

   {

       XmNsliderMark, XmCSliderMark, XmRSliderMark,

       sizeof (XtEnum),

       XtOffsetOf(XmScaleRec, scale.slider_mark),

       XmRCallProc, (XtPointer) SliderMarkDefault

   },

   { /* undocumented - need synthetic hook to be complete */

       XmNsliderSize, XmCSliderSize, XmRHorizontalInt, sizeof (int),

       XtOffsetOf(XmScaleRec, scale.slider_size),

       XmRImmediate, (XtPointer) 30

   },

   { 

       XmNshowArrows, XmCShowArrows, XmRShowArrows, sizeof (XtEnum),

       XtOffsetOf(XmScaleRec, scale.show_arrows),

       XmRImmediate, (XtPointer) XmNONE

   },

};

/*  Definition for resources that need special processing in get values  */

static XmSyntheticResource syn_resources[] =

{

    { 

	XmNtitleString,

	sizeof (XmString), XtOffsetOf(XmScaleRec, scale.title), 

	ScaleGetTitleString, (XmImportProc)NULL 

    },

    { 

	XmNscaleWidth,

	sizeof (Dimension), XtOffsetOf(XmScaleRec, scale.scale_width), 

	XmeFromHorizontalPixels, XmeToHorizontalPixels 

    },

    { 

	XmNscaleHeight,

	sizeof (Dimension), XtOffsetOf(XmScaleRec, scale.scale_height), 

	XmeFromVerticalPixels, XmeToVerticalPixels

    }

};

/*  Scale class record definition  */

static XmBaseClassExtRec baseClassExtRec = {

    NULL,

    NULLQUARK,

    XmBaseClassExtVersion,

    sizeof(XmBaseClassExtRec),

    (XtInitProc)NULL,			/* InitializePrehook	*/

    (XtSetValuesFunc)NULL,		/* SetValuesPrehook	*/

    (XtInitProc)NULL,			/* InitializePosthook	*/

    (XtSetValuesFunc)NULL,		/* SetValuesPosthook	*/

    NULL,				/* secondaryObjectClass	*/

    (XtInitProc)NULL,			/* secondaryCreate	*/

    (XmGetSecResDataFunc)NULL, 		/* getSecRes data	*/

    { 0 },      			/* fastSubclass flags	*/

    (XtArgsProc)NULL,			/* getValuesPrehook	*/

    (XtArgsProc)NULL,			/* getValuesPosthook	*/

    (XtWidgetClassProc)NULL,            /* classPartInitPrehook */

    (XtWidgetClassProc)NULL,            /* classPartInitPosthook*/

    NULL,                               /* ext_resources        */

    NULL,                               /* compiled_ext_resources*/

    0,                                  /* num_ext_resources    */

    FALSE,                              /* use_sub_resources    */

    WidgetNavigable,                    /* widgetNavigable      */

    (XmFocusChangeProc)NULL,            /* focusChange          */

    (XmWrapperData)NULL			/* wrapperData 		*/

};

externaldef(xmscaleclassrec) XmScaleClassRec xmScaleClassRec = 

{

   {                                            /* core_class fields    */

      (WidgetClass) &xmManagerClassRec,         /* superclass         */

      "XmScale",                                /* class_name         */

      sizeof(XmScaleRec),                       /* widget_size        */

      ClassInitialize,                          /* class_initialize   */

      ClassPartInitialize,                      /* class_part_init    */

      FALSE,                                    /* class_inited       */

      Initialize,                               /* initialize         */

      (XtArgsProc)NULL,                         /* initialize_hook    */

      Realize,                                  /* realize            */

      NULL,                                     /* actions            */

      0,                                        /* num_actions        */

      resources,                                /* resources          */

      XtNumber(resources),                      /* num_resources      */

      NULLQUARK,                                /* xrm_class          */

      TRUE,                                     /* compress_motion    */

      XtExposeCompressMaximal,                  /* compress_exposure  */

      TRUE,                                     /* compress_enterlv   */

      FALSE,                                    /* visible_interest   */

      Destroy,                                  /* destroy            */

      Resize,                                   /* resize             */

      Redisplay,                                /* expose             */

      SetValues,                                /* set_values         */

      (XtArgsFunc)NULL,                         /* set_values_hook    */

      XtInheritSetValuesAlmost,                 /* set_values_almost  */

      (XtArgsProc)NULL,                         /* get_values_hook    */

      (XtAcceptFocusProc)NULL,                  /* accept_focus       */

      XtVersion,                                /* version            */

      NULL,                                     /* callback_private   */

      XtInheritTranslations,                    /* tm_table           */

      (XtGeometryHandler) QueryGeometry,        /* query_geometry     */

      (XtStringProc)NULL,                       /* display_accelerator*/

      (XtPointer)&baseClassExtRec,              /* extension          */

   },

   {                                            /* composite_class fields */

      GeometryManager,                          /* geometry_manager   */

      ChangeManaged,                            /* change_managed     */

      XtInheritInsertChild,                     /* insert_child       */

      XtInheritDeleteChild,                     /* delete_child       */

      NULL,                                     /* extension          */

   },

   {                                            /* constraint_class fields */

      NULL,                                     /* resource list        */   

      0,                                        /* num resources        */   

      sizeof(XmManagerConstraintRec),           /* constraint size      */   

      (XtInitProc)NULL,                         /* init proc            */   

      (XtWidgetProc)NULL,                       /* destroy proc         */   

      (XtSetValuesFunc)NULL,                    /* set values proc      */   

      NULL,                                     /* extension            */

   },

   {		/* manager_class fields */

      XtInheritTranslations,			/* translations           */

      syn_resources,				/* syn_resources      	  */

      XtNumber(syn_resources),			/* num_syn_resources 	  */

      NULL,					/* syn_cont_resources     */

      0,					/* num_syn_cont_resources */

      XmInheritParentProcess,                   /* parent_process         */

      NULL,					/* extension           	  */

   },

   {                                            /* scale class - none */     

      (XtPointer) NULL                          /* extension */

   }    

};

externaldef(xmscalewidgetclass) WidgetClass

	xmScaleWidgetClass = (WidgetClass)&xmScaleClassRec;

/* Transfer trait record */

static XmConst XmTransferTraitRec ScaleTransfer = {

  0, 						/* version */

  (XmConvertCallbackProc) DragConvertCallback,	/* convertProc */

  NULL,						/* destinationProc */

  NULL,						/* destinationPreHookProc */

};

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

/************** Synthetic hook & default routines ***************/

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

/*ARGSUSED*/

static void

ScaleGetTitleString(

        Widget wid,

        int resource,		/* unused */

        XtArgVal *value)

/****************           ARGSUSED  ****************/

{

	XmScaleWidget scale = (XmScaleWidget) wid ;

	Arg           al[1] ;

	if (scale->scale.title == NULL) {

	    /* mean that the title has never been set, so 

	       we should return NULL, not the label value which

	       is the label name, not NULL,  in this case */

	    *value = (XtArgVal) NULL ;

	} else { 

	    /* title = -1, our magic value used to tell: look in

	       the label child. */

	    XtSetArg (al[0], XmNlabelString, value);	/* make a copy */

	    XtGetValues (scale->composite.children[0], al, 1);

	}

}

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

 *

 * ProcessingDirectionDefault

 *    This procedure provides the dynamic default behavior for

 *    the processing direction resource dependent on the orientation.

 *

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

/*ARGSUSED*/

static void 

ProcessingDirectionDefault(

        XmScaleWidget widget,

        int offset,		/* unused */

        XrmValue *value )

{

	static unsigned char direction;

	value->addr = (XPointer) &direction;

	if (widget->scale.orientation == XmHORIZONTAL)

        {

           if (LayoutIsRtoLM(widget))

                direction = XmMAX_ON_LEFT;

           else

		direction = XmMAX_ON_RIGHT;

        }

	else /* XmVERTICAL  -- range checking done during widget

		                   initialization */

		direction = XmMAX_ON_TOP;

}

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

 *

 * SliderVisualDefault

 *    

 *

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

/*ARGSUSED*/

static void 

SliderVisualDefault(

        XmScaleWidget widget,

        int offset,		/* unused */

        XrmValue *value )

{

      static XtEnum slider_visual ;

      value->addr = (XPointer) &slider_visual;

      if (widget->scale.sliding_mode == XmTHERMOMETER) {

          slider_visual = XmTROUGH_COLOR ;

      } else {

	  slider_visual = XmSHADOWED_BACKGROUND ;

      }

}

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

 *

 * SliderMarkDefault

 *    

 *

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

/*ARGSUSED*/

static void 

SliderMarkDefault(

        XmScaleWidget widget,

        int offset,		/* unused */

        XrmValue *value )

{

      static XtEnum slider_mark ;

      value->addr = (XPointer) &slider_mark;

      if (!widget->scale.editable) slider_mark = XmNONE ;

      else {

	  if (widget->scale.sliding_mode == XmTHERMOMETER)

	      slider_mark = XmROUND_MARK ;

	  else

	      slider_mark = XmETCHED_LINE ;

      }

}

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

 *

 * EditableDefault

 *    

 *

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

/*ARGSUSED*/

static void 

EditableDefault(

        XmScaleWidget widget,

        int offset,		/* unused */

        XrmValue *value )

{

      static XtEnum editable ;

      value->addr = (XPointer) &editable;

      if (widget->scale.sliding_mode == XmTHERMOMETER) {

          editable = False ;

      } else {

	  editable = True ;

      }

}

/*

 * XmRCallProc routine for checking list.font before setting it to NULL

 * if no value is specified for both XmNrenderTable and XmNfontList.

 * If "last_value" is True, then function has been called twice on same 

 * widget, thus resource needs to be set NULL, otherwise leave it alone.

 */

/* ARGSUSED */

static void 

CheckSetRenderTable(Widget wid,

		    int offset,

		    XrmValue *value )

{

  XmScaleWidget sw = (XmScaleWidget)wid;

  /* Check if been here before */

  if (sw->scale.last_value)

      value->addr = NULL;

  else {

      sw->scale.last_value = True;

      value->addr = (char*)&(sw->scale.font_list);

  }

}

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

 *

 *  ClassInitialize

 *

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

static void 

ClassInitialize( void )

{

  baseClassExtRec.record_type = XmQmotif ;

  if (null_region == NULL)

    null_region = XCreateRegion();

}

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

 *

 *  ClassPartInitialize

 *     Initialize the fast subclassing.

 *

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

static void 

ClassPartInitialize(

        WidgetClass wc )

{

   _XmFastSubclassInit (wc, XmSCALE_BIT);

    /* Install transfer trait */

    XmeTraitSet((XtPointer)wc, XmQTtransfer, (XtPointer) &ScaleTransfer);

}

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

 *  Initialize

 *      Validate all of the argument data for the widget, create the

 *	title label and scrollbar.

 *

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

/*ARGSUSED*/

static void 

ValidateInitialState(

        XmScaleWidget req,	/* unused */

        XmScaleWidget new_w )

{

	Boolean default_value = FALSE;

        float value_range;

	if (new_w->scale.minimum >= new_w->scale.maximum)

	{

		new_w->scale.minimum = 0;

		new_w->scale.maximum = 100;

		XmeWarning( (Widget) new_w, MESSAGE1);

	}

        value_range = (float)((float)new_w->scale.maximum - 

			      (float)new_w->scale.minimum);

        if (value_range > (float)((float)INT_MAX / (float) 2.0))

        {

             new_w->scale.minimum = 0;

	     if (new_w->scale.maximum > (INT_MAX / 2))

	         new_w->scale.maximum = INT_MAX / 2;

            XmeWarning( (Widget) new_w, MESSAGE9);

        }

	if (new_w->scale.value == XmINVALID_DIMENSION)

	{

		new_w->scale.value = 0;

		default_value = True;

	}

	if (new_w->scale.value < new_w->scale.minimum)

	{

		new_w->scale.value = new_w->scale.minimum;

		if (!default_value) XmeWarning( (Widget) new_w, MESSAGE2);

	}

	if (new_w->scale.value > new_w->scale.maximum)

	{

		new_w->scale.value = new_w->scale.minimum;

		if (!default_value) XmeWarning( (Widget) new_w, MESSAGE3);

	}

	if(!XmRepTypeValidValue( XmRID_ORIENTATION,

				new_w->scale.orientation, (Widget) new_w) )

	{

		new_w->scale.orientation = XmVERTICAL;

	}

	if (!XmRepTypeValidValue( XmRID_SHOW_VALUE,

				new_w->scale.show_value, (Widget) new_w) )

	    {

		new_w->scale.show_value = XmNONE;

	    }

	if (new_w->scale.orientation == XmHORIZONTAL)

	{

		if ((new_w->scale.processing_direction != XmMAX_ON_RIGHT) &&

			(new_w->scale.processing_direction != XmMAX_ON_LEFT))

		{

			new_w->scale.processing_direction = XmMAX_ON_RIGHT;

			XmeWarning( (Widget) new_w, MESSAGE5);

		}

	}

	else