/*

 * 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

 * 

 */

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

 *       INCLUDE FILES

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

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include "ColorSP.h"

#include <Xm/Xm.h>

#include <Xm/VaSimpleP.h>

#include <Xm/ButtonBox.h>

#include <Xm/Scale.h>

#include <Xm/ScrolledW.h>

#include <Xm/List.h>

#include <Xm/RowColumn.h>

#include <Xm/ToggleB.h>

#include <Xm/Frame.h>

#include <Xm/Label.h>

#include <Xm/ExtP.h>

#include "XmI.h"

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

 *       TYPEDEFS AND DEFINES

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

#define SUPERCLASS ((WidgetClass) &xmManagerClassRec)

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

 *       MACROS

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

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

 *       GLOBAL DECLARATIONS

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

extern void 		XmeNavigChangeManaged(Widget);

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

 *       STATIC FUNCTION DECLARATIONS

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

static void ChangeManaged(Widget w);

static void ClassInitialize(void), Destroy(Widget), Resize(Widget);

static void ClassPartInitialize(WidgetClass w_class);

static void Initialize(Widget, Widget, ArgList, Cardinal *);

static Boolean SetValues(Widget, Widget, Widget, ArgList, Cardinal *);

static XtGeometryResult GeometryHandler(Widget, XtWidgetGeometry *, 

					XtWidgetGeometry *);

static XtGeometryResult QueryGeometry(Widget, XtWidgetGeometry *,

				      XtWidgetGeometry *);

static Boolean UpdateColorWindow(XmColorSelectorWidget, Boolean);

static Boolean color_name_changed(XmColorSelectorWidget, char *);

static Boolean FindColor(XmColorSelectorWidget, int *);

static Boolean CvtStringToColorMode(Display *, XrmValuePtr, Cardinal, 

				    XrmValuePtr, XrmValuePtr, XtPointer *);

static Boolean DefaultVisualDisplay(XmColorSelectorWidget, Pixel, XColor, char *);

static void CalcPreferredSize(XmColorSelectorWidget, Dimension *, Dimension *);

static void SelectColor(XmColorSelectorWidget);

static void slider_changed(Widget, XtPointer, XtPointer);

static void list_selected(Widget, XtPointer, XtPointer);

static void change_mode(Widget, XtPointer, XtPointer);

static void new_mode(XmColorSelectorWidget, XmColorMode);

static void compute_size(XmColorSelectorWidget);

static void read_rgb_file(XmColorSelectorWidget, ArgList, Cardinal, Boolean);

static void SetSliders(XmColorSelectorWidget);

static void CreateColorSliders(XmColorSelectorWidget, ArgList, Cardinal);

static void CreateSelectorRadio(XmColorSelectorWidget, ArgList, Cardinal);

static void CreateColorWindow(XmColorSelectorWidget, ArgList, Cardinal);

static void NoPrivateColormaps(XmColorSelectorWidget, Pixel, XColor, char *);

static void PrivateColormaps(XmColorSelectorWidget, Pixel, XColor, char *);

#ifdef notdef

static void CreateTypes(XmColorSelectorWidget, Widget, ArgList, Cardinal);

#endif

static int CmpColors(const void *, const void *);

static char *find_name(char *);

static int GetVisual(XmColorSelectorWidget);

static void GetValues_XmNredSliderLabel ( Widget w, int n, XtArgVal *value) ;

static void GetValues_XmNgreenSliderLabel( Widget w, int n, XtArgVal *value) ;

static void GetValues_XmNblueSliderLabel( Widget w, int n, XtArgVal *value) ;

static void GetValues_XmNcolorListTogLabel( Widget w, int n, XtArgVal *value) ;

static void GetValues_XmNsliderTogLabel( Widget w, int n, XtArgVal *value) ;

static void GetValues_XmNnoCellError( Widget w, int n, XtArgVal *value) ;

static void GetValues_XmNfileReadError( Widget w, int n, XtArgVal *value) ;

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

 *       STATIC DECLARATIONS

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

static XtResource resources[] =

{

  {

    XmNcolorMode, XmCColorMode, XmRXmColorMode,

    sizeof(XmColorMode), XtOffsetOf(XmColorSelectorRec, cs.color_mode),

    XmRImmediate, (XtPointer) XmScaleMode

  },

  {

    XmNcolorName, XmCString, XmRString,

    sizeof(String), XtOffsetOf(XmColorSelectorRec, cs.color_name),

    XmRString, "White"

  },

#ifdef VMS    

  {

    XmNrgbFile, XmCString, XmRString,

    sizeof(String), XtOffsetOf(XmColorSelectorRec, cs.rgb_file),

    XmRString, (XtPointer) "sys$manager:decw$rgb.dat"

  },

#else

  {

    XmNrgbFile, XmCString, XmRString,

    sizeof(String), XtOffsetOf(XmColorSelectorRec, cs.rgb_file),

    XmRString, (XtPointer) "/usr/lib/X11/rgb.txt"

  },

#endif

  {

    XmNmarginWidth, XmCMargin, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmColorSelectorRec, cs.margin_width),

    XmRImmediate, (XtPointer) 2

  },

  {

    XmNmarginHeight, XmCMargin, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmColorSelectorRec, cs.margin_height),

    XmRImmediate, (XtPointer) 2

  },

  {

    XmNredSliderLabel, XmCSliderLabel, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmColorSelectorRec, cs.strings.slider_labels[0]),

    XmRString, (XtPointer) "Red"

  },

  {

    XmNgreenSliderLabel, XmCSliderLabel, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmColorSelectorRec, cs.strings.slider_labels[1]),

    XmRString, (XtPointer) "Green"

  },

  {

    XmNblueSliderLabel, XmCSliderLabel, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmColorSelectorRec, cs.strings.slider_labels[2]),

    XmRString, (XtPointer) "Blue"

  },

  {

    XmNcolorListTogLabel, XmCTogLabel, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmColorSelectorRec, cs.strings.tog_labels[0]),

    XmRString, (XtPointer) "Color List"

  },

  {

    XmNsliderTogLabel, XmCTogLabel, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmColorSelectorRec, cs.strings.tog_labels[1]),

    XmRString,(XtPointer)"Color Sliders"

  },

  {

    XmNnoCellError, XmCNoCellError, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmColorSelectorRec, cs.strings.no_cell_error),

    XmRString, (XtPointer)"\n\nNo Color Cell Available!"

  },

  {

    XmNfileReadError, XmCFileReadError, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmColorSelectorRec, cs.strings.file_read_error),

    XmRString, (XtPointer)"Could not read rgb.txt file:"

  }

};	

static XmSyntheticResource get_resources[] =

{

  {

    XmNmarginWidth, sizeof(Dimension),

    XtOffsetOf(XmColorSelectorRec, cs.margin_width),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  },

  {

    XmNmarginHeight, sizeof(Dimension),

    XtOffsetOf(XmColorSelectorRec, cs.margin_height),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  },

  {

    XmNredSliderLabel, sizeof(XmString),

    XtOffsetOf(XmColorSelectorRec, cs.strings.slider_labels[0]), 

    GetValues_XmNredSliderLabel, NULL

  },

  {

    XmNgreenSliderLabel, sizeof(XmString),

    XtOffsetOf(XmColorSelectorRec, cs.strings.slider_labels[1]),

    GetValues_XmNgreenSliderLabel, NULL

  },

  {

    XmNblueSliderLabel, sizeof(XmString),

    XtOffsetOf(XmColorSelectorRec, cs.strings.slider_labels[2]), 

    GetValues_XmNblueSliderLabel, NULL

  },

  {

    XmNcolorListTogLabel, sizeof(XmString),

    XtOffsetOf(XmColorSelectorRec, cs.strings.tog_labels[0]), 

    GetValues_XmNcolorListTogLabel, NULL

  },

  {

    XmNsliderTogLabel, sizeof(XmString),

    XtOffsetOf(XmColorSelectorRec, cs.strings.tog_labels[1]),

    GetValues_XmNsliderTogLabel, NULL

  },

  {

    XmNnoCellError, sizeof(XmString),

    XtOffsetOf(XmColorSelectorRec, cs.strings.no_cell_error),

    GetValues_XmNnoCellError, NULL

  },

  {

    XmNfileReadError, sizeof(XmString),

    XtOffsetOf(XmColorSelectorRec, cs.strings.file_read_error),

    GetValues_XmNfileReadError, NULL

  }

};

XmColorSelectorClassRec xmColorSelectorClassRec = {

  { /* core fields */

    /* superclass               */      SUPERCLASS,

    /* class_name               */      "XmColorSelector",

    /* widget_size              */      sizeof(XmColorSelectorRec),

    /* class_initialize         */      ClassInitialize,

    /* class_part_initialize    */      ClassPartInitialize,

    /* class_inited             */      False,

    /* initialize               */      Initialize,

    /* initialize_hook          */      NULL,

    /* realize                  */      XtInheritRealize,

    /* actions                  */      NULL,

    /* num_actions              */      (Cardinal)0,

    /* resources                */      (XtResource*)resources,

    /* num_resources            */      XtNumber(resources),

    /* xrm_class                */      NULLQUARK,

    /* compress_motion          */      True,

    /* compress_exposure        */      True,

    /* compress_enterleave      */      True,

    /* visible_interest         */      False,

   /* destroy                  */      Destroy,

    /* resize                   */      Resize,

    /* expose                   */      NULL,

    /* set_values               */      SetValues,

    /* set_values_hook          */      NULL,

    /* set_values_almost        */      XtInheritSetValuesAlmost,

    /* get_values_hook          */      NULL,

    /* accept_focus             */      NULL,

    /* version                  */      XtVersion,

    /* callback_private         */      NULL,

    /* tm_table                 */      XtInheritTranslations,

    /* query_geometry           */      (XtGeometryHandler) QueryGeometry,

    /* display_accelerator      */      XtInheritDisplayAccelerator,

    /* extension                */      NULL,

  },

  {            /* composite_class fields */

    /* geometry_manager   	*/      GeometryHandler,

    /* change_managed     	*/      ChangeManaged,

    /* insert_child       	*/      XtInheritInsertChild,

    /* delete_child       	*/      XtInheritDeleteChild,

    /* extension          	*/      NULL,

  },

  {            /* constraint_class fields */

   /* resource list        	*/ 	NULL,

   /* num resources        	*/ 	0,

   /* constraint size      	*/ 	sizeof(XmColorSelectorConstraintRec),

   /* destroy proc         	*/ 	NULL,

   /* init proc            	*/ 	NULL,

   /* set values proc      	*/ 	NULL,

   /* extension            	*/ 	NULL,

  },

  {            /* manager_class fields */

   /* default translations   	*/      XtInheritTranslations,

   /* syn_resources          	*/      get_resources,

   /* num_syn_resources      	*/      XtNumber(get_resources),

   /* syn_cont_resources     	*/      NULL,

   /* num_syn_cont_resources 	*/      0,

   /* parent_process         	*/      NULL,

   /* extension              	*/      NULL,

  },

  {	      /* color_selector_class fields */

    /* mumble 		  	*/	NULL,

  }

};

WidgetClass xmColorSelectorWidgetClass = (WidgetClass)&xmColorSelectorClassRec;

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

 *       STATIC CODE

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

/*      Function Name: ClassInitialize

 *      Description:   Called to initialize class specific information.

 *      Arguments:     widget_class - the widget class.

 *      Returns:       none.

 */

static void 

ClassInitialize(void)

{

    XmColorSelectorClassRec *wc = &xmColorSelectorClassRec;

    XtSetTypeConverter(XmRString, XmRXmColorMode, 

		       (XtTypeConverter) CvtStringToColorMode, 

		       NULL, (Cardinal) 0, XtCacheAll, NULL);

}

/*

 * ClassPartInitialize sets up the fast subclassing for the widget.

 */

static void 

#ifdef _NO_PROTO

ClassPartInitialize(w_class)

        WidgetClass w_class ;

#else

ClassPartInitialize(WidgetClass w_class)

#endif /* _NO_PROTO */

{

    _XmFastSubclassInit (w_class, XmCOLORSELECTOR_BIT);

}

/*      Function Name: Initialize

 *      Description:   Called to initialize information specific

 *                     to this widget.

 *      Arguments:     request - what was originally requested.

 *                     set - what will be created (our superclasses have

 *                           already mucked with this)

 *                     args, num_args - The arguments passed to

 *                                      the creation call.

 *      Returns:       none.

 */

/* ARGSUSED */

static void 

Initialize(Widget request, Widget set, ArgList args, Cardinal *num_args)

{

    XmColorSelectorWidget	csw = (XmColorSelectorWidget)set;

    Dimension			width, height;

    String 			temp;

    char			message_buffer[BUFSIZ];

    ArgList 			f_args;

    Cardinal 			f_num_args;

    Widget			button;

    _XmFilterArgs(args, *num_args, xm_std_filter, &f_args, &f_num_args);

    /*

     * Initialize important values.

     */

    XmColorS_good_cell(csw) = False;

    temp = XmColorS_color_name(csw);

    XmColorS_color_name(csw) = NULL;

    XmColorS_list(csw) = NULL;

    CreateColorSliders(csw, f_args, f_num_args);

    CreateSelectorRadio(csw, f_args, f_num_args);

    CreateColorWindow(csw, f_args, f_num_args);

    XmColorS_rgb_file(csw) = XtNewString(XmColorS_rgb_file(csw));

    XmColorS_colors(csw) = NULL;

    read_rgb_file(csw, f_args, f_num_args, True);

    if (!color_name_changed(csw, temp)) {

        snprintf(message_buffer, BUFSIZ, XmNunparsableColorMsg, temp);

	XmeWarning((Widget)set, message_buffer);

	(void) color_name_changed(csw, "White");

    }

    slider_changed(NULL, (XtPointer) csw, NULL);

    CalcPreferredSize(csw, &width, &height);

    if ( csw->core.width < 1 )

	csw->core.width = width;

    if ( csw->core.height < 1 )

	csw->core.height = height;

    new_mode(csw, XmColorS_color_mode(csw));

    button = XmColorS_chose_mode(csw)[XmColorS_color_mode(csw)];

    XmToggleButtonSetState(button, True, False);

    XtFree((XtPointer) f_args);

    {

    int i;

    for( i = 0; i < 3; i++ )

    	XmColorS_strings(csw).slider_labels[i] = XmStringCopy(XmColorS_strings(csw).slider_labels[i]);

    for (i = 0; i< XmColorSelector_NUM_TOGGLES; i++) 

	XmColorS_strings(csw).tog_labels[i] = XmStringCopy(XmColorS_strings(csw).tog_labels[i]);

    XmColorS_strings(csw).file_read_error = XmStringCopy(XmColorS_strings(csw).file_read_error);

    XmColorS_strings(csw).no_cell_error = XmStringCopy(XmColorS_strings(csw).no_cell_error); 

    }

}

/*      Function Name: Destroy

 *      Description:   Called to destroy this widget.

 *      Arguments:     w - Color Selector Widget to destroy.

 *      Returns:       none.

 */

/* ARGSUSED */

static void	

Destroy(Widget w)

{

    XmColorSelectorWidget	csw = (XmColorSelectorWidget)w;

    if (XmColorS_good_cell(csw)) {

    	XFreeColors(XtDisplay(csw), csw->core.colormap,

		    &XmColorS_color_pixel(csw), 1, 0);

    }

    XtFree((char*) XmColorS_colors(csw));

    XtFree((char*) XmColorS_color_name(csw));

    XtFree((char*) XmColorS_rgb_file(csw));

    {

    int i;

    for( i = 0; i < 3; i++ ) 

    	XmStringFree(XmColorS_strings(csw).slider_labels[i]);

    for (i = 0; i< XmColorSelector_NUM_TOGGLES; i++) 

	XmStringFree(XmColorS_strings(csw).tog_labels[i]);

    XmStringFree(XmColorS_strings(csw).file_read_error);

    XmStringFree(XmColorS_strings(csw).no_cell_error); 

    }

}

/*      Function Name: Resize

 *      Description:   Called when this widget has been resized.

 *      Arguments:     w - Color Selector Widget to realize.

 *      Returns:       none.

 */

/* ARGSUSED */

static void	

Resize(Widget w)

{

    compute_size((XmColorSelectorWidget)w);

}

static Boolean AreDiff(char *s1, char *s2)

{

	if (s1 && !s2)	return True;

	if (s2 && !s1)	return True;

	if (!s1 && !s2)	return False;

	/* they exist; now safe to do strcmp */

	return strcmp(s1, s2);

}

/*      Function Name: SetValues

 *      Description:   Called when some widget data needs to be modified on-

 *                     the-fly.

 *      Arguments:     current - the current (old) widget values.

 *                     request - before superclassed have changed things.

 *                     set - what will acutally be the new values.

 *                     args, num_args - the arguments in the list.

 *      Returns:       none

 */

/* ARGSUSED */

static Boolean 

SetValues(Widget current, Widget request, Widget set, 

	  ArgList args, Cardinal *num_args)

{

    XmColorSelectorWidget	csw = (XmColorSelectorWidget)set;

    XmColorSelectorWidget	curr = (XmColorSelectorWidget)current;

    /*

     * Pass argument list through to all children.

     */

    {

	ArgList f_args;

	Cardinal f_num_args;

	_XmFilterArgs(args, *num_args, xm_std_filter, &f_args, &f_num_args);

	_XmSetValuesOnChildren(set, f_args, f_num_args);

	XtFree((XtPointer) f_args);

    }

    if (XmColorS_color_mode(curr) != XmColorS_color_mode(csw))

    {

	new_mode(csw, XmColorS_color_mode(csw));

	XmToggleButtonSetState(XmColorS_chose_mode(csw)[XmColorS_color_mode(csw)],

			       True, True);

    }

    /* 

    ** Don't compare pointers; they are allocated, so passing the same file

    ** in twice will trip this expensive function unless we compare the 

    ** values of the strings (when they exist)

    */

    if (AreDiff(XmColorS_rgb_file(curr), XmColorS_rgb_file(csw)))

    {

	read_rgb_file(csw, NULL, 0, False);

    }

    if (XmColorS_rgb_file(curr) != XmColorS_rgb_file(csw))

    {

    	XtFree((char*) XmColorS_rgb_file(curr));

        XmColorS_rgb_file(csw) = XtNewString(XmColorS_rgb_file(csw));

    }

    if ((XmColorS_margin_height(curr) != XmColorS_margin_height(csw)) ||

	(XmColorS_margin_width(curr) != XmColorS_margin_width(csw)))

    {

	compute_size(csw);

    }

    if (XmColorS_color_name(curr) != XmColorS_color_name(csw))

    {

	String		oldValue;	/* old color name, will free. */

	String		newValue;	/* new color name, allocate   */

	char            string_buffer[BUFSIZ];

	oldValue = XmColorS_color_name(curr);

	newValue = XmColorS_color_name(csw);

	if (!streq(newValue, oldValue)) 

	{

	    /*

	     * Color name changed will automatically free the old 

	     * value on success...

	     */

	    XmColorS_color_name(csw) = oldValue; /* so it free's the right thing. */

	    if (!color_name_changed(csw, newValue)) {

		snprintf(string_buffer, BUFSIZ, XmNunparsableColorMsg, newValue);

		XmeWarning(set, string_buffer);

		XmColorS_color_name(csw) = oldValue;

	    }

	}

	else {

	    XtFree(oldValue);

	    XmColorS_color_name(csw) = XtNewString(newValue);

	}

    }

    {

    int i;

    for( i = 0; i < 3; i++ )

	{

    	if (XmColorS_strings(curr).slider_labels[i] != XmColorS_strings(csw).slider_labels[i])

		{

		XmStringFree(XmColorS_strings(curr).slider_labels[i]);

    		XmColorS_strings(csw).slider_labels[i] = XmStringCopy(XmColorS_strings(csw).slider_labels[i]);

		XtVaSetValues(XmColorS_sliders(csw)[i], XmNtitleString, XmColorS_strings(csw).slider_labels[i], NULL); 

		}

	}

    for (i = 0; i< XmColorSelector_NUM_TOGGLES; i++) 

	{

	if (XmColorS_strings(curr).tog_labels[i] != XmColorS_strings(csw).tog_labels[i])

		{

		XmStringFree(XmColorS_strings(curr).tog_labels[i]);

		XmColorS_strings(csw).tog_labels[i] = XmStringCopy(XmColorS_strings(csw).tog_labels[i]);

		XtVaSetValues(XmColorS_chose_mode(csw)[i], XmNlabelString, XmColorS_strings(csw).tog_labels[i], NULL);

		}

	}

	if (XmColorS_strings(curr).file_read_error != XmColorS_strings(csw).file_read_error)

	{

		XmStringFree(XmColorS_strings(curr).file_read_error);

		XmColorS_strings(csw).file_read_error = XmStringCopy(XmColorS_strings(csw).file_read_error);

	}

	if (XmColorS_strings(curr).no_cell_error != XmColorS_strings(csw).no_cell_error)

	{

		XmStringFree(XmColorS_strings(curr).no_cell_error);

		XmColorS_strings(csw).no_cell_error = XmStringCopy(XmColorS_strings(csw).no_cell_error);

	}

    }

    return FALSE;

}

/*      Function Name: GeometryHandler

 *      Description:   handles request from children for size changes.

 *      Arguments:     child - the child to change.

 *                     request - desired geometry of child.

 *                     result - what will be allowed if almost.

 *      Returns:       status.

 */

/* ARGSUSED */

static XtGeometryResult

GeometryHandler(Widget w, XtWidgetGeometry *request, XtWidgetGeometry *result)

{

    return(XtGeometryNo);

}

/*	Function Name: QueryGeometry

 *	Description:   Called when my parent wants to know what size

 *                     I would like to be.

 *	Arguments:     w - the widget to check.

 *                     indended - constriants imposed by the parent.

 *                     preferred - what I would like.

 *	Returns:       See Xt Manual.

 */

static XtGeometryResult 

QueryGeometry(Widget w,XtWidgetGeometry *intended, XtWidgetGeometry *preferred)

{

    CalcPreferredSize((XmColorSelectorWidget) w, 

		      &(preferred->width), &(preferred->height));

    return(_XmHWQuery(w, intended, preferred));

}

/*	Function Name: ChangeManaged

 *	Description: Called when a management change happens.

 *	Arguments: w - the csw widget.

 *	Returns: none

 */

static void

ChangeManaged(Widget w)

{

    compute_size((XmColorSelectorWidget) w);

    XmeNavigChangeManaged(w);

}

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

 * Type Converters.

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

/*      Function Name: 	CvtStringToColorMode

 *      Description:   	Converts a string to a ColorMode

 *      Arguments:     	dpy - the X Display.

 *                     	args, num_args - *** NOT USED ***

 *                     	from - contains the string to convert.

 *                     	to - contains the converted node state.

 *                      junk - *** NOT USED *** .

 *      Returns:       	

 */

/* ARGSUSED */

static Boolean

CvtStringToColorMode(Display *dpy, XrmValuePtr args, Cardinal num_args, 

		     XrmValuePtr from, XrmValuePtr to, XtPointer * junk)

{

    static XmColorMode	mode;

    char		lowerName[BUFSIZ];

    XmCopyISOLatin1Lowered(lowerName, (char *)from->addr);

    if (streq(lowerName, "listmode"))

	mode = XmListMode;

    else if (streq(lowerName, "scalemode"))

	mode = XmScaleMode;

    else {

        XtDisplayStringConversionWarning(dpy, from->addr, XmRXmColorMode);

        return(False);          /* Conversion failed. */

    }

    to->size = sizeof(XmColorMode);

    if ( to->addr == NULL ) {

        to->addr = (XtPointer)&mode;

        return(True);

    }

    else if ( to->size >= sizeof(XmColorMode) ) {

	XmColorMode *state = (XmColorMode *) to->addr;

	*state = mode;

	return(True);

    }

    return(False);

}

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

 *      LOCAL CODE

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

/*	Function Name: CalcPreferredSize

 *	Description: Calculates the size this widget would prefer to be.

 *	Arguments: csw - the color selector widget.

 *  RETURNED       width, height - preferred size of the color selector.

 *	Returns: none.

 */

static void 

CalcPreferredSize(XmColorSelectorWidget csw, 

		  Dimension *width, Dimension *height)

{

    XtWidgetGeometry geo;

    Widget *childP;

    *height = *width = 0;

    ForAllChildren(csw, childP) {	

	if (*childP == XmColorS_bb(csw))

	    continue;

	(void)XtQueryGeometry(*childP, NULL, &geo;;

	ASSIGN_MAX(*width, (geo.width + (2 * geo.border_width)));

	geo.height += 2 * geo.border_width;

	if ( *childP == XtParent(XmColorS_color_window(csw)) )

	    continue;

	else if ( *childP == XmColorS_scrolled_list(csw) )	

	    *height += (int)(4 * geo.height)/3;

	else

	    *height += geo.height;

	*height += XmColorS_margin_height(csw);

    }

    *width += 2 * XmColorS_margin_width(csw);

    *height += 2 * XmColorS_margin_height(csw);

}

/*      Function Name: 	color_name_changed

 *      Description:   	Change in the color name string.

 *      Arguments:     	csw - the color selector widget.

 *                     	name - the color name.

 *      Returns:       	True if successful

 */

/* ARGSUSED */

static Boolean

color_name_changed(XmColorSelectorWidget csw, char *name)

{

    String old_val = XmColorS_color_name(csw);

    if ( name == NULL ) {

	XmColorS_color_name(csw) = NULL;

	XtFree((XtPointer) old_val);

	return(True);

    }

    XmColorS_color_name(csw) = XtNewString(name);

    if (!UpdateColorWindow(csw, True)) {

	XtFree((XtPointer) XmColorS_color_name(csw));

	XmColorS_color_name(csw) = old_val;

	return(False);

    }

    SetSliders(csw);

    SelectColor(csw);

    XtFree((XtPointer) old_val);

    return(True);

}

/*	Function Name: SetSliders

 *	Description: Sets the values in the color sliders.

 *	Arguments: csw - the color selector widget.

 *	Returns: none

 */

static void

SetSliders(XmColorSelectorWidget csw)

{

    static Arg args[] = {

	{ XmNvalue, (XtArgVal) NULL },

    };

    args[0].value = (XtArgVal) XmColorS_slider_red(csw);

    XtSetValues(XmColorS_sliders(csw)[0], args, XtNumber(args));

    args[0].value = (XtArgVal) XmColorS_slider_green(csw);

    XtSetValues(XmColorS_sliders(csw)[1], args, XtNumber(args));

    args[0].value = (XtArgVal) XmColorS_slider_blue(csw);

    XtSetValues(XmColorS_sliders(csw)[2], args, XtNumber(args));

}

/*	Function Name: SelectColor

 *	Description: Selects the color in the list that corrosponds

 *                   to the current values of the RGB sliders.

 *	Arguments: csw - the color selector widget.

 *	Returns: none.

 */

static void 

SelectColor(XmColorSelectorWidget csw)

{

    int color_num;

    if (FindColor(csw, &color_num)) {

	XmListSelectPos(XmColorS_list(csw), color_num + 1, False);

	XmListSetBottomPos(XmColorS_list(csw), color_num + 1);

    }

    else

	XmListDeselectAllItems(XmColorS_list(csw));

}

/*	Function Name:	EndsInDigits

 *	Description:	Determines if a string ends in a digit

 *	Returns:	True if it does

 */

static int

EndsInDigits(char *str)

{

    register char *c = str;

    while(*c != '\0') c++;	/* advance to end of string marker */

    c--;			/* back to the last character */

    if(c >= str && isascii(*c) && isdigit(*c)) 

	return True;

    return False;

}

/*	Function Name: FindColor

 *	Description: Finds the index into the colors array associated with

 *                   the current slider values.  Attempts to find the slot

 *		     with a the best matching name.

 *	Arguments: csw - The color selector widget.

 * RETURNED        color_num - The color index that was found. 

 *	Returns: True if color was found, false otherwise.

 *

 * NOTE: if False is returned then color_num has an undefined value.

 */

static Boolean

FindColor(XmColorSelectorWidget csw, int *color_num)

{

    register ColorInfo *ptr;

    register int i, red, green, blue;

    /*

     * Obtain the color settings from the ColorSelector

     * data structure

     */

    red = XmColorS_slider_red(csw);

    green = XmColorS_slider_green(csw);

    blue = XmColorS_slider_blue(csw);

    ptr = XmColorS_colors(csw);