/* * 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 #endif #include #include #include #include "ColorSP.h" #include #include #include #include #include #include #include #include #include #include #include #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); /* * 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; }