/*
* 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/share/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);
/*
* Flag for finding color value
*/
*color_num = -1;
/*
* Find color within the exisiting colormap assigned to
* ColorSelector
*/
for (i = 0; i < XmColorS_num_colors(csw); i++, ptr++)
{
if ((ptr->red == red) && (ptr->green == green) && (ptr->blue == blue))
{
if( *color_num < 0 )
*color_num = i;
/* Only change the selected color if it is better in some way */
if(XmColorS_color_name(csw)) {
if(XmColorS_color_name(csw)[0] == '#')
*color_num = i;
if(streq(XmColorS_color_name(csw), ptr->name) ||
streq(XmColorS_color_name(csw), ptr->no_space_lower_name))
{
*color_num = i;
return(True);
}
}
if(! EndsInDigits(ptr->name)) {
*color_num = i;
return(True);
}
}
}
return(*color_num >= 0);
}
/* Function Name: slider_changed
* Description: One of the sliders was pressed
* Arguments: w - the slider widget.
* csw - the color selector.
* scale - the scale widget callback struct.
* Returns: none.
*/
/* ARGSUSED */
static void
slider_changed(Widget w, XtPointer csw_ptr, XtPointer scale_ptr)
{
XmColorSelectorWidget csw = (XmColorSelectorWidget) csw_ptr;
XmScaleCallbackStruct *scale = (XmScaleCallbackStruct *) scale_ptr;
if (scale_ptr != NULL) { /* Set a new value. */
if (w == XmColorS_sliders(csw)[0])
XmColorS_slider_red(csw) = scale->value;
else if(w == XmColorS_sliders(csw)[1])
XmColorS_slider_green(csw) = scale->value;
else if(w == XmColorS_sliders(csw)[2])
XmColorS_slider_blue(csw) = scale->value;
}
UpdateColorWindow(csw, False);
}
/* Function Name: UpdateColorWindow
* Description: Updates the color window display.
* Arguments: csw - the color selector widget.
* use_name - if TRUE then use the color name to update.
* if FALSE then use the color sliders to update.
* Returns: True if successful
*/
static Boolean
UpdateColorWindow(XmColorSelectorWidget csw, Boolean use_name)
{
int index;
XColor color;
Pixel foreground;
char buf[XmColorSelector_COLOR_NAME_SIZE], new_label[BUFSIZ];
if (!use_name) /* Update color names */
{
char *freeMe;
freeMe = XmColorS_color_name(csw);
sprintf(buf, "#%02x%02x%02x", XmColorS_slider_red(csw),
XmColorS_slider_green(csw), XmColorS_slider_blue(csw));
if (FindColor(csw, &index))
{
XmColorS_color_name(csw) = XtNewString(XmColorS_colors(csw)[index].name);
sprintf(new_label, "%s (%s)", XmColorS_color_name(csw), buf);
}
else
{
XmColorS_color_name(csw) = XtNewString(buf);
sprintf(new_label, "%s", buf);
}
XtFree((XtPointer)freeMe );
color.red = XmColorS_slider_red(csw) * 256;
color.green = XmColorS_slider_green(csw) * 256;
color.blue = XmColorS_slider_blue(csw) * 256;
}
else /* Update color slider */
{
if(XParseColor(XtDisplay(csw), csw->core.colormap,
XmColorS_color_name(csw), &color) == 0)
{
return(False);
}
XmColorS_slider_red(csw) = color.red / 256;
XmColorS_slider_green(csw) = color.green / 256;
XmColorS_slider_blue(csw) = color.blue / 256;
/*
* Attempt to replace a name that begins with a # with a real color
* name.
*/
if ((XmColorS_color_name(csw)[0] == '#') && FindColor(csw, &index))
{
XtFree(XmColorS_color_name(csw));
XmColorS_color_name(csw) = XtNewString(XmColorS_colors(csw)[index].name);
}
sprintf(buf, "#%02x%02x%02x", color.red/256, color.green/256, color.blue/256);
sprintf(new_label, "%s (%s)", XmColorS_color_name(csw), buf);
}
{
long test = (long) color.red;
test += (long) color.green;
test += (long) color.blue;
if (test/3 > 0x7000)
{
foreground = BlackPixelOfScreen(XtScreen((Widget) csw));
}
else
{
foreground = WhitePixelOfScreen(XtScreen((Widget) csw));
}
}
/*
* Check on the default visual
*/
if (DefaultVisualDisplay(csw, foreground, color, (char *)new_label))
{
return True;
} else
{
return False;
}
}
/* Function Name: list_selected
* Description: One of the list widgets was selected.
* Arguments: w - the slider widget.
* csw - the color selector.
* list - the list widget callback struct.
* Returns: none.
*/
/* ARGSUSED */
static void
list_selected(Widget w, XtPointer csw_ptr, XtPointer list_ptr)
{
XmColorSelectorWidget csw = (XmColorSelectorWidget) csw_ptr;
XmListCallbackStruct *list = (XmListCallbackStruct *) list_ptr;
XtFree(XmColorS_color_name(csw));
XmColorS_color_name(csw) =
XmStringUnparse(list->item,
NULL, XmCHARSET_TEXT, XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL);
/* deprecated
XmStringGetLtoR(list->item, XmFONTLIST_DEFAULT_TAG,
&(XmColorS_color_name(csw)));
*/
UpdateColorWindow(csw, True);
}
/* Function Name: change_mode
* Description: One of the change mode buttons was pressed.
* Arguments: w - the slider widget.
* csw_ptr - the color selector.
* tp - the toggle widget callback struct.
* Returns: none.
*/
/* ARGSUSED */
static void
change_mode(Widget w, XtPointer csw_ptr, XtPointer tp)
{
XmColorSelectorWidget csw = (XmColorSelectorWidget) csw_ptr;
XmToggleButtonCallbackStruct *toggle = (XmToggleButtonCallbackStruct *) tp;
/*
* Ignore unsets.
*/
if (toggle->reason == XmCR_VALUE_CHANGED && toggle->set) {
/*
* Change the mode if it is different.
*/
if ((w == XmColorS_chose_mode(csw)[XmListMode]) &&
(XmColorS_color_mode(csw) != XmListMode))
{
new_mode(csw, XmListMode);
}
else if ((w == XmColorS_chose_mode(csw)[XmScaleMode]) &&
(XmColorS_color_mode(csw) != XmScaleMode))
{
new_mode(csw, XmScaleMode);
}
}
}
/* Function Name: new_mode
* Description: mode has changed
* Arguments: csw - the color selector.
* mode - the new mode.
* Returns: none.
*/
/* ARGSUSED */
static void
new_mode(XmColorSelectorWidget csw, XmColorMode mode)
{
XmColorS_color_mode(csw) = mode;
if (mode == XmScaleMode) {
SetSliders(csw);
XtUnmanageChild(XmColorS_scrolled_list(csw));
XtManageChild(XmColorS_bb(csw));
}
else {
SelectColor(csw); /* Select the current color in the list. */
XtUnmanageChild(XmColorS_bb(csw));
XtManageChild(XmColorS_scrolled_list(csw));
}
}
/* Function Name: compute_size
* Description: Do all the size and position computing.
* Arguments: csw - the color selector.
* Returns: none.
*/
/* ARGSUSED */
static void
compute_size(XmColorSelectorWidget csw)
{
XtWidgetGeometry input, radio_geom, color_geom;
Dimension width, height;
Position x,y; /* positions */
/*
* First size and place the button box and scrolled list.
*/
y = XmColorS_margin_height(csw);
x = XmColorS_margin_width(csw);
width = csw->core.width - (2 * XmColorS_margin_width(csw));
input.width = width;
input.request_mode = CWWidth;
(void) XtQueryGeometry(XmColorS_chose_radio(csw), NULL, &radio_geom);
(void) XtQueryGeometry(XmColorS_color_window(csw), &input, &color_geom);
height = (csw->core.height - 4 * XmColorS_margin_height(csw) -
(radio_geom.height + 2 * radio_geom.border_width));
/*
* Leave space for the margins and make the color area 1/3 the height
* of the scrolled list and button box.
*/
color_geom.height = height / 4;
height -= color_geom.height;
color_geom.height -= 2 * color_geom.border_width;
_XmConfigureWidget(XmColorS_bb(csw), x, y, width, height, 0);
_XmConfigureWidget(XmColorS_scrolled_list(csw), x, y, width, height, 0);
y += height + XmColorS_margin_height(csw);
/*
* Place the radio box.
*/
if ( radio_geom.width < csw->core.width )
x = (int)(csw->core.width - radio_geom.width) / 2;
else
x = XmColorS_margin_width(csw);
_XmConfigureWidget(XmColorS_chose_radio(csw), x, y, radio_geom.width,
radio_geom.height, radio_geom.border_width);
y += radio_geom.height + XmColorS_margin_height(csw);
/*
* Lastly, place the color window
*/
_XmConfigureWidget(XtParent(XmColorS_color_window(csw)), XmColorS_margin_width(csw), y,
width, color_geom.height, color_geom.border_width);
}
/* Function Name: read_rgb_file
* Description: Read in all the color names and add them to the list.
* Arguments: csw - the color selector.
* cargs, cnum_args - a filtered arg list that was
* passed to create the color selector.
* Returns: none.
*/
/* ARGSUSED */
static void
read_rgb_file(XmColorSelectorWidget csw, ArgList cargs, Cardinal cnum_args, Boolean initial)
{
FILE *file;
char buf[BUFSIZ];
char string_buffer[BUFSIZ];
char *color_name;
ColorInfo * color_info = NULL;
register int i;
Arg *margs, args[20];
/*
* Create new list if needed, or delete any old list items.
*/
if (XmColorS_list(csw) == NULL)
{
i = 0;
XtSetArg(args[i], XmNlistSizePolicy, XmCONSTANT); i++;
XtSetArg(args[i], XmNvisibleItemCount, 15); i++;
margs = XtMergeArgLists(args, i, cargs, cnum_args);
XmColorS_list(csw) = XmCreateScrolledList((Widget) csw, "list",
margs, i + cnum_args);
XtManageChild(XmColorS_list(csw));
XmColorS_scrolled_list(csw) = XtParent(XmColorS_list(csw));
if (XmColorS_color_mode(csw) != XmListMode)
{
/* Hide the scrolled list until it need be visible... */
XtUnmanageChild(XmColorS_scrolled_list(csw));
}
XtFree((XtPointer) margs);
}
else
{
XmListDeleteAllItems(XmColorS_list(csw));
}
/*
** Because of the internal functioning of the XmList, it is better to
** zero out the selected item list rather than to let the item currently
** selected be re-selected by the XmList when the new list of colors is
** assigned. As is, the XmList iteratively searches through the list of
** selected items for each item added. Resetting the selectedItem list to
** NULL/0 ensures that we don't have O(n*m) XmStringCompare operations
** done when setting the new list below.
** Also, resetting the list saves us in the case in which the rgb_file
** is invalid or doesn't contain this selected string.
*/
XtVaSetValues(XmColorS_list(csw),
XmNselectedItems, NULL, XmNselectedItemCount, 0, NULL);
/*
* Read in all the colornames.
*/
if ((file = fopen(XmColorS_rgb_file(csw), "r")) != NULL) {
register int alloc, count, len;
register char *name;
alloc = count = 0;
while(fgets(buf, BUFSIZ, file)) {
/*
* Skip any comment lines in the file
*/
if ( buf[0] == '!' ) continue;
if (count >= alloc) {
if (0 == alloc)
alloc = 755; /* rather than stat the file and determine a good value to use, just use enough for X11R5, X11R6, and OpenWindows3 */
else
{
#define ALLOC_INC 20
alloc += ALLOC_INC;
}
color_info = (ColorInfo *)XtRealloc((XtPointer) color_info,
sizeof(ColorInfo) * alloc);
}
sscanf(buf, "%hu %hu %hu", &(color_info[count].red),
&(color_info[count].green), &(color_info[count].blue));
if ((color_name = find_name(buf)) == NULL)
continue;
len = strlen(color_name);
if (len > XmColorSelector_COLOR_NAME_SIZE) {
color_name[XmColorSelector_COLOR_NAME_SIZE - 1] = '\0';
snprintf(string_buffer, BUFSIZ,
XmNcolorNameTooLongMsg, buf, color_name);
XmeWarning((Widget)csw, string_buffer);
}
name = color_info[count].no_space_lower_name;
for (i = 0; i < len; i++) {
register char c = color_name[i];
/*
* Copy in all characters that are ascii and non-spaces.
*/
if (!isascii(c))
continue;
if (!isspace(c))
*name++ = tolower(c);
}
*name = '\0';
name = color_info[count].name;
color_name[0] = toupper(color_name[0]);
for (i = 0; i < len; i++) {
register char c = color_name[i];
/*
* Capitalize all characters after a space.
*/
if (!isascii(c))
continue;
if (isspace(c) && ((i + 1) < len)) {
color_name[i + 1] = toupper(color_name[i + 1]);
}
*name++ = c;
}
*name = '\0';
count++;
}
fclose(file);
qsort(color_info, count, sizeof(ColorInfo), CmpColors);
/*
* Remove duplicates.
*/
i = 0;
while (i < (count - 1)) {
if (streq(color_info[i].no_space_lower_name,
color_info[i + 1].no_space_lower_name))
{
register int j;
register ColorInfo *ptr;
ptr = color_info + i;
j = i;
/*
* This makes sure that the one with the space is
* left in place in favor of the one without.
*/
if (strchr(ptr->name, ' ') != NULL) {
j++;
ptr++;
}
while ( ++j < count) {
ptr[0] = ptr[1];
ptr++;
}
count--; /*Something has been removed, decrement count*/
}
else
i++;
}
{
XmString *strs = (XmString*)XtMalloc(sizeof(XmString)*count);
for (i = 0; i < count; i++)
strs[i] = XmStringCreateLocalized(color_info[i].name);
XtVaSetValues(XmColorS_list(csw),
XmNitems, strs,
XmNitemCount, count,
NULL);
for (i = 0; i < count; i++)
XmStringFree(strs[i]);
XtFree((char*)strs);
}
XtFree((char*)XmColorS_colors(csw));
XmColorS_colors(csw) = color_info;
XmColorS_num_colors(csw) = count;
/* It would be better if we had cached the current index number so
** we could just reset the list to the string corresponding to that
** value, but instead wind up going through FindColor to reestablish
** the selected string
*/
if (!initial)
SelectColor(csw);
}
else {
XmString str;
XmListAddItem(XmColorS_list(csw), XmColorS_strings(csw).file_read_error, 0);
str = XmStringCreateLocalized(XmColorS_rgb_file(csw));
XmListAddItem(XmColorS_list(csw), str, 0);
XmStringFree(str);
XtFree((char*)XmColorS_colors(csw));
XmColorS_colors(csw) = NULL;
XmColorS_num_colors(csw) = 0;
}
XtAddCallback(XmColorS_list(csw), XmNsingleSelectionCallback,
list_selected, csw);
XtAddCallback(XmColorS_list(csw), XmNbrowseSelectionCallback,
list_selected, csw);
}
/* Function Name: CmpColors
* Description: Compares two colors.
* Arguments: ptr_1, ptr_2 - two colors too compare.
* Returns: none
*/
static int
CmpColors(const void * ptr_1, const void * ptr_2)
{
ColorInfo *color1, *color2;
color1 = (ColorInfo *) ptr_1;
color2 = (ColorInfo *) ptr_2;
return(strcmp(color1->no_space_lower_name, color2->no_space_lower_name));
}
/* Function Name: find_name
* Description: Go through the buffer for looking for the name
* of a color string.
* Arguments: buffer - list of color names.
* Returns: pointer in the buffer where the string begins.
*/
static char*
find_name(char *buffer)
{
register char *curr, *temp; /* current pointer */
for (curr = buffer; curr != NULL && *curr != '\0'; curr++) {
/*
* Look for first non number, non space or tab.
*/
if (isascii(*curr) && (isdigit(*curr) || isspace(*curr)))
continue;
temp = (char *) strchr(curr, '\n');
*temp = '\0';
return(curr);
}
return(NULL);
}
/* Function Name: CreateColorSliders
* Description: creates a button with three sliders (Red, Green, Blue).
* Arguments: csw - the color selector widget.
* cargs, cnum_args - a filtered arg list that was
* passed to create the color selector.
* Returns: none.
*/
/* ARGSUSED */
static void
CreateColorSliders(XmColorSelectorWidget csw,
ArgList cargs, Cardinal cnum_args)
{
register int i;
Cardinal num_args, title;
Arg *margs, args[10];
num_args = 0;
XtSetArg(args[num_args], XmNborderWidth, 0); num_args++;
XtSetArg(args[num_args], XmNorientation, XmVERTICAL); num_args++;
XtSetArg(args[num_args], XmNfillOption, XmFillMinor); num_args++;
margs = XtMergeArgLists(args, num_args, cargs, cnum_args);
XmColorS_bb(csw) = XtCreateManagedWidget("buttonBox", xmButtonBoxWidgetClass,
(Widget) csw,
margs, cnum_args + num_args);
XtFree((XtPointer) margs);
num_args = 0;
XtSetArg(args[num_args], XmNmaximum, 255); num_args++;
XtSetArg(args[num_args], XmNorientation, XmHORIZONTAL); num_args++;
XtSetArg(args[num_args], XmNshowValue, True); num_args++;
XtSetArg(args[num_args], XmNprocessingDirection, XmMAX_ON_RIGHT);
num_args++;
XtSetArg(args[num_args], XmNtitleString, NULL); title = num_args++;
margs = XtMergeArgLists(args, num_args, cargs, cnum_args);
for( i = 0; i < 3; i++ ) {
margs[title].value = (XtArgVal) XmColorS_strings(csw).slider_labels[i];
XmColorS_sliders(csw)[i] = XtCreateManagedWidget("scale",
xmScaleWidgetClass,
XmColorS_bb(csw), margs,
num_args + cnum_args);
XtAddCallback(XmColorS_sliders(csw)[i], XmNdragCallback,
slider_changed, csw);
XtAddCallback(XmColorS_sliders(csw)[i], XmNvalueChangedCallback,
slider_changed, csw);
}
XtFree((XtPointer) margs);
}
/* Function Name: CreateSelectorRadio
* Description: creates a radio box with two toggles for selector
* type.
* Arguments: csw - the color selector widget.
* cargs, cnum_args - a filtered arg list that was
* passed to create the color selector.
* Returns: none.
*/
/* ARGSUSED */
static void
CreateSelectorRadio(XmColorSelectorWidget csw,
ArgList cargs, Cardinal cnum_args)
{
Widget w;
Cardinal i, label;
Arg *margs, args[5];
int count;
static String names[] = { "colorListToggle", "colorSlidersToggle" };
i = 0;
XtSetArg(args[i], XmNradioBehavior, True); i++;
XtSetArg(args[i], XmNpacking, XmPACK_COLUMN); i++;
XtSetArg(args[i], XmNnumColumns, 2); i++;
margs = XtMergeArgLists(args, i, cargs, cnum_args);
w = XtCreateManagedWidget("radioBox", xmRowColumnWidgetClass,
(Widget) csw, margs, i + cnum_args);
XmColorS_chose_radio(csw) = w;
XtFree((XtPointer) margs);
i = 0;
XtSetArg(args[i], XmNlabelString, NULL); label = i++;
margs = XtMergeArgLists(args, i, cargs, cnum_args);
for (count = 0; count < XmColorSelector_NUM_TOGGLES; count++) {
margs[label].value = (XtArgVal) XmColorS_strings(csw).tog_labels[count];
w = XtCreateManagedWidget(names[count], xmToggleButtonWidgetClass,
XmColorS_chose_radio(csw), margs, i + cnum_args);
XmColorS_chose_mode(csw)[count] = w;
XtAddCallback(w, XmNvalueChangedCallback, change_mode, csw);
}
XtFree((XtPointer) margs);
}
/* Function Name: CreateColorWindow
* Description: creates a label in a frame to display the
* currently selected color.
* Arguments: csw - the color selector widget.
* cargs, cnum_args - a filtered arg list that was
* passed to create the color selector.
* Returns: none.
*/
/* ARGSUSED */
static void
CreateColorWindow(XmColorSelectorWidget csw,ArgList cargs, Cardinal cnum_args)
{
Widget fr;
Arg *margs, args[10];
Cardinal n;
fr = XtCreateManagedWidget("colorFrame", xmFrameWidgetClass,
(Widget) csw, cargs, cnum_args);
n = 0;
XtSetArg(args[n], XmNrecomputeSize, False); n++;
margs = XtMergeArgLists(args, n, cargs, cnum_args);
XmColorS_color_window(csw) = XtCreateManagedWidget("colorWindow",
xmLabelWidgetClass,
fr, margs, n + cnum_args);
XtFree((XtPointer) margs);
}
/* ARGSUSED */
static void GetValues_XmNredSliderLabel ( Widget w, int n, XtArgVal *value)
{
(*value) = (XtArgVal) XmStringCopy(XmColorS_strings(w).slider_labels[0]);
}
/* ARGSUSED */
static void GetValues_XmNgreenSliderLabel( Widget w, int n, XtArgVal *value)
{
(*value) = (XtArgVal) XmStringCopy(XmColorS_strings(w).slider_labels[1]);
}
/* ARGSUSED */
static void GetValues_XmNblueSliderLabel( Widget w, int n, XtArgVal *value)
{
(*value) = (XtArgVal) XmStringCopy(XmColorS_strings(w).slider_labels[2]);
}
/* ARGSUSED */
static void GetValues_XmNcolorListTogLabel( Widget w, int n, XtArgVal *value)
{
(*value) = (XtArgVal) XmStringCopy(XmColorS_strings(w).tog_labels[0]);
}
/* ARGSUSED */
static void GetValues_XmNsliderTogLabel( Widget w, int n, XtArgVal *value)
{
(*value) = (XtArgVal) XmStringCopy(XmColorS_strings(w).tog_labels[1]);
}
/* ARGSUSED */
static void GetValues_XmNnoCellError( Widget w, int n, XtArgVal *value)
{
(*value) = (XtArgVal) XmStringCopy(XmColorS_strings(w).no_cell_error);
}
/* ARGSUSED */
static void GetValues_XmNfileReadError( Widget w, int n, XtArgVal *value)
{
(*value) = (XtArgVal) XmStringCopy(XmColorS_strings(w).file_read_error);
}
/* Function Name: GetVisual
* Description: Gets the defaults visual of the screen
* Arguments: csw - the color selector widget.
* Returns: Visual id.
*/
/* ARGSUSED */
static int
GetVisual(XmColorSelectorWidget csw)
{
Visual * vis;
int visual;
vis = DefaultVisual(XtDisplay(csw), XDefaultScreen(XtDisplay(csw)));
visual = vis->class;
return visual;
}
/* Function Name: NoPrivateColormaps
* Description: Determines the color to be used.
* Arguments: csw - the color selector widget.
* foreground - default color for the ColorSelector.
* color - Current color attributes.
* str - label for the ColorSelector.
* Returns: None.
*/
/* ARGSUSED */
static void
NoPrivateColormaps(XmColorSelectorWidget csw, Pixel foreground,
XColor color, char *str)
{
Arg args[5];
XmString xm_str;
Cardinal num_args;
xm_str = XmStringCreateLocalized(str);
num_args = 0;
if (!XmColorS_good_cell(csw))
{
if(XAllocColor(XtDisplay(csw), csw->core.colormap, &color) )
{
XmColorS_color_pixel(csw) = color.pixel;
XmColorS_good_cell(csw) = True;
}
} else {
if (XAllocColor(XtDisplay(csw), csw->core.colormap, &color) )
{
XmColorS_color_pixel(csw) = color.pixel;
XmColorS_good_cell(csw) = True;
}
else
{
XmString out;
out = XmStringConcatAndFree(xm_str, XmColorS_strings(csw).no_cell_error);
xm_str = out;
}
}
if (XmColorS_good_cell(csw))
{
color.flags = DoRed | DoGreen | DoBlue;
color.pixel = XmColorS_color_pixel(csw);
XtSetArg(args[num_args], XmNforeground, foreground); num_args++;
XtSetArg(args[num_args], XmNbackground, XmColorS_color_pixel(csw));
num_args++;
XtSetValues(XmColorS_color_window(csw), args, num_args);
}
XtSetArg(args[num_args], XmNlabelString, xm_str); num_args++;
XtSetValues(XmColorS_color_window(csw), args, num_args);
XmStringFree(xm_str);
}
/* Function Name: DoPrivateColormaps
* Description: Determines the color to be used.
* Arguments: csw - the color selector widget.
* foreground - default color for the ColorSelector.
* color - Current color attributes.
* str - label for the ColorSelector.
* Returns: None.
*/
/* ARGSUSED */
static void
PrivateColormaps(XmColorSelectorWidget csw, Pixel foreground, XColor color, char *str)
{
Arg args[5];
XmString xm_str;
Cardinal num_args;
xm_str = XmStringCreateLocalized(str);
num_args = 0;
if (!XmColorS_good_cell(csw)) {
if(XAllocColorCells(XtDisplay(csw), csw->core.colormap,
0, 0, 0, &(XmColorS_color_pixel(csw)), 1))
{
XmColorS_good_cell(csw) = True;
}
else {
XmString out;
out = XmStringConcatAndFree(xm_str, XmColorS_strings(csw).no_cell_error);
xm_str = out;
}
}
if (XmColorS_good_cell(csw)) {
color.flags = DoRed | DoGreen | DoBlue;
color.pixel = XmColorS_color_pixel(csw);
XStoreColor(XtDisplay((Widget) csw), csw->core.colormap, &color);
XtSetArg(args[num_args], XmNforeground, foreground); num_args++;
XtSetArg(args[num_args], XmNbackground, XmColorS_color_pixel(csw));
num_args++;
}
XtSetArg(args[num_args], XmNlabelString, xm_str); num_args++;
XtSetValues(XmColorS_color_window(csw), args, num_args);
XmStringFree(xm_str);
}
/*
* Function Name: DefaultVisualDisplay
* Description: Determines the default visual and allocates
* the color depending upon the visual classes
* Arguments: csw - the color selector widget.
* foreground - default color for the ColorSelector.
* color - Current color attributes.
* str - label for the ColorSelector.
* Returns: Returns true on a valid visual class.
* False otherwise.
*/
/* ARGSUSED */
static Boolean
DefaultVisualDisplay(XmColorSelectorWidget csw, Pixel foreground, XColor color, char *str)
{
int visual = 0;
visual = GetVisual(csw);
/*
* Obtain a valid color cell. In case, if one not available
*/
if ( visual == StaticColor || visual == TrueColor || \
visual == StaticGray )
{
NoPrivateColormaps(csw, foreground, color, str);
return True;
} else if ( visual == PseudoColor || visual == DirectColor || \
visual == GrayScale )
{
PrivateColormaps(csw, foreground, color, str);
return True;
} else
{
return False;
}
}
/************************************************************
*
* Public functions.
*
************************************************************/
/* Function Name: XmCreateColorSelector
* Description: Creation Routine for UIL and ADA.
* Arguments: parent - the parent widget.
* name - the name of the widget.
* args, num_args - the number and list of args.
* Returns: The created widget.
*/
Widget
XmCreateColorSelector(Widget parent, String name,
ArgList args, Cardinal num_args)
{
return(XtCreateWidget(name, xmColorSelectorWidgetClass,
parent, args, num_args));
}
Widget
XmVaCreateColorSelector(
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,
xmColorSelectorWidgetClass,
parent, False,
var, count);
va_end(var);
return w;
}
Widget
XmVaCreateManagedColorSelector(
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,
xmColorSelectorWidgetClass,
parent, True,
var, count);
va_end(var);
return w;
}