/nx-3.5.0/nx-X11/lib/dpstk/ColorSB.c

Large files files are truncated, but you can click here to view the full file

/* 
 * ColorSB.c
 *
 * (c) Copyright 1993-1994 Adobe Systems Incorporated.
 * All rights reserved.
 * 
 * Permission to use, copy, modify, distribute, and sublicense this software
 * and its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notices appear in all copies and that
 * both those copyright notices and this permission notice appear in
 * supporting documentation and that the name of Adobe Systems Incorporated
 * not be used in advertising or publicity pertaining to distribution of the
 * software without specific, written prior permission.  No trademark license
 * to use the Adobe trademarks is hereby granted.  If the Adobe trademark
 * "Display PostScript"(tm) is used to describe this software, its
 * functionality or for any other purpose, such use shall be limited to a
 * statement that this software works in conjunction with the Display
 * PostScript system.  Proper trademark attribution to reflect Adobe's
 * ownership of the trademark shall be given whenever any such reference to
 * the Display PostScript system is made.
 * 
 * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR
 * ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
 * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NON- INFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO EVENT SHALL ADOBE BE LIABLE
 * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  ADOBE WILL NOT
 * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE.
 * 
 * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems
 * Incorporated which may be registered in certain jurisdictions
 * 
 * Author:  Adobe Systems Incorporated
 */
/* $XFree86$ */

#ifndef X_NOT_POSIX
#include <unistd.h>
#endif

#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/ShellP.h>
#include <stdlib.h>
#include <Xm/Xm.h>

/* There are no words to describe how I feel about having to do this */

#if XmVersion > 1001		
#include <Xm/ManagerP.h>
#else
#include <Xm/XmP.h>
#endif

#include <Xm/Form.h>
#include <Xm/Label.h>
#include <Xm/LabelG.h>
#include <Xm/PushB.h>
#include <Xm/PushBG.h>
#include <Xm/SeparatoG.h>
#include <Xm/DrawingA.h>
#include <Xm/Scale.h>
#include <Xm/RowColumn.h>
#include <Xm/Frame.h>
#include <Xm/MessageB.h>

#include <DPS/dpsXclient.h>
#include "dpsXcommonI.h"
#include <DPS/dpsXshare.h>
#include "eyedrop16.xbm"
#include "eyedropmask16.xbm"
#include "eyedrop32.xbm"
#include "eyedropmask32.xbm"
#include "heyedrop.xbm"
#include "square.xbm"
#include "squaremask.xbm"
#include "CSBwraps.h"
#include <math.h>
#include <stdio.h>
#include <pwd.h>
#include <DPS/ColorSBP.h>

#define PATH_BUF_SIZE 1024

/* Turn a string into a compound string */
#define CS(str, w) CreateSharedCS(str, w)

#undef MIN
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#undef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define TO_PCT(val) ((int) (val * 100.0 + 0.5))
#define TO_X(color) ((color) * 65535)

#define Offset(field) XtOffsetOf(ColorSelectionBoxRec, csb.field)

static XtResource resources[] = {
    {XtNcontext, XtCContext, XtRDPSContext, sizeof(DPSContext),
	Offset(context), XtRDPSContext, (XtPointer) NULL},
    {XtNrgbLabels, XtCRgbLabels, XtRString, sizeof(String),
	Offset(rgb_labels), XtRString, (XtPointer) "R:G:B"},
    {XtNcmykLabels, XtCCmykLabels, XtRString, sizeof(String),
	Offset(cmyk_labels), XtRString, (XtPointer) "C:M:Y:K"},
    {XtNhsbLabels, XtCHsbLabels, XtRString, sizeof(String),
	Offset(hsb_labels), XtRString, (XtPointer) "H:S:B"},
    {XtNgrayLabels, XtCGrayLabels, XtRString, sizeof(String),
	Offset(gray_labels), XtRString, (XtPointer) "Gray"},
    {XtNcellSize, XtCCellSize, XtRDimension, sizeof(Dimension),
	Offset(cell_size), XtRImmediate, (XtPointer) 15},
    {XtNnumCells, XtCNumCells, XtRShort, sizeof(short),
	Offset(num_cells), XtRImmediate, (XtPointer) 30},
    {XtNfillMe, XtCFillMe, XtRString, sizeof(String),
	Offset(fill_me), XtRString, (XtPointer) "Fill me with colors"},
    {XtNcurrentSpace, XtCCurrentSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(current_space), XtRImmediate, (XtPointer) CSBSpaceHSB},
    {XtNcurrentRendering, XtCCurrentRendering, XtRRenderingType,
	sizeof(CSBRenderingType), Offset(current_rendering),
	XtRImmediate, (XtPointer) CSBDisplayDPS},
    {XtNcurrentPalette, XtCCurrentPalette, XtRShort, sizeof(short),
	Offset(current_palette), XtRImmediate, (XtPointer) 0},
    {XtNbrokenPaletteLabel, XtCBrokenPaletteLabel, XtRString,
	sizeof(String), Offset(broken_palette_label),
	XtRString, (XtPointer) "(broken)"},
    {XtNbrokenPaletteMessage, XtCBrokenPaletteMessage, XtRString,
	sizeof(String), Offset(broken_palette_message),
	XtRString, (XtPointer) "The current palette contains an error"},

    {XtNpalette0Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[0]), XtRString, (XtPointer) NULL},
    {XtNpalette0Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[0]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette0ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[0]), XtRImmediate, (XtPointer) False},
    {XtNpalette0Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[0]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette1Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[1]), XtRString, (XtPointer) NULL},
    {XtNpalette1Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[1]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette1ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[1]), XtRImmediate, (XtPointer) False},
    {XtNpalette1Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[1]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette2Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[2]), XtRString, (XtPointer) NULL},
    {XtNpalette2Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[2]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette2ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[2]), XtRImmediate, (XtPointer) False},
    {XtNpalette2Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[2]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette3Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[3]), XtRString, (XtPointer) NULL},
    {XtNpalette3Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[3]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette3ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[3]), XtRImmediate, (XtPointer) False},
    {XtNpalette3Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[3]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette4Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[4]), XtRString, (XtPointer) NULL},
    {XtNpalette4Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[4]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette4ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[4]), XtRImmediate, (XtPointer) False},
    {XtNpalette4Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[4]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette5Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[5]), XtRString, (XtPointer) NULL},
    {XtNpalette5Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[5]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette5ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[5]), XtRImmediate, (XtPointer) False},
    {XtNpalette5Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[5]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette6Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[6]), XtRString, (XtPointer) NULL},
    {XtNpalette6Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[6]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette6ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[6]), XtRImmediate, (XtPointer) False},
    {XtNpalette6Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[6]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette7Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[7]), XtRString, (XtPointer) NULL},
    {XtNpalette7Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[7]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette7ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[7]), XtRImmediate, (XtPointer) False},
    {XtNpalette7Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[7]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette8Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[8]), XtRString, (XtPointer) NULL},
    {XtNpalette8Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[8]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette8ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[8]), XtRImmediate, (XtPointer) False},
    {XtNpalette8Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[8]), XtRImmediate, (XtPointer) NULL},

    {XtNpalette9Label, XtCPaletteLabel, XtRString, sizeof(String),
	Offset(palette_label[9]), XtRString, (XtPointer) NULL},
    {XtNpalette9Space, XtCPaletteSpace, XtRColorSpace, sizeof(CSBColorSpace),
	Offset(palette_space[9]), XtRImmediate, (XtPointer) CSBSpaceRGB},
    {XtNpalette9ColorDependent, XtCPaletteColorDependent,
	XtRBoolean, sizeof(Boolean),
	Offset(palette_color_dependent[9]), XtRImmediate, (XtPointer) False},
    {XtNpalette9Function, XtCPaletteFunction, XtRString, sizeof(String),
	Offset(palette_function[9]), XtRImmediate, (XtPointer) NULL},

    {XtNokCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
	Offset(ok_callback), XtRCallback, (XtPointer) NULL},
    {XtNapplyCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
	Offset(apply_callback), XtRCallback, (XtPointer) NULL},
    {XtNresetCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
	Offset(reset_callback), XtRCallback, (XtPointer) NULL},
    {XtNcancelCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
	Offset(cancel_callback), XtRCallback, (XtPointer) NULL},
    {XtNvalueChangedCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
	Offset(value_changed_callback), XtRCallback, (XtPointer) NULL}
};

static Boolean SetColor         (Widget w, CSBColorSpace space, double c1, double c2, double c3, double c4, Bool setSpace);
static Boolean SetValues        (Widget old, Widget req, Widget new, ArgList args, Cardinal *num_args);
static XtGeometryResult GeometryManager (Widget w, XtWidgetGeometry *desired, XtWidgetGeometry *allowed);
static void ChangeLabel         (Widget label, double n);
static void ChangeManaged       (Widget w);
static void ClassInitialize     (void);
static void ClassPartInitialize (WidgetClass widget_class);
static void CreateChildren      (ColorSelectionBoxWidget csb);
static void Destroy             (Widget widget);
static void DrawDock            (ColorSelectionBoxWidget csb);
static void DrawPalette         (ColorSelectionBoxWidget csb);
static void FillPatch           (ColorSelectionBoxWidget csb);
static void GetColor            (Widget w, CSBColorSpace space, float *c1, float *c2, float *c3, float *c4);
static void Initialize          (Widget request, Widget new, ArgList args, Cardinal *num_args);
static void InitializeDock      (ColorSelectionBoxWidget csb);
static void Realize             (Widget w, XtValueMask *mask, XSetWindowAttributes *attr);
static void Resize              (Widget widget);
static void SaveDockContents    (ColorSelectionBoxWidget csb);
static void SetBackground       (ColorSelectionBoxWidget csb);
static void SetCMYKValues       (ColorSelectionBoxWidget csb);
static void SetColorSpace       (ColorSelectionBoxWidget csb);
static void SetGrayValues       (ColorSelectionBoxWidget csb);
static void SetHSBValues        (ColorSelectionBoxWidget csb);
static void SetRGBValues        (ColorSelectionBoxWidget csb);
static void SetRendering        (ColorSelectionBoxWidget csb);
static void SetSliders          (ColorSelectionBoxWidget csb);
static void UpdateColorSpaces   (ColorSelectionBoxWidget csb, CSBColorSpace masterSpace);

static void DockPress           (Widget w, XtPointer data, XEvent *event, Boolean *goOn);
static void EyedropPointer      (Widget w, XtPointer data, XEvent *event, Boolean *goOn);
static void FormResize          (Widget w, XtPointer data, XEvent *event, Boolean *goOn);
static void PalettePress        (Widget w, XtPointer data, XEvent *event, Boolean *goOn);
static void PatchPress          (Widget w, XtPointer data, XEvent *event, Boolean *goOn);
static void PatchRelease        (Widget w, XtPointer data, XEvent *event, Boolean *goOn);

static void ApplyCallback       (Widget w, XtPointer clientData, XtPointer callData);
static void DoEyedropCallback   (Widget w, XtPointer clientData, XtPointer callData);
static void DrawDockCallback    (Widget w, XtPointer clientData, XtPointer callData);
static void DrawPaletteCallback (Widget w, XtPointer clientData, XtPointer callData);
static void FillPatchCallback   (Widget w, XtPointer clientData, XtPointer callData);
static void OKCallback          (Widget w, XtPointer clientData, XtPointer callData);
static void SetCMYKCallback     (Widget w, XtPointer clientData, XtPointer callData);
static void SetGrayCallback     (Widget w, XtPointer clientData, XtPointer callData);
static void SetHSBCallback      (Widget w, XtPointer clientData, XtPointer callData);
static void SetRGBCallback      (Widget w, XtPointer clientData, XtPointer callData);
static void Slider1Callback     (Widget w, XtPointer clientData, XtPointer callData);
static void Slider2Callback     (Widget w, XtPointer clientData, XtPointer callData);
static void Slider3Callback     (Widget w, XtPointer clientData, XtPointer callData);
static void Slider4Callback     (Widget w, XtPointer clientData, XtPointer callData);

ColorSelectionBoxClassRec colorSelectionBoxClassRec = {
    /* Core class part */
  {
    /* superclass	     */	(WidgetClass) &xmManagerClassRec,
    /* class_name	     */ "ColorSelectionBox",
    /* widget_size	     */ sizeof(ColorSelectionBoxRec),
    /* class_initialize      */ ClassInitialize,
    /* class_part_initialize */ ClassPartInitialize,
    /* class_inited          */	False,
    /* initialize	     */	Initialize,
    /* initialize_hook       */	NULL,
    /* realize		     */	Realize,
    /* actions		     */	NULL,
    /* num_actions	     */	0,
    /* resources	     */	resources,
    /* num_resources	     */	XtNumber(resources),
    /* xrm_class	     */	NULLQUARK,
    /* compress_motion	     */	True,
    /* compress_exposure     */	XtExposeCompressMultiple,
    /* 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 offsets      */	NULL,
    /* tm_table              */	NULL,
    /* query_geometry	     */	XtInheritQueryGeometry,
    /* display_accelerator   */	NULL,
    /* extension	     */	NULL,
  },
   /* Composite class part */
  {
    /* geometry_manager	     */	GeometryManager,
    /* change_managed	     */	ChangeManaged,
    /* insert_child	     */	XtInheritInsertChild,
    /* delete_child	     */	XtInheritDeleteChild,
    /* extension	     */	NULL,
  },
   /* Constraint class part */
  {
    /* resources	     */ NULL,
    /* num_resources	     */ 0,
    /* constraint_size	     */ 0,
    /* initialize	     */ NULL,
    /* destroy		     */ NULL,
    /* set_values	     */ NULL,
    /* extension	     */ NULL,
  },
   /* Manager class part */
  {
    /* translations	     */ XtInheritTranslations,
    /* syn_resources	     */ NULL,
    /* num_syn_resources     */ 0,
    /* syn_constraint_resources */ NULL,
    /* num_syn_constraint_resources */ 0,
    /* parent_process	     */ XmInheritParentProcess,
    /* extension	     */ NULL,
  },
   /* ColorSelectionBox class part */
  {
    /* set_color	     */ SetColor,
    /* get_color	     */ GetColor,
    /* extension	     */	NULL,
  }
};

WidgetClass colorSelectionBoxWidgetClass =
	(WidgetClass) &colorSelectionBoxClassRec;

static XmString CreateSharedCS(String str, Widget w)
{
    XrmValue src, dst;
    XmString result;

    src.addr = str;
    src.size = strlen(str);

    dst.addr = (caddr_t) &result;
    dst.size = sizeof(result);

    if (XtConvertAndStore(w, XtRString, &src, XmRXmString, &dst)) {
	return result;
    } else return NULL;
}
 
static Boolean LowerCase(String from, String to, int size)
{
    register char ch;
    register int i;

    for (i = 0; i < size; i++) {
	ch = from[i];
	if (ch >= 'A' && ch <= 'Z') to[i] = ch - 'A' + 'a';
	else to[i] = ch;
	if (ch == '\0') return False;
    }
    return TRUE;
}

/* ARGSUSED */

static Boolean CvtStringToColorSpace(
    Display *dpy,
    XrmValuePtr args,
    Cardinal *num_args,
    XrmValuePtr from,
    XrmValuePtr to,
    XtPointer *data)
{
#define LOWER_SIZE 5
    char lower[LOWER_SIZE];	/* Lower cased string value */
    Boolean badConvert;
    static CSBColorSpace c;

    if (*num_args != 0) {	/* Check for correct number */
	XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
		"cvtStringToColorSpace", "wrongParameters",
		"XtToolkitError",
		"String to colorspace conversion needs no extra arguments",
		(String *) NULL, (Cardinal *) NULL);
    }

    /* Lower case the value */
    badConvert = LowerCase(from->addr, lower, LOWER_SIZE);

    /* Try to convert if a short enough string specified */
    if (!badConvert) {
	if (strcmp(lower, "rgb") == 0) c = CSBSpaceRGB;
	else if (strcmp(lower, "cmyk") == 0) c = CSBSpaceCMYK;
	else if (strcmp(lower, "hsb") == 0) c = CSBSpaceHSB;
	else if (strcmp(lower, "gray") == 0) c = CSBSpaceGray;
	else if (strcmp(lower, "grey") == 0) c = CSBSpaceGray;
	else badConvert = True;
    }

    /* String too long or unknown value -- issue warning */
    if (badConvert) {
	XtDisplayStringConversionWarning(dpy, from->addr, "ColorSpace");
    } else {
	if (to->addr == NULL) to->addr = (caddr_t) &c;

	else if (to->size < sizeof(CSBColorSpace)) badConvert = TRUE;
	else *(CSBColorSpace *) to->addr = c;

	to->size = sizeof(CSBColorSpace);
    }
    return !badConvert;
#undef LOWER_SIZE
}

/* ARGSUSED */

static Boolean CvtStringToRenderingType(
    Display *dpy,
    XrmValuePtr args,
    Cardinal *num_args,
    XrmValuePtr from,
    XrmValuePtr to,
    XtPointer *data)
{
#define LOWER_SIZE 5
    char lower[LOWER_SIZE];	/* Lower cased string value */
    Boolean badConvert;
    static CSBRenderingType c;

    if (*num_args != 0) {	/* Check for correct number */
	XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
		"cvtStringToRenderingType", "wrongParameters",
		"XtToolkitError",
		"String to rendering type conversion needs no extra arguments",
		(String *) NULL, (Cardinal *) NULL);
    }

    /* Lower case the value */
    badConvert = LowerCase(from->addr, lower, LOWER_SIZE);

    /* Try to convert if a short enough string specified */
    if (!badConvert) {
	if (strcmp(lower, "x") == 0) c = CSBDisplayX;
	else if (strcmp(lower, "dps") == 0) c = CSBDisplayDPS;
	else if (strcmp(lower, "both") == 0) c = CSBDisplayBoth;
	else badConvert = True;
    }

    /* String too long or unknown value -- issue warning */
    if (badConvert) {
	XtDisplayStringConversionWarning(dpy, from->addr, "RenderingType");
    } else {
	if (to->addr == NULL) to->addr = (caddr_t) &c;

	else if (to->size < sizeof(CSBRenderingType)) badConvert = TRUE;
	else *(CSBRenderingType *) to->addr = c;

	to->size = sizeof(CSBRenderingType);
    }
    return !badConvert;
#undef LOWER_SIZE
}

static void ClassInitialize(void)
{
    /* Register converters */

    XtSetTypeConverter(XtRString, XtRColorSpace,
	    CvtStringToColorSpace, (XtConvertArgList) NULL, 0,
	    XtCacheAll, (XtDestructor) NULL);
    XtSetTypeConverter(XtRString, XtRRenderingType,
	    CvtStringToRenderingType, (XtConvertArgList) NULL, 0,
	    XtCacheAll, (XtDestructor) NULL);
}

/* ARGSUSED */

static void ClassPartInitialize(WidgetClass widget_class)
{
    register ColorSelectionBoxWidgetClass wc =
	    (ColorSelectionBoxWidgetClass) widget_class;
    ColorSelectionBoxWidgetClass super =
	    (ColorSelectionBoxWidgetClass) wc->core_class.superclass;

    if (wc->csb_class.set_color == InheritSetColor) {
	wc->csb_class.set_color = super->csb_class.set_color;
    }
    if (wc->csb_class.get_color == InheritGetColor) {
	wc->csb_class.get_color = super->csb_class.get_color;
    }
}

static void ToUserSpace(
    ColorSelectionBoxWidget csb,
    int xWidth, int xHeight,
    float *uWidth, float *uHeight)
{
    register float *i = csb->csb.itransform;

    *uWidth = i[0] * xWidth - i[2] * xHeight + i[4];
    *uHeight= i[1] * xWidth - i[3] * xHeight + i[5];
}

static void ColorizeRGB(ColorSelectionBoxWidget csb)
{
    Dimension height, width;
    int depth, steps;
    float w, h;

    XtVaGetValues(csb->csb.slider_child[0], XtNwidth, &width,
		  XtNheight, &height,
		  XtNdepth, &depth, NULL);

    if (csb->csb.red_pixmap != None && width != csb->csb.rgb_slider_width) {
	XFreePixmap(XtDisplay(csb), csb->csb.red_pixmap);
	XFreePixmap(XtDisplay(csb), csb->csb.green_pixmap);
	XFreePixmap(XtDisplay(csb), csb->csb.blue_pixmap);
	csb->csb.red_pixmap = None;
    }

    if (csb->csb.red_pixmap == None) {
	csb->csb.rgb_slider_width = width;
	if (csb->csb.visual_class == TrueColor) steps = width / 2;
	else steps = width / 4;
	
	ToUserSpace(csb, width, height, &w, &h);

	csb->csb.red_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					    width, height, depth);
    
	XDPSSetContextGState(csb->csb.context, csb->csb.base_gstate);
	XDPSSetContextDrawable(csb->csb.context, csb->csb.red_pixmap, height);

	_DPSCRGBBlend(csb->csb.context, 0.0, 0.0, w, h, "0 0", steps);

	csb->csb.green_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					      width, height, depth);
    
	XDPSSetContextDrawable(csb->csb.context,
			       csb->csb.green_pixmap, height);

	_DPSCRGBBlend(csb->csb.context, 0.0, 0.0, w, h, "0 exch 0", steps);

	csb->csb.blue_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					     width, height, depth);
    
	XDPSSetContextDrawable(csb->csb.context, csb->csb.blue_pixmap, height);

	_DPSCRGBBlend(csb->csb.context,
		      0.0, 0.0, w, h, "0 0 3 -1 roll", steps);

	DPSWaitContext(csb->csb.context);
    }

    XtVaSetValues(csb->csb.slider_child[0],
		  XtNbackgroundPixmap, csb->csb.red_pixmap, NULL);
    XtVaSetValues(csb->csb.slider_child[1],
		  XtNbackgroundPixmap, csb->csb.green_pixmap, NULL);
    XtVaSetValues(csb->csb.slider_child[2],
		  XtNbackgroundPixmap, csb->csb.blue_pixmap, NULL);
}

static void ColorizeCMYK(ColorSelectionBoxWidget csb)
{
    Dimension height, width;
    int depth, steps;
    float w, h;

    XtVaGetValues(csb->csb.slider_child[0], XtNwidth, &width,
		  XtNheight, &height,
		  XtNdepth, &depth, NULL);

    if (csb->csb.cyan_pixmap != None && width != csb->csb.cmyk_slider_width) {
	XFreePixmap(XtDisplay(csb), csb->csb.cyan_pixmap);
	XFreePixmap(XtDisplay(csb), csb->csb.magenta_pixmap);
	XFreePixmap(XtDisplay(csb), csb->csb.yellow_pixmap);
	XFreePixmap(XtDisplay(csb), csb->csb.black_pixmap);
	csb->csb.cyan_pixmap = None;
    }

    if (csb->csb.cyan_pixmap == None) {
	csb->csb.cmyk_slider_width = width;
	if (csb->csb.visual_class == TrueColor) steps = width / 2;
	else steps = width / 4;
	
	ToUserSpace(csb, width, height, &w, &h);

	csb->csb.cyan_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					     width, height, depth);
    
	XDPSSetContextGState(csb->csb.context, csb->csb.base_gstate);
	XDPSSetContextDrawable(csb->csb.context, csb->csb.cyan_pixmap, height);

	_DPSCCMYKBlend(csb->csb.context, 0.0, 0.0, w, h, "0 0 0", steps);

	csb->csb.magenta_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
						width, height, depth);
    
	XDPSSetContextDrawable(csb->csb.context, csb->csb.magenta_pixmap,
			       height);

	_DPSCCMYKBlend(csb->csb.context, 0.0, 0.0, w, h, "0 exch 0 0", steps);

	csb->csb.yellow_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					       width, height, depth);
    
	XDPSSetContextDrawable(csb->csb.context, csb->csb.yellow_pixmap,
			       height);

	_DPSCCMYKBlend(csb->csb.context, 0.0, 0.0, w, h, "0 0 3 -1 roll 0",
		       steps);

	csb->csb.black_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					      width, height, depth);
    
	XDPSSetContextDrawable(csb->csb.context, csb->csb.black_pixmap,
			       height);

	_DPSCCMYKBlend(csb->csb.context, 0.0, 0.0, w, h, "0 0 0 4 -1 roll",
		       steps);

	DPSWaitContext(csb->csb.context);
    }

    XtVaSetValues(csb->csb.slider_child[0], XtNbackgroundPixmap,
		  csb->csb.cyan_pixmap, NULL);
    XtVaSetValues(csb->csb.slider_child[1], XtNbackgroundPixmap,
		  csb->csb.magenta_pixmap, NULL);
    XtVaSetValues(csb->csb.slider_child[2], XtNbackgroundPixmap,
		  csb->csb.yellow_pixmap, NULL);
    XtVaSetValues(csb->csb.slider_child[3], XtNbackgroundPixmap,
		  csb->csb.black_pixmap, NULL);
}

static void ColorizeHSB(ColorSelectionBoxWidget csb)
{
    Dimension height, width;
    int depth, steps;
    float w, h;

    XtVaGetValues(csb->csb.slider_child[0], XtNwidth, &width,
		  XtNheight, &height,
		  XtNdepth, &depth, NULL);

    if (csb->csb.hue_pixmap != None && width != csb->csb.hsb_slider_width) {
	XFreePixmap(XtDisplay(csb), csb->csb.hue_pixmap);
	XFreePixmap(XtDisplay(csb), csb->csb.sat_pixmap);
	XFreePixmap(XtDisplay(csb), csb->csb.bright_pixmap);
	csb->csb.hue_pixmap = None;
    }

    if (csb->csb.hue_pixmap == None) {
	csb->csb.hsb_slider_width = width;
	if (csb->csb.visual_class == TrueColor) steps = width / 2;
	else steps = width / 4;
	
	ToUserSpace(csb, width, height, &w, &h);

	csb->csb.hue_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					    width, height, depth);
    
	XDPSSetContextGState(csb->csb.context, csb->csb.base_gstate);
	XDPSSetContextDrawable(csb->csb.context, csb->csb.hue_pixmap, height);

	_DPSCHSBBlend(csb->csb.context, 0.0, 0.0, w, h, "1 1", steps);

	csb->csb.sat_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					    width, height, depth);
    
	XDPSSetContextDrawable(csb->csb.context, csb->csb.sat_pixmap, height);

	_DPSCHSBBlend(csb->csb.context, 0.0, 0.0, w, h, "0 exch 1", steps);

	csb->csb.bright_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					       width, height, depth);
    
	XDPSSetContextDrawable(csb->csb.context, csb->csb.bright_pixmap,
			       height);

	_DPSCHSBBlend(csb->csb.context, 0.0, 0.0, w, h, "0 1 3 -1 roll",
		      steps);

	DPSWaitContext(csb->csb.context);
    }

    XtVaSetValues(csb->csb.slider_child[0], XtNbackgroundPixmap,
		  csb->csb.hue_pixmap, NULL);
    XtVaSetValues(csb->csb.slider_child[1], XtNbackgroundPixmap,
		  csb->csb.sat_pixmap, NULL);
    XtVaSetValues(csb->csb.slider_child[2], XtNbackgroundPixmap,
		  csb->csb.bright_pixmap, NULL);
}

static void ColorizeGray(ColorSelectionBoxWidget csb)
{
    Dimension height, width;
    int depth, steps;
    float w, h;

    XtVaGetValues(csb->csb.slider_child[0], XtNwidth, &width,
		  XtNheight, &height,
		  XtNdepth, &depth, NULL);

    if (csb->csb.gray_pixmap != None && width != csb->csb.gray_slider_width) {
	XFreePixmap(XtDisplay(csb), csb->csb.gray_pixmap);
	csb->csb.gray_pixmap = None;
    }

    if (csb->csb.gray_pixmap == None) {
	csb->csb.gray_slider_width = width;
	if (csb->csb.visual_class == TrueColor) steps = width / 2;
	else steps = width / 4;
	
	ToUserSpace(csb, width, height, &w, &h);

	csb->csb.gray_pixmap = XCreatePixmap(XtDisplay(csb), XtWindow(csb),
					     width, height, depth);
    
	XDPSSetContextGState(csb->csb.context, csb->csb.base_gstate);
	XDPSSetContextDrawable(csb->csb.context, csb->csb.gray_pixmap, height);

	_DPSCGrayBlend(csb->csb.context, 0.0, 0.0, w, h, " ", steps);

	DPSWaitContext(csb->csb.context);
    }

    XtVaSetValues(csb->csb.slider_child[0], XtNbackgroundPixmap,
		  csb->csb.gray_pixmap, NULL);
}

static void ColorizeSliders(ColorSelectionBoxWidget csb)
{
    if (!XtIsRealized(csb)) return;

    switch (csb->csb.current_space) {
	case CSBSpaceRGB:
	    ColorizeRGB(csb);
	    break;
	case CSBSpaceCMYK:
	    ColorizeCMYK(csb);
	    break;
	case CSBSpaceHSB:
	    ColorizeHSB(csb);
	    break;
	case CSBSpaceGray:
	    ColorizeGray(csb);
	    break;
    }
}

/* ARGSUSED */

static void FormResize(
    Widget w,
    XtPointer data,
    XEvent *event,
    Boolean *goOn)
{
    ColorSelectionBoxWidget csb = (ColorSelectionBoxWidget) data;
    
    if (event->type != ConfigureNotify && event->type != MapNotify) return;

    csb->csb.rgb_slider_width = csb->csb.cmyk_slider_width =
	    csb->csb.hsb_slider_width = csb->csb.gray_slider_width = 0;
    csb->csb.palette_pixmap_valid = False;
    if (csb->csb.patch_gstate != 0) {
	XDPSFreeContextGState(csb->csb.context, csb->csb.patch_gstate);
	csb->csb.patch_gstate = 0;
    }
    if (csb->csb.dock_gstate != 0) {
	XDPSFreeContextGState(csb->csb.context, csb->csb.dock_gstate);
	csb->csb.dock_gstate = 0;
    }
    ColorizeSliders(csb);
    DrawPalette(csb);
    if (XtIsRealized(csb->csb.patch_child)) {
	XClearArea(XtDisplay(csb), XtWindow(csb->csb.patch_child),
		   0, 0, 1000, 1000, True);
    }
}

static void FillCallbackRec(
    ColorSelectionBoxWidget csb,
    CSBCallbackRec *rec)
{
    rec->current_space = csb->csb.current_space;
    rec->red = csb->csb.current_color.red;
    rec->green = csb->csb.current_color.green;
    rec->blue = csb->csb.current_color.blue;
    rec->cyan = csb->csb.current_color.cyan;
    rec->magenta = csb->csb.current_color.magenta;
    rec->yellow = csb->csb.current_color.yellow;
    rec->black = csb->csb.current_color.black;
    rec->hue = csb->csb.current_color.hue;
    rec->saturation = csb->csb.current_color.saturation;
    rec->brightness = csb->csb.current_color.brightness;
    rec->gray = csb->csb.current_color.gray;
}

/* ARGSUSED */

static void OKCallback(
    Widget w,
    XtPointer clientData, XtPointer callData)
{
    ColorSelectionBoxWidget csb = (ColorSelectionBoxWidget) clientData;
    CSBCallbackRec rec;

    csb->csb.save_color = csb->csb.current_color;
    FillCallbackRec(csb, &rec);
    rec.reason = CSBOK;
    XtCallCallbackList((Widget) csb, csb->csb.ok_callback, (XtPointer) &rec);
    if (XtIsShell(XtParent(csb))) XtPopdown(XtParent(csb));

    SaveDockContents(csb);
}

/* ARGSUSED */

static void ApplyCallback(
    Widget w,
    XtPointer clientData, XtPointer callData)
{
    ColorSelectionBoxWidget csb = (ColorSelectionBoxWidget) clientData;
    CSBCallbackRec rec;

    csb->csb.save_color = csb->csb.current_color;
    FillCallbackRec(csb, &rec);
    rec.reason = CSBApply;
    XtCallCallbackList((Widget) csb, csb->csb.apply_callback,
		       (XtPointer) &rec);

    SaveDockContents(csb);
}

/* ARGSUSED */

static void ResetCallback(
    Widget w,
    XtPointer clientData, XtPointer callData)
{
    ColorSelectionBoxWidget csb = (ColorSelectionBoxWidget) clientData;
    CSBCallbackRec rec;

    csb->csb.current_color = csb->csb.save_color;
    FillPatch(csb);
    SetSliders(csb);
    FillCallbackRec(csb, &rec);
    rec.reason = CSBReset;
    XtCallCallbackList((Widget) csb, csb->csb.reset_callback,
		       (XtPointer) &rec);
}

/* ARGSUSED */

static void CancelCallback(
    Widget w,
    XtPointer clientData, XtPointer callData)
{
    ColorSelectionBoxWidget csb = (ColorSelectionBoxWidget) clientData;
    CSBCallbackRec rec;

    csb->csb.current_color = csb->csb.save_color;
    FillPatch(csb);
    SetSliders(csb);
    FillCallbackRec(csb, &rec);
    rec.reason = CSBCancel;
    XtCallCallbackList((Widget) csb, csb->csb.cancel_callback,
		       (XtPointer) &rec);
    if (XtIsShell(XtParent(csb))) XtPopdown(XtParent(csb));
}

/* ARGSUSED */

static void DoValueChangedCallback(ColorSelectionBoxWidget csb)
{
    CSBCallbackRec rec;

    FillCallbackRec(csb, &rec);
    rec.reason = CSBValueChanged;
    XtCallCallbackList((Widget) csb, csb->csb.value_changed_callback,
		       (XtPointer) &rec);
}

/* ARGSUSED */

static void ChangeLabelCallback(
    Widget w,
    XtPointer clientData, XtPointer callData)
{
    XmScaleCallbackStruct *scaleData = (XmScaleCallbackStruct *) callData;

    ChangeLabel((Widget) clientData, ((float) scaleData->value) / 100.0);
}

static void ChangeLabel(Widget label, double n)
{
    char buf[10];

    sprintf(buf, "%d", TO_PCT(n));
    XtVaSetValues(label, XmNlabelString, CS(buf, label), NULL);
}

static void CreateModelMenu(Widget parent, Widget csb)
{
    Widget kids[4];

    kids[0] = XmCreatePushButtonGadget(parent, "rgb", (ArgList) NULL, 0);
    XtAddCallback(kids[0], XmNactivateCallback,
		  SetRGBCallback, (XtPointer) csb);
    kids[1] = XmCreatePushButtonGadget(parent, "cmyk", (ArgList) NULL, 0);
    XtAddCallback(kids[1], XmNactivateCallback,
		  SetCMYKCallback, (XtPointer) csb);
    kids[2] = XmCreatePushButtonGadget(parent, "hsb", (ArgList) NULL, 0);
    XtAddCallback(kids[2], XmNactivateCallback,
		  SetHSBCallback, (XtPointer) csb);
    kids[3] = XmCreatePushButtonGadget(parent, "gray", (ArgList) NULL, 0);
    XtAddCallback(kids[3], XmNactivateCallback,
		  SetGrayCallback, (XtPointer) csb);

    XtManageChildren(kids, 4);
}

typedef struct {
    ColorSelectionBoxWidget csb;
    CSBRenderingType rendering;
} RenderingRec;

/* ARGSUSED */

static void SetRenderingCallback(
    Widget w,
    XtPointer clientData, XtPointer callData)
{
    RenderingRec *r = (RenderingRec *) clientData;

    r->csb->csb.current_rendering = r->rendering;
    FillPatch(r->csb);
}

static void CreateDisplayMenu(Widget parent, ColorSelectionBoxWidget csb)
{
    Widget kids[3];
    RenderingRec *r;

    r = XtNew(RenderingRec);
    r->csb = csb;
    r->rendering = CSBDisplayDPS;
    kids[0] = XmCreatePushButtonGadget(parent, "displayDPS",
				       (ArgList) NULL, 0);
    XtAddCallback(kids[0], XmNactivateCallback,
		  SetRenderingCallback, (XtPointer) r);
    r = XtNew(RenderingRec);
    r->csb = csb;
    r->rendering = CSBDisplayX;
    kids[1] = XmCreatePushButtonGadget(parent, "displayX", (ArgList) NULL, 0);
    XtAddCallback(kids[1], XmNactivateCallback,
		  SetRenderingCallback, (XtPointer) r);
    r = XtNew(RenderingRec);
    r->csb = csb;
    r->rendering = CSBDisplayBoth;
    kids[2] = XmCreatePushButtonGadget(parent, "displayBoth",
				       (ArgList) NULL, 0);
    XtAddCallback(kids[2], XmNactivateCallback,
		  SetRenderingCallback, (XtPointer) r);

    XtManageChildren(kids, 3);
}

typedef struct {
    ColorSelectionBoxWidget csb;
    int n;
} PaletteRec;

/* ARGSUSED */

static void SetPaletteCallback(
    Widget w,
    XtPointer clientData, XtPointer callData)
{
    PaletteRec *p = (PaletteRec *) clientData;

    if (p->csb->csb.palette_broken[p->n]) return;

    if (p->n != p->csb->csb.current_palette ||
	p->csb->csb.palette_color_dependent[p->n]) {
	p->csb->csb.palette_pixmap_valid = False;
    }

    p->csb->csb.current_palette = p->n;
    DrawPalette(p->csb);
}

static void CreatePaletteMenu(Widget parent, ColorSelectionBoxWidget csb)
{
    Widget w, managed[PALETTE_MAX];
    int j, k;
    char buf[10];
    PaletteRec *p;

    j = 0;

    for (k = 0; k < PALETTE_MAX; k++) {
	p = XtNew(PaletteRec);
	p->csb = csb;
	p->n = k;
	sprintf(buf, "palette%d", k);
	w = XtVaCreateWidget(buf, xmPushButtonGadgetClass, parent, NULL);
	if (csb->csb.palette_label[k] != NULL) {
	    XtVaSetValues(w, XtVaTypedArg, XmNlabelString,
			     XtRString, csb->csb.palette_label[k],
			     strlen(csb->csb.palette_label[k])+1,
			     NULL);
	}
	XtAddCallback(w, XmNactivateCallback,
		      SetPaletteCallback, (XtPointer) p);
	if (csb->csb.palette_function[k] != NULL) managed[j++] = w;
    }

    if (j != 0) XtManageChildren(managed, j);
}

static void CreateChildren(ColorSelectionBoxWidget csb)
{
    int i;
    Arg args[20];
    Widget form, menu, button, w, dock_frame, palette_frame;
    Pixel fg, bg;
    int depth;
    Pixmap eyedrop;

    i = 0;
    XtSetArg(args[i], XmNresizePolicy, XmRESIZE_NONE);			i++;
    form = XtCreateManagedWidget("panel", xmFormWidgetClass,
				 (Widget) csb, args, i);
    csb->csb.form_child = form;
    XtAddEventHandler(form, StructureNotifyMask, False, FormResize,
		      (XtPointer) csb);

    i = 0;
    menu = XmCreatePulldownMenu(form, "modelMenu", args, i);
    CreateModelMenu(menu, (Widget) csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM);			i++;
    XtSetArg(args[i], XmNsubMenuId, menu);				i++;
    csb->csb.model_option_menu_child =
	    XmCreateOptionMenu(form, "modelOptionMenu",
			       args, i);
    XtManageChild(csb->csb.model_option_menu_child);

    XtVaGetValues(form, XtNbackground, &bg, XmNforeground, &fg,
		  XtNdepth, &depth, NULL);
    eyedrop = XCreatePixmapFromBitmapData(XtDisplay(csb),
					  RootWindowOfScreen(XtScreen(csb)),
					  (char *) heyedrop_bits,
					  heyedrop_width, heyedrop_height,
					  fg, bg, depth);
				    
    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNleftWidget, csb->csb.model_option_menu_child);	i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.model_option_menu_child);	i++;
    XtSetArg(args[i], XmNlabelPixmap, eyedrop);				i++;
    button = XtCreateManagedWidget("eyedropButton", xmPushButtonWidgetClass,
				   form, args, i);
    XtAddCallback(button, XmNactivateCallback,
		  DoEyedropCallback, (XtPointer) csb);
    XtInsertRawEventHandler(button, PointerMotionMask | ButtonReleaseMask,
			    False, EyedropPointer, (XtPointer) csb,
			    XtListHead);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.model_option_menu_child);	i++;
    csb->csb.label_child[0] =
	    XtCreateManagedWidget("label1", xmLabelWidgetClass, form, args, i);

    i = 0;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.model_option_menu_child);	i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_POSITION);		i++;
    csb->csb.value_child[0] =
	    XtCreateManagedWidget("value1", xmLabelWidgetClass, form, args, i);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNleftWidget, csb->csb.label_child[0]);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.model_option_menu_child);	i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNrightWidget, csb->csb.value_child[0]);		i++;
    csb->csb.slider_child[0] =
	    XtCreateManagedWidget("slider1", xmScaleWidgetClass,
				  form, args, i);
    XtAddCallback(csb->csb.slider_child[0], XmNvalueChangedCallback,
		  ChangeLabelCallback, (XtPointer) csb->csb.value_child[0]);
    XtAddCallback(csb->csb.slider_child[0], XmNdragCallback,
		  ChangeLabelCallback, (XtPointer) csb->csb.value_child[0]);
    XtAddCallback(csb->csb.slider_child[0], XmNvalueChangedCallback,
		  Slider1Callback, (XtPointer) csb);
    XtAddCallback(csb->csb.slider_child[0], XmNdragCallback,
		  Slider1Callback, (XtPointer) csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[0]);		i++;
    csb->csb.label_child[1] =
	    XtCreateManagedWidget("label2", xmLabelWidgetClass, form, args, i);

    i = 0;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[0]);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNrightWidget, csb->csb.value_child[0]);		i++;
    csb->csb.value_child[1] =
	    XtCreateManagedWidget("value2", xmLabelWidgetClass, form, args, i);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNleftWidget, csb->csb.slider_child[0]);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[0]);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNrightWidget, csb->csb.slider_child[0]);	i++;
    csb->csb.slider_child[1] =
	    XtCreateManagedWidget("slider2", xmScaleWidgetClass,
				  form, args, i);
    XtAddCallback(csb->csb.slider_child[1], XmNvalueChangedCallback,
		  ChangeLabelCallback, (XtPointer) csb->csb.value_child[1]);
    XtAddCallback(csb->csb.slider_child[1], XmNdragCallback,
		  ChangeLabelCallback, (XtPointer) csb->csb.value_child[1]);
    XtAddCallback(csb->csb.slider_child[1], XmNvalueChangedCallback,
		  Slider2Callback, (XtPointer) csb);
    XtAddCallback(csb->csb.slider_child[1], XmNdragCallback,
		  Slider2Callback, (XtPointer) csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[1]);		i++;
    csb->csb.label_child[2] =
	    XtCreateManagedWidget("label3", xmLabelWidgetClass, form, args, i);

    i = 0;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[1]);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNrightWidget, csb->csb.value_child[0]);		i++;
    csb->csb.value_child[2] =
	    XtCreateManagedWidget("value3", xmLabelWidgetClass, form, args, i);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNleftWidget, csb->csb.slider_child[0]);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[1]);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNrightWidget, csb->csb.slider_child[0]);	i++;
    csb->csb.slider_child[2] =
	    XtCreateManagedWidget("slider3", xmScaleWidgetClass,
				  form, args, i);
    XtAddCallback(csb->csb.slider_child[2], XmNvalueChangedCallback,
		  ChangeLabelCallback, (XtPointer) csb->csb.value_child[2]);
    XtAddCallback(csb->csb.slider_child[2], XmNdragCallback,
		  ChangeLabelCallback, (XtPointer) csb->csb.value_child[2]);
    XtAddCallback(csb->csb.slider_child[2], XmNvalueChangedCallback,
		  Slider3Callback, (XtPointer) csb);
    XtAddCallback(csb->csb.slider_child[2], XmNdragCallback,
		  Slider3Callback, (XtPointer) csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[2]);		i++;
    csb->csb.label_child[3] =
	    XtCreateManagedWidget("label4", xmLabelWidgetClass, form, args, i);

    i = 0;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[2]);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNrightWidget, csb->csb.value_child[0]);		i++;
    csb->csb.value_child[3] =
	    XtCreateManagedWidget("value4", xmLabelWidgetClass, form, args, i);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNleftWidget, csb->csb.slider_child[0]);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNtopWidget, csb->csb.slider_child[2]);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNrightWidget, csb->csb.slider_child[0]);	i++;
    csb->csb.slider_child[3] =
	    XtCreateManagedWidget("slider4", xmScaleWidgetClass,
				  form, args, i);
    XtAddCallback(csb->csb.slider_child[3], XmNvalueChangedCallback,
		  ChangeLabelCallback, (XtPointer) csb->csb.value_child[3]);
    XtAddCallback(csb->csb.slider_child[3], XmNdragCallback,
		  ChangeLabelCallback, (XtPointer) csb->csb.value_child[3]);
    XtAddCallback(csb->csb.slider_child[3], XmNvalueChangedCallback,
		  Slider4Callback, (XtPointer) csb);
    XtAddCallback(csb->csb.slider_child[3], XmNdragCallback,
		  Slider4Callback, (XtPointer) csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM);		i++;
    button = XtCreateManagedWidget("okButton", xmPushButtonWidgetClass,
				   form, args, i);
    XtAddCallback(button, XmNactivateCallback, OKCallback, (XtPointer) csb);

    i = 0;
    XtSetArg(args[i], XmNdefaultButton, button);			i++;
    XtSetValues(form, args, i);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNleftWidget, button);				i++;
    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM);		i++;
    button = XtCreateManagedWidget("applyButton", xmPushButtonWidgetClass,
				   form, args, i);

    XtAddCallback(button, XmNactivateCallback, ApplyCallback, (XtPointer) csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNleftWidget, button);				i++;
    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM);		i++;
    button = XtCreateManagedWidget("resetButton", xmPushButtonWidgetClass,
				   form, args, i);
    XtAddCallback(button, XmNactivateCallback, ResetCallback, (XtPointer) csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNleftWidget, button);				i++;
    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM);		i++;
    button = XtCreateManagedWidget("cancelButton", xmPushButtonWidgetClass,
				  form, args, i);
    XtAddCallback(button, XmNactivateCallback,
		  CancelCallback, (XtPointer) csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNbottomWidget, button);				i++;
    w = XtCreateManagedWidget("separator", xmSeparatorGadgetClass,
			      form, args, i);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNbottomWidget, w);				i++;
    palette_frame = XtCreateManagedWidget("paletteFrame", xmFrameWidgetClass,
					  form, args, i);

    i = 0;
    csb->csb.palette_child =
	    XtCreateManagedWidget("palette", xmDrawingAreaWidgetClass,
				  palette_frame, args, i);
    XtAddCallback(csb->csb.palette_child, XmNexposeCallback,
		  DrawPaletteCallback, (XtPointer) csb);
    XtAddEventHandler(csb->csb.palette_child, ButtonPressMask, False,
		      PalettePress, (XtPointer) csb);

    i = 0;
    menu = XmCreatePulldownMenu(form, "paletteMenu", args, i);
    CreatePaletteMenu(menu, csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNbottomWidget, palette_frame);			i++;
    XtSetArg(args[i], XmNsubMenuId, menu);				i++;
    csb->csb.palette_option_menu_child =
	    XmCreateOptionMenu(form, "paletteOptionMenu",
			       args, i);
    XtManageChild(csb->csb.palette_option_menu_child);

    i = 0;
    menu = XmCreatePulldownMenu(form, "displayMenu", args, i);
    CreateDisplayMenu(menu, csb);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_POSITION);		i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM);			i++;
    XtSetArg(args[i], XmNsubMenuId, menu);				i++;
    csb->csb.display_option_menu_child =
	    XmCreateOptionMenu(form, "displayOptionMenu",
			       args, i);
    XtManageChild(csb->csb.display_option_menu_child);

    i = 0;
    XtSetArg(args[i], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
    XtSetArg(args[i], XmNleftWidget, csb->csb.display_option_menu_child);i++;
    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
    XtSetArg(args[i], XmNbottomWidget, palette_frame);			i++;
    dock_frame = XtCreateManagedWidget("dockFrame", xmFrameWidgetClass,
				       form, args, i);

    i = 0;
    csb->csb…