Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 1864 insertions, 0 deletions

diff --git a/nx-X11/lib/Xt/Converters.c b/nx-X11/lib/Xt/Converters.c
new file mode 100644
index 000000000..acb572e69
--- /dev/null
+++ b/nx-X11/lib/Xt/Converters.c
@@ -0,0 +1,1864 @@
+/* $Xorg: Converters.c,v 1.5 2001/02/09 02:03:54 xorgcvs Exp $ */
+
+/***********************************************************
+Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts
+Copyright 1993 by Sun Microsystems, Inc. Mountain View, CA.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or Sun not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO  THIS  SOFTWARE,
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
+NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE  LI-
+ABLE  FOR  ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,  DATA  OR
+PROFITS,  WHETHER  IN  AN  ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+/* $XFree86: xc/lib/Xt/Converters.c,v 3.14tsi Exp $ */
+
+/*
+
+Copyright 1987, 1988, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+/*LINTLIBRARY*/
+/* Conversion.c - implementations of resource type conversion procs */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include	"IntrinsicI.h"
+#include	"StringDefs.h"
+#include	"Shell.h"
+#include	<stdio.h>
+#include        <X11/cursorfont.h>
+#include	<X11/keysym.h>
+#include	<X11/Xlocale.h>
+#include	<errno.h>	/* for StringToDirectoryString */
+
+#ifdef __UNIXOS2__
+#define IsNewline(str) ((str) == '\n' || (str) == '\r')
+#define IsWhitespace(str) ((str)== ' ' || (str) == '\t' || (str) == '\r')
+#else
+#define IsNewline(str) ((str) == '\n')
+#define IsWhitespace(str) ((str)== ' ' || (str) == '\t')
+#endif
+
+static const String XtNwrongParameters = "wrongParameters";
+static const String XtNconversionError = "conversionError";
+static const String XtNmissingCharsetList = "missingCharsetList";
+
+/* Representation types */
+
+#define XtQAtom			XrmPermStringToQuark(XtRAtom)
+#define XtQCommandArgArray	XrmPermStringToQuark(XtRCommandArgArray)
+#define XtQCursor		XrmPermStringToQuark(XtRCursor)
+#define XtQDirectoryString	XrmPermStringToQuark(XtRDirectoryString)
+#define XtQDisplay		XrmPermStringToQuark(XtRDisplay)
+#define XtQFile			XrmPermStringToQuark(XtRFile)
+#define XtQFloat		XrmPermStringToQuark(XtRFloat)
+#define XtQInitialState		XrmPermStringToQuark(XtRInitialState)
+#define XtQPixmap		XrmPermStringToQuark(XtRPixmap)
+#define XtQRestartStyle 	XrmPermStringToQuark(XtRRestartStyle)
+#define XtQShort		XrmPermStringToQuark(XtRShort)
+#define XtQUnsignedChar		XrmPermStringToQuark(XtRUnsignedChar)
+#define XtQVisual		XrmPermStringToQuark(XtRVisual)
+
+static XrmQuark  XtQBool;
+static XrmQuark  XtQBoolean;
+static XrmQuark  XtQColor;
+static XrmQuark  XtQDimension;
+static XrmQuark  XtQFont;
+static XrmQuark  XtQFontSet;
+static XrmQuark  XtQFontStruct;
+static XrmQuark  XtQGravity;
+static XrmQuark  XtQInt;
+static XrmQuark  XtQPixel;
+static XrmQuark  XtQPosition;
+#ifdef __UNIXOS2__
+XrmQuark  _XtQString = 0;
+#else
+XrmQuark  _XtQString;
+#endif
+
+void _XtConvertInitialize(void)
+{
+    XtQBool		= XrmPermStringToQuark(XtRBool);
+    XtQBoolean		= XrmPermStringToQuark(XtRBoolean);
+    XtQColor		= XrmPermStringToQuark(XtRColor);
+    XtQDimension	= XrmPermStringToQuark(XtRDimension);
+    XtQFont		= XrmPermStringToQuark(XtRFont);
+    XtQFontSet		= XrmPermStringToQuark(XtRFontSet);
+    XtQFontStruct	= XrmPermStringToQuark(XtRFontStruct);
+    XtQGravity		= XrmPermStringToQuark(XtRGravity);
+    XtQInt		= XrmPermStringToQuark(XtRInt);
+    XtQPixel		= XrmPermStringToQuark(XtRPixel);
+    XtQPosition		= XrmPermStringToQuark(XtRPosition);
+    _XtQString		= XrmPermStringToQuark(XtRString);
+}
+
+#define	donestr(type, value, tstr) \
+	{							\
+	    if (toVal->addr != NULL) {				\
+		if (toVal->size < sizeof(type)) {		\
+		    toVal->size = sizeof(type);			\
+		    XtDisplayStringConversionWarning(dpy, 	\
+			(char*) fromVal->addr, tstr);		\
+		    return False;				\
+		}						\
+		*(type*)(toVal->addr) = (value);		\
+	    }							\
+	    else {						\
+		static type static_val;				\
+		static_val = (value);				\
+		toVal->addr = (XPointer)&static_val;		\
+	    }							\
+	    toVal->size = sizeof(type);				\
+	    return True;					\
+	}
+
+#define	done(type, value) \
+	{							\
+	    if (toVal->addr != NULL) {				\
+		if (toVal->size < sizeof(type)) {		\
+		    toVal->size = sizeof(type);			\
+		    return False;				\
+		}						\
+		*(type*)(toVal->addr) = (value);		\
+	    }							\
+	    else {						\
+		static type static_val;				\
+		static_val = (value);				\
+		toVal->addr = (XPointer)&static_val;		\
+	    }							\
+	    toVal->size = sizeof(type);				\
+	    return True;					\
+	}
+
+void XtDisplayStringConversionWarning(
+    Display* dpy,
+    _Xconst char* from,
+    _Xconst char* toType
+    )
+{
+#ifndef NO_MIT_HACKS
+    /* Allow suppression of conversion warnings. %%%  Not specified. */
+
+    static enum {Check, Report, Ignore} report_it = Check;
+    XtAppContext app = XtDisplayToApplicationContext(dpy);
+
+    LOCK_APP(app);
+    LOCK_PROCESS;
+    if (report_it == Check) {
+	XrmDatabase rdb = XtDatabase(dpy);
+	XrmName xrm_name[2];
+	XrmClass xrm_class[2];
+	XrmRepresentation rep_type;
+	XrmValue value;
+	xrm_name[0] = XrmPermStringToQuark( "stringConversionWarnings" );
+	xrm_name[1] = 0;
+	xrm_class[0] = XrmPermStringToQuark( "StringConversionWarnings" );
+	xrm_class[1] = 0;
+	if (XrmQGetResource( rdb, xrm_name, xrm_class,
+			     &rep_type, &value ))
+	{
+	    if (rep_type == XtQBoolean)
+		report_it = *(Boolean*)value.addr ? Report : Ignore;
+	    else if (rep_type == _XtQString) {
+		XrmValue toVal;
+		Boolean report;
+		toVal.addr = (XPointer)&report;
+		toVal.size = sizeof(Boolean);
+		if (XtCallConverter(dpy, XtCvtStringToBoolean, (XrmValuePtr)NULL,
+				    (Cardinal)0, &value, &toVal,
+				    (XtCacheRef*)NULL))
+		    report_it = report ? Report : Ignore;
+	    }
+	    else report_it = Report;
+	}
+	else report_it = Report;
+    }
+
+    if (report_it == Report) {
+#endif /* ifndef NO_MIT_HACKS */
+	String params[2];
+	Cardinal num_params = 2;
+	params[0] = (String)from;
+	params[1] = (String)toType;
+	XtAppWarningMsg(app,
+		   XtNconversionError,"string",XtCXtToolkitError,
+		   "Cannot convert string \"%s\" to type %s",
+		    params,&num_params);
+#ifndef NO_MIT_HACKS
+    }
+#endif /* ifndef NO_MIT_HACKS */
+    UNLOCK_PROCESS;
+    UNLOCK_APP(app);
+}
+
+void XtStringConversionWarning(
+    _Xconst char* from,
+    _Xconst char* toType
+    )
+{
+	String params[2];
+	Cardinal num_params = 2;
+	params[0] = (String)from;
+	params[1] = (String)toType;
+	XtWarningMsg(XtNconversionError,"string",XtCXtToolkitError,
+		   "Cannot convert string \"%s\" to type %s",
+		    params,&num_params);
+}
+
+static int CompareISOLatin1(char *, char *);
+
+
+static Boolean IsInteger(
+    String string,
+    int *value)
+{
+    Boolean foundDigit = False;
+    Boolean isNegative = False;
+    Boolean isPositive = False;
+    int val = 0;
+    char ch;
+    /* skip leading whitespace */
+#ifndef __UNIXOS2__
+    while ((ch = *string) == ' ' || ch == '\t') string++;
+#else
+    while ((ch = *string) == ' ' || ch == '\t' || ch == '\r') string++;
+#endif
+    while ((ch = *string++)) {
+	if (ch >= '0' && ch <= '9') {
+	    val *= 10;
+	    val += ch - '0';
+	    foundDigit = True;
+	    continue;
+	}
+	if (IsWhitespace(ch)) {
+	    if (!foundDigit) return False;
+	    /* make sure only trailing whitespace */
+	    while ((ch = *string++)) {
+		if (!IsWhitespace(ch))
+		    return False;
+	    }
+	    break;
+	}
+	if (ch == '-' && !foundDigit && !isNegative && !isPositive) {
+	    isNegative = True;
+	    continue;
+	}
+	if (ch == '+' && !foundDigit && !isNegative && !isPositive) {
+	    isPositive = True;
+	    continue;
+	}
+	return False;
+    }
+    if (ch == '\0') {
+	if (isNegative)
+	    *value = -val;
+	else
+	    *value = val;
+	return True;
+    }
+    return False;
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtIntToBoolean(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtIntToBoolean",XtCXtToolkitError,
+                  "Integer to Boolean conversion needs no extra arguments",
+                   (String *)NULL, (Cardinal *)NULL);
+    done(Boolean, (*(int *)fromVal->addr != 0));
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtIntToShort(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtIntToShort",XtCXtToolkitError,
+                  "Integer to Short conversion needs no extra arguments",
+                   (String *)NULL, (Cardinal *)NULL);
+    done(short, (*(int *)fromVal->addr));
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtStringToBoolean(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    String str = (String)fromVal->addr;
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtStringToBoolean",XtCXtToolkitError,
+                  "String to Boolean conversion needs no extra arguments",
+                   (String *)NULL, (Cardinal *)NULL);
+
+    if (   (CompareISOLatin1(str, "true") == 0)
+	|| (CompareISOLatin1(str, "yes") == 0)
+	|| (CompareISOLatin1(str, "on") == 0)
+	|| (CompareISOLatin1(str, "1") == 0))	donestr( Boolean, True, XtRBoolean );
+
+    if (   (CompareISOLatin1(str, "false") == 0)
+	|| (CompareISOLatin1(str, "no") == 0)
+	|| (CompareISOLatin1(str, "off") == 0)
+	|| (CompareISOLatin1(str, "0") == 0))	donestr( Boolean, False, XtRBoolean );
+
+    XtDisplayStringConversionWarning(dpy, str, XtRBoolean);
+    return False;
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtIntToBool(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtIntToBool",XtCXtToolkitError,
+                  "Integer to Bool conversion needs no extra arguments",
+                   (String *)NULL, (Cardinal *)NULL);
+    done(Bool, (*(int *)fromVal->addr != 0));
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtStringToBool(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    String str = (String)fromVal->addr;
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		XtNwrongParameters,"cvtStringToBool",
+		XtCXtToolkitError,
+                 "String to Bool conversion needs no extra arguments",
+                  (String *)NULL, (Cardinal *)NULL);
+
+    if (   (CompareISOLatin1(str, "true") == 0)
+	|| (CompareISOLatin1(str, "yes") == 0)
+	|| (CompareISOLatin1(str, "on") == 0)
+	|| (CompareISOLatin1(str, "1") == 0))	donestr( Bool, True, XtRBool );
+
+    if (   (CompareISOLatin1(str, "false") == 0)
+	|| (CompareISOLatin1(str, "no") == 0)
+	|| (CompareISOLatin1(str, "off") == 0)
+	|| (CompareISOLatin1(str, "0") == 0))	donestr( Bool, False, XtRBool );
+
+    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRBool);
+    return False;
+}
+
+XtConvertArgRec const colorConvertArgs[] = {
+    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
+     sizeof(Screen *)},
+    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
+     sizeof(Colormap)}
+};
+
+
+/* ARGSUSED */
+Boolean XtCvtIntToColor(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    XColor	c;
+    Screen	*screen;
+    Colormap	colormap;
+
+    if (*num_args != 2) {
+      XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	 XtNwrongParameters,"cvtIntOrPixelToXColor",XtCXtToolkitError,
+         "Pixel to color conversion needs screen and colormap arguments",
+          (String *)NULL, (Cardinal *)NULL);
+      return False;
+    }
+    screen = *((Screen **) args[0].addr);
+    colormap = *((Colormap *) args[1].addr);
+    c.pixel = *(int *)fromVal->addr;
+
+    XQueryColor(DisplayOfScreen(screen), colormap, &c);
+    done(XColor, c);
+}
+
+
+Boolean XtCvtStringToPixel(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    String	    str = (String)fromVal->addr;
+    XColor	    screenColor;
+    XColor	    exactColor;
+    Screen	    *screen;
+    XtPerDisplay    pd = _XtGetPerDisplay(dpy);
+    Colormap	    colormap;
+    Status	    status;
+    String          params[1];
+    Cardinal	    num_params=1;
+
+    if (*num_args != 2) {
+     XtAppWarningMsg(pd->appContext, XtNwrongParameters, "cvtStringToPixel",
+		     XtCXtToolkitError,
+	"String to pixel conversion needs screen and colormap arguments",
+        (String *)NULL, (Cardinal *)NULL);
+     return False;
+    }
+
+    screen = *((Screen **) args[0].addr);
+    colormap = *((Colormap *) args[1].addr);
+
+    if (CompareISOLatin1(str, XtDefaultBackground) == 0) {
+	*closure_ret = False;
+	if (pd->rv) donestr(Pixel, BlackPixelOfScreen(screen), XtRPixel)
+	else	    donestr(Pixel, WhitePixelOfScreen(screen), XtRPixel);
+    }
+    if (CompareISOLatin1(str, XtDefaultForeground) == 0) {
+	*closure_ret = False;
+	if (pd->rv) donestr(Pixel, WhitePixelOfScreen(screen), XtRPixel)
+        else	    donestr(Pixel, BlackPixelOfScreen(screen), XtRPixel);
+    }
+
+    status = XAllocNamedColor(DisplayOfScreen(screen), colormap,
+			      (char*)str, &screenColor, &exactColor);
+    if (status == 0) {
+	String msg, type;
+	params[0] = str;
+	/* Server returns a specific error code but Xlib discards it.  Ugh */
+	if (XLookupColor(DisplayOfScreen(screen), colormap, (char*)str,
+			 &exactColor, &screenColor)) {
+	    type = "noColormap";
+	    msg = "Cannot allocate colormap entry for \"%s\"";
+	}
+	else {
+	    type = "badValue";
+	    msg = "Color name \"%s\" is not defined";
+	}
+
+	XtAppWarningMsg(pd->appContext, type, "cvtStringToPixel",
+			XtCXtToolkitError, msg, params, &num_params);
+	*closure_ret = False;
+	return False;
+    } else {
+	*closure_ret = (char*)True;
+        donestr(Pixel, screenColor.pixel, XtRPixel);
+    }
+}
+
+/* ARGSUSED */
+static void FreePixel(
+    XtAppContext app,
+    XrmValuePtr	toVal,
+    XtPointer	closure,
+    XrmValuePtr	args,
+    Cardinal	*num_args)
+{
+    Screen	    *screen;
+    Colormap	    colormap;
+
+    if (*num_args != 2) {
+     XtAppWarningMsg(app, XtNwrongParameters,"freePixel",XtCXtToolkitError,
+	"Freeing a pixel requires screen and colormap arguments",
+        (String *)NULL, (Cardinal *)NULL);
+     return;
+    }
+
+    screen = *((Screen **) args[0].addr);
+    colormap = *((Colormap *) args[1].addr);
+
+    if (closure) {
+	XFreeColors( DisplayOfScreen(screen), colormap,
+		     (unsigned long*)toVal->addr, 1, (unsigned long)0
+		    );
+    }
+}
+
+
+/* no longer used by Xt, but it's in the spec */
+XtConvertArgRec const screenConvertArg[] = {
+    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
+     sizeof(Screen *)}
+};
+
+/*ARGSUSED*/
+static void FetchDisplayArg(
+    Widget widget,
+    Cardinal *size,
+    XrmValue* value)
+{
+    if (widget == NULL)
+	XtErrorMsg("missingWidget", "fetchDisplayArg", XtCXtToolkitError,
+		   "FetchDisplayArg called without a widget to reference",
+		   (String*)NULL, (Cardinal*)NULL);
+        /* can't return any useful Display and caller will de-ref NULL,
+	   so aborting is the only useful option */
+
+    value->size = sizeof(Display*);
+    value->addr = (XPointer)&DisplayOfScreen(XtScreenOfObject(widget));
+}
+
+static XtConvertArgRec const displayConvertArg[] = {
+    {XtProcedureArg, (XtPointer)FetchDisplayArg, 0},
+};
+
+/*ARGSUSED*/
+Boolean XtCvtStringToCursor(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    static const struct _CursorName {
+	const char	*name;
+	unsigned int	shape;
+    } cursor_names[] = {
+			{"X_cursor",		XC_X_cursor},
+			{"arrow",		XC_arrow},
+			{"based_arrow_down",	XC_based_arrow_down},
+			{"based_arrow_up",	XC_based_arrow_up},
+			{"boat",		XC_boat},
+			{"bogosity",		XC_bogosity},
+			{"bottom_left_corner",	XC_bottom_left_corner},
+			{"bottom_right_corner",	XC_bottom_right_corner},
+			{"bottom_side",		XC_bottom_side},
+			{"bottom_tee",		XC_bottom_tee},
+			{"box_spiral",		XC_box_spiral},
+			{"center_ptr",		XC_center_ptr},
+			{"circle",		XC_circle},
+			{"clock",		XC_clock},
+			{"coffee_mug",		XC_coffee_mug},
+			{"cross",		XC_cross},
+			{"cross_reverse",	XC_cross_reverse},
+			{"crosshair",		XC_crosshair},
+			{"diamond_cross",	XC_diamond_cross},
+			{"dot",			XC_dot},
+			{"dotbox",		XC_dotbox},
+			{"double_arrow",	XC_double_arrow},
+			{"draft_large",		XC_draft_large},
+			{"draft_small",		XC_draft_small},
+			{"draped_box",		XC_draped_box},
+			{"exchange",		XC_exchange},
+			{"fleur",		XC_fleur},
+			{"gobbler",		XC_gobbler},
+			{"gumby",		XC_gumby},
+			{"hand1",		XC_hand1},
+			{"hand2",		XC_hand2},
+			{"heart",		XC_heart},
+			{"icon",		XC_icon},
+			{"iron_cross",		XC_iron_cross},
+			{"left_ptr",		XC_left_ptr},
+			{"left_side",		XC_left_side},
+			{"left_tee",		XC_left_tee},
+			{"leftbutton",		XC_leftbutton},
+			{"ll_angle",		XC_ll_angle},
+			{"lr_angle",		XC_lr_angle},
+			{"man",			XC_man},
+			{"middlebutton",	XC_middlebutton},
+			{"mouse",		XC_mouse},
+			{"pencil",		XC_pencil},
+			{"pirate",		XC_pirate},
+			{"plus",		XC_plus},
+			{"question_arrow",	XC_question_arrow},
+			{"right_ptr",		XC_right_ptr},
+			{"right_side",		XC_right_side},
+			{"right_tee",		XC_right_tee},
+			{"rightbutton",		XC_rightbutton},
+			{"rtl_logo",		XC_rtl_logo},
+			{"sailboat",		XC_sailboat},
+			{"sb_down_arrow",	XC_sb_down_arrow},
+			{"sb_h_double_arrow",	XC_sb_h_double_arrow},
+			{"sb_left_arrow",	XC_sb_left_arrow},
+			{"sb_right_arrow",	XC_sb_right_arrow},
+			{"sb_up_arrow",		XC_sb_up_arrow},
+			{"sb_v_double_arrow",	XC_sb_v_double_arrow},
+			{"shuttle",		XC_shuttle},
+			{"sizing",		XC_sizing},
+			{"spider",		XC_spider},
+			{"spraycan",		XC_spraycan},
+			{"star",		XC_star},
+			{"target",		XC_target},
+			{"tcross",		XC_tcross},
+			{"top_left_arrow",	XC_top_left_arrow},
+			{"top_left_corner",	XC_top_left_corner},
+			{"top_right_corner",	XC_top_right_corner},
+			{"top_side",		XC_top_side},
+			{"top_tee",		XC_top_tee},
+			{"trek",		XC_trek},
+			{"ul_angle",		XC_ul_angle},
+			{"umbrella",		XC_umbrella},
+			{"ur_angle",		XC_ur_angle},
+			{"watch",		XC_watch},
+			{"xterm",		XC_xterm},
+    };
+    const struct _CursorName *nP;
+    char *name = (char *)fromVal->addr;
+    register Cardinal i;
+
+    if (*num_args != 1) {
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	     XtNwrongParameters,"cvtStringToCursor",XtCXtToolkitError,
+             "String to cursor conversion needs display argument",
+              (String *)NULL, (Cardinal *)NULL);
+	return False;
+    }
+
+    for (i=0, nP=cursor_names; i < XtNumber(cursor_names); i++, nP++ ) {
+	if (strcmp(name, nP->name) == 0) {
+	    Display *display = *(Display**)args[0].addr;
+	    Cursor cursor = XCreateFontCursor(display, nP->shape );
+	    donestr(Cursor, cursor, XtRCursor);
+	}
+    }
+    XtDisplayStringConversionWarning(dpy, name, XtRCursor);
+    return False;
+}
+
+/* ARGSUSED */
+static void FreeCursor(
+    XtAppContext app,
+    XrmValuePtr	toVal,
+    XtPointer	closure,	/* unused */
+    XrmValuePtr	args,
+    Cardinal	*num_args)
+{
+    Display*	display;
+
+    if (*num_args != 1) {
+     XtAppWarningMsg(app,
+	     XtNwrongParameters,"freeCursor",XtCXtToolkitError,
+             "Free Cursor requires display argument",
+              (String *)NULL, (Cardinal *)NULL);
+     return;
+    }
+
+    display = *(Display**)args[0].addr;
+    XFreeCursor( display, *(Cursor*)toVal->addr );
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToDisplay(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    Display	*d;
+
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtStringToDisplay",XtCXtToolkitError,
+                  "String to Display conversion needs no extra arguments",
+                   (String *)NULL, (Cardinal *)NULL);
+
+    d = XOpenDisplay((char *)fromVal->addr);
+    if (d != NULL)
+	donestr(Display*, d, XtRDisplay);
+
+    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRDisplay);
+    return False;
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtStringToFile(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    FILE *f;
+
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		 XtNwrongParameters,"cvtStringToFile",XtCXtToolkitError,
+                 "String to File conversion needs no extra arguments",
+                 (String *) NULL, (Cardinal *)NULL);
+
+    f = fopen((char *)fromVal->addr, "r");
+    if (f != NULL)
+	donestr(FILE*, f, XtRFile);
+
+    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRFile);
+    return False;
+}
+
+/* ARGSUSED */
+static void FreeFile(
+    XtAppContext app,
+    XrmValuePtr	toVal,
+    XtPointer	closure,	/* unused */
+    XrmValuePtr	args,		/* unused */
+    Cardinal	*num_args)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(app,
+		 XtNwrongParameters,"freeFile",XtCXtToolkitError,
+                 "Free File requires no extra arguments",
+                 (String *) NULL, (Cardinal *)NULL);
+
+    fclose( *(FILE**)toVal->addr );
+}
+
+/*ARGSUSED*/
+Boolean XtCvtIntToFloat(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtIntToFloat",XtCXtToolkitError,
+                  "Integer to Float conversion needs no extra arguments",
+                   (String *)NULL, (Cardinal *)NULL);
+    done(float, (*(int *)fromVal->addr));
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToFloat(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    int ret;
+    float f, nan;
+
+#ifndef ISC /* On ISC this generates a core dump :-( at least with gs */
+    /* depending on the system this may or may not do anything useful */
+    (void) sscanf ("NaNS", "%g",
+		   toVal->addr != NULL ? (float*) toVal->addr : &nan);
+#endif
+
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		 XtNwrongParameters,"cvtStringToFloat",XtCXtToolkitError,
+                 "String to Float conversion needs no extra arguments",
+                 (String *) NULL, (Cardinal *)NULL);
+
+    ret = sscanf (fromVal->addr, "%g", &f);
+    if (ret == 0) {
+	if (toVal->addr != NULL && toVal->size == sizeof nan)
+	    *(float*)toVal->addr = nan;
+	XtDisplayStringConversionWarning (dpy, (char*) fromVal->addr, XtRFloat);
+	return False;
+    }
+    donestr(float, f, XtRFloat);
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToFont(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    Font	f;
+    Display*	display;
+
+    if (*num_args != 1) {
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	     XtNwrongParameters,"cvtStringToFont",XtCXtToolkitError,
+             "String to font conversion needs display argument",
+              (String *) NULL, (Cardinal *)NULL);
+	return False;
+    }
+
+    display = *(Display**)args[0].addr;
+
+    if (CompareISOLatin1((String)fromVal->addr, XtDefaultFont) != 0) {
+	f = XLoadFont(display, (char *)fromVal->addr);
+	if (f != 0) {
+  Done:	    donestr( Font, f, XtRFont );
+	}
+	XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRFont);
+    }
+    /* try and get the default font */
+
+    {
+	XrmName xrm_name[2];
+	XrmClass xrm_class[2];
+	XrmRepresentation rep_type;
+	XrmValue value;
+
+	xrm_name[0] = XrmPermStringToQuark ("xtDefaultFont");
+	xrm_name[1] = 0;
+	xrm_class[0] = XrmPermStringToQuark ("XtDefaultFont");
+	xrm_class[1] = 0;
+	if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
+			    &rep_type, &value)) {
+	    if (rep_type == _XtQString) {
+		f = XLoadFont(display, (char *)value.addr);
+		if (f != 0)
+		    goto Done;
+		else
+		    XtDisplayStringConversionWarning(dpy, (char *)value.addr,
+						     XtRFont);
+	    } else if (rep_type == XtQFont) {
+		f = *(Font*)value.addr;
+		goto Done;
+	    } else if (rep_type == XtQFontStruct) {
+		f = ((XFontStruct*)value.addr)->fid;
+		goto Done;
+	    }
+	}
+    }
+    /* Should really do XListFonts, but most servers support this */
+    f = XLoadFont(display, "-*-*-*-R-*-*-*-120-*-*-*-*-ISO8859-*");
+    if (f != 0)
+	goto Done;
+
+    XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		    "noFont","cvtStringToFont",XtCXtToolkitError,
+		    "Unable to load any usable ISO8859 font",
+		    (String *) NULL, (Cardinal *)NULL);
+
+    return False;
+}
+
+/* ARGSUSED */
+static void FreeFont(
+    XtAppContext app,
+    XrmValuePtr	toVal,
+    XtPointer	closure,	/* unused */
+    XrmValuePtr	args,
+    Cardinal	*num_args)
+{
+    Display *display;
+    if (*num_args != 1) {
+	XtAppWarningMsg(app,
+	     XtNwrongParameters,"freeFont",XtCXtToolkitError,
+             "Free Font needs display argument",
+              (String *) NULL, (Cardinal *)NULL);
+	return;
+    }
+
+    display = *(Display**)args[0].addr;
+    XUnloadFont( display, *(Font*)toVal->addr );
+}
+
+/*ARGSUSED*/
+Boolean XtCvtIntToFont(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	   XtNwrongParameters,"cvtIntToFont",XtCXtToolkitError,
+           "Integer to Font conversion needs no extra arguments",
+            (String *) NULL, (Cardinal *)NULL);
+    done(Font, *(int*)fromVal->addr);
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToFontSet(
+    Display*    dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer   *closure_ret)
+{
+    XFontSet  f;
+    Display*  display;
+    char**    missing_charset_list;
+    int       missing_charset_count;
+    char*     def_string;
+
+    if (*num_args != 2) {
+      XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+           XtNwrongParameters,"cvtStringToFontSet",XtCXtToolkitError,
+             "String to FontSet conversion needs display and locale arguments",
+              (String *) NULL, (Cardinal *)NULL);
+      return False;
+    }
+
+    display = *(Display**)args[0].addr;
+
+    if (CompareISOLatin1((String)fromVal->addr, XtDefaultFontSet) != 0) {
+      f = XCreateFontSet(display, (char *)fromVal->addr,
+              &missing_charset_list, &missing_charset_count, &def_string);
+        /* Free any returned missing charset list */
+      if (missing_charset_count) {
+          XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                 XtNmissingCharsetList,"cvtStringToFontSet",XtCXtToolkitError,
+                 "Missing charsets in String to FontSet conversion",
+                 (String *) NULL, (Cardinal *)NULL);
+            XFreeStringList(missing_charset_list);
+      }
+      if (f != NULL) {
+  Done:           donestr( XFontSet, f, XtRFontSet );
+      }
+      XtDisplayStringConversionWarning(dpy, (char *)fromVal->addr, XtRFontSet);
+    }
+    /* try and get the default fontset */
+
+    {
+      XrmName xrm_name[2];
+      XrmClass xrm_class[2];
+      XrmRepresentation rep_type;
+      XrmValue value;
+
+      xrm_name[0] = XrmPermStringToQuark ("xtDefaultFontSet");
+      xrm_name[1] = 0;
+      xrm_class[0] = XrmPermStringToQuark ("XtDefaultFontSet");
+      xrm_class[1] = 0;
+      if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
+                          &rep_type, &value)) {
+          if (rep_type == _XtQString) {
+
+              f = XCreateFontSet(display, (char *)value.addr,
+				 &missing_charset_list, &missing_charset_count,
+				 &def_string);
+                /* Free any returned missing charset list */
+              if (missing_charset_count) {
+                  XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+			 XtNmissingCharsetList,"cvtStringToFontSet",
+			 XtCXtToolkitError,
+			 "Missing charsets in String to FontSet conversion",
+                         (String *) NULL, (Cardinal *)NULL);
+		  XFreeStringList(missing_charset_list);
+              }
+              if (f != NULL)
+                  goto Done;
+              else
+                  XtDisplayStringConversionWarning(dpy, (char *)value.addr,
+                                                   XtRFontSet);
+          } else if (rep_type == XtQFontSet) {
+              f = *(XFontSet*)value.addr;
+              goto Done;
+          }
+      }
+  }
+
+    /* Should really do XListFonts, but most servers support this */
+    f = XCreateFontSet(display, "-*-*-*-R-*-*-*-120-*-*-*-*,*",
+          &missing_charset_list, &missing_charset_count, &def_string);
+
+    /* Free any returned missing charset list */
+    if (missing_charset_count) {
+      XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+             XtNmissingCharsetList,"cvtStringToFontSet",XtCXtToolkitError,
+             "Missing charsets in String to FontSet conversion",
+             (String *) NULL, (Cardinal *)NULL);
+        XFreeStringList(missing_charset_list);
+    }
+    if (f != NULL)
+      goto Done;
+
+    XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+           "noFont","cvtStringToFontSet",XtCXtToolkitError,
+             "Unable to load any usable fontset",
+              (String *) NULL, (Cardinal *)NULL);
+
+    return False;
+}
+
+/*ARGSUSED*/
+static void FreeFontSet(
+    XtAppContext	app,
+    XrmValuePtr		toVal,
+    XtPointer		closure,        /* unused */
+    XrmValuePtr		args,
+    Cardinal		*num_args)
+{
+    Display *display;
+    if (*num_args != 2) {
+      XtAppWarningMsg(app,
+           XtNwrongParameters,"freeFontSet",XtCXtToolkitError,
+             "FreeFontSet needs display and locale arguments",
+              (String *) NULL, (Cardinal *)NULL);
+      return;
+    }
+
+    display = *(Display**)args[0].addr;
+    XFreeFontSet( display, *(XFontSet*)toVal->addr );
+}
+
+/*ARGSUSED*/
+static void FetchLocaleArg(
+    Widget widget,	/* unused */
+    Cardinal *size,	/* unused */
+    XrmValue *value)
+{
+    static XrmString locale;
+
+    locale = XrmQuarkToString(XrmStringToQuark
+			      (setlocale(LC_CTYPE, (char*)NULL)));
+    value->size = sizeof(XrmString);
+    value->addr = (XPointer)&locale;
+}
+
+static XtConvertArgRec const localeDisplayConvertArgs[] = {
+    {XtProcedureArg, (XtPointer)FetchDisplayArg, 0},
+    {XtProcedureArg, (XtPointer)FetchLocaleArg, 0},
+};
+
+
+/*ARGSUSED*/
+Boolean
+XtCvtStringToFontStruct(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    XFontStruct	    *f;
+    Display*	display;
+
+    if (*num_args != 1) {
+     XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	     XtNwrongParameters,"cvtStringToFontStruct",XtCXtToolkitError,
+             "String to font conversion needs display argument",
+              (String *) NULL, (Cardinal *)NULL);
+     return False;
+    }
+
+    display = *(Display**)args[0].addr;
+
+    if (CompareISOLatin1((String)fromVal->addr, XtDefaultFont) != 0) {
+	f = XLoadQueryFont(display, (char *)fromVal->addr);
+	if (f != NULL) {
+  Done:	    donestr( XFontStruct*, f, XtRFontStruct);
+	}
+
+	XtDisplayStringConversionWarning(dpy, (char*)fromVal->addr,
+					 XtRFontStruct);
+    }
+
+    /* try and get the default font */
+
+    {
+	XrmName xrm_name[2];
+	XrmClass xrm_class[2];
+	XrmRepresentation rep_type;
+	XrmValue value;
+
+	xrm_name[0] = XrmPermStringToQuark ("xtDefaultFont");
+	xrm_name[1] = 0;
+	xrm_class[0] = XrmPermStringToQuark ("XtDefaultFont");
+	xrm_class[1] = 0;
+	if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
+			    &rep_type, &value)) {
+	    if (rep_type == _XtQString) {
+		f = XLoadQueryFont(display, (char*)value.addr);
+		if (f != NULL)
+		    goto Done;
+		else
+		    XtDisplayStringConversionWarning(dpy, (char*)value.addr,
+						     XtRFontStruct);
+	    } else if (rep_type == XtQFont) {
+		f = XQueryFont(display, *(Font*)value.addr );
+		if (f != NULL) goto Done;
+	    } else if (rep_type == XtQFontStruct) {
+		f = (XFontStruct*)value.addr;
+		goto Done;
+	    }
+	}
+    }
+    /* Should really do XListFonts, but most servers support this */
+    f = XLoadQueryFont(display, "-*-*-*-R-*-*-*-120-*-*-*-*-ISO8859-*");
+    if (f != NULL)
+	goto Done;
+
+    XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	     "noFont","cvtStringToFontStruct",XtCXtToolkitError,
+             "Unable to load any usable ISO8859 font",
+              (String *) NULL, (Cardinal *)NULL);
+
+    return False;
+}
+
+/* ARGSUSED */
+static void FreeFontStruct(
+    XtAppContext app,
+    XrmValuePtr	toVal,
+    XtPointer	closure,	/* unused */
+    XrmValuePtr	args,
+    Cardinal	*num_args)
+{
+    Display *display;
+    if (*num_args != 1) {
+     XtAppWarningMsg(app,
+	     XtNwrongParameters,"freeFontStruct",XtCXtToolkitError,
+             "Free FontStruct requires display argument",
+              (String *) NULL, (Cardinal *)NULL);
+     return;
+    }
+
+    display = *(Display**)args[0].addr;
+    XFreeFont( display, *(XFontStruct**)toVal->addr );
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToInt(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    int	i;
+
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtStringToInt",XtCXtToolkitError,
+                  "String to Integer conversion needs no extra arguments",
+                  (String *) NULL, (Cardinal *)NULL);
+    if (IsInteger((String)fromVal->addr, &i))
+	donestr(int, i, XtRInt);
+
+    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRInt);
+    return False;
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToShort(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer	*closure_ret)
+{
+    int i;
+
+    if (*num_args != 0)
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	  XtNwrongParameters,"cvtStringToShort",XtCXtToolkitError,
+          "String to Integer conversion needs no extra arguments",
+           (String *) NULL, (Cardinal *)NULL);
+    if (IsInteger((String)fromVal->addr, &i))
+        donestr(short, (short)i, XtRShort);
+
+    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRShort);
+    return False;
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToDimension(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer	*closure_ret)
+{
+    int i;
+
+    if (*num_args != 0)
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	  XtNwrongParameters,"cvtStringToDimension",XtCXtToolkitError,
+          "String to Dimension conversion needs no extra arguments",
+           (String *) NULL, (Cardinal *)NULL);
+    if (IsInteger((String)fromVal->addr, &i)) {
+        if ( i < 0 )
+            XtDisplayStringConversionWarning(dpy, (char*)fromVal->addr,
+					     XtRDimension);
+        donestr(Dimension, (Dimension)i, XtRDimension);
+    }
+    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRDimension);
+    return False;
+}
+
+/*ARGSUSED*/
+Boolean XtCvtIntToUnsignedChar(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtIntToUnsignedChar",XtCXtToolkitError,
+                  "Integer to UnsignedChar conversion needs no extra arguments",
+                   (String *)NULL, (Cardinal *)NULL);
+    done(unsigned char, (*(int *)fromVal->addr));
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtStringToUnsignedChar(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer	*closure_ret)
+{
+    int i;
+
+    if (*num_args != 0)
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtStringToUnsignedChar",XtCXtToolkitError,
+                  "String to Integer conversion needs no extra arguments",
+                   (String *) NULL, (Cardinal *)NULL);
+    if (IsInteger((String)fromVal->addr, &i)) {
+        if ( i < 0 || i > 255 )
+            XtDisplayStringConversionWarning(dpy, (char*)fromVal->addr,
+					     XtRUnsignedChar);
+        donestr(unsigned char, i, XtRUnsignedChar);
+    }
+    XtDisplayStringConversionWarning(dpy, (char*)fromVal->addr,
+				     XtRUnsignedChar);
+    return False;
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtColorToPixel(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtXColorToPixel",XtCXtToolkitError,
+                  "Color to Pixel conversion needs no extra arguments",
+                   (String *) NULL, (Cardinal *)NULL);
+    done(Pixel, ((XColor *)fromVal->addr)->pixel);
+}
+
+/*ARGSUSED*/
+Boolean XtCvtIntToPixel(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtIntToPixel",XtCXtToolkitError,
+                  "Integer to Pixel conversion needs no extra arguments",
+                   (String *) NULL, (Cardinal *)NULL);
+    done(Pixel, *(int*)fromVal->addr);
+}
+
+/*ARGSUSED*/
+Boolean XtCvtIntToPixmap(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer	*closure_ret)
+{
+    if (*num_args != 0)
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtIntToPixmap",XtCXtToolkitError,
+                  "Integer to Pixmap conversion needs no extra arguments",
+                   (String *) NULL, (Cardinal *)NULL);
+    done(Pixmap, *(Pixmap*)fromVal->addr);
+}
+
+#ifdef MOTIFBC
+void LowerCase(register char  *source, register *dest)
+{
+    register char ch;
+    int i;
+
+    for (i = 0; (ch = *source) != 0 && i < 999; source++, dest++, i++) {
+    	if ('A' <= ch && ch <= 'Z')
+	    *dest = ch - 'A' + 'a';
+	else
+	    *dest = ch;
+    }
+    *dest = 0;
+}
+#endif
+
+static int CompareISOLatin1 (char *first, char *second)
+{
+    register unsigned char *ap, *bp;
+
+    for (ap = (unsigned char *) first, bp = (unsigned char *) second;
+	 *ap && *bp; ap++, bp++) {
+	register unsigned char a, b;
+
+	if ((a = *ap) != (b = *bp)) {
+	    /* try lowercasing and try again */
+
+	    if ((a >= XK_A) && (a <= XK_Z))
+	      a += (XK_a - XK_A);
+	    else if ((a >= XK_Agrave) && (a <= XK_Odiaeresis))
+	      a += (XK_agrave - XK_Agrave);
+	    else if ((a >= XK_Ooblique) && (a <= XK_Thorn))
+	      a += (XK_oslash - XK_Ooblique);
+
+	    if ((b >= XK_A) && (b <= XK_Z))
+	      b += (XK_a - XK_A);
+	    else if ((b >= XK_Agrave) && (b <= XK_Odiaeresis))
+	      b += (XK_agrave - XK_Agrave);
+	    else if ((b >= XK_Ooblique) && (b <= XK_Thorn))
+	      b += (XK_oslash - XK_Ooblique);
+
+	    if (a != b) break;
+	}
+    }
+    return (((int) *bp) - ((int) *ap));
+}
+
+static void CopyISOLatin1Lowered(char *dst, char *src)
+{
+    unsigned char *dest, *source;
+
+    dest = (unsigned char *) dst; source = (unsigned char *) src;
+
+    for ( ; *source; source++, dest++) {
+	if (*source >= XK_A  && *source <= XK_Z)
+	    *dest = *source + (XK_a - XK_A);
+	else if (*source >= XK_Agrave && *source <= XK_Odiaeresis)
+	    *dest = *source + (XK_agrave - XK_Agrave);
+	else if (*source >= XK_Ooblique && *source <= XK_Thorn)
+	    *dest = *source + (XK_oslash - XK_Ooblique);
+	else
+	    *dest = *source;
+    }
+    *dest = '\0';
+}
+
+/*ARGSUSED*/
+Boolean
+XtCvtStringToInitialState(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    String str = (String)fromVal->addr;
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtStringToInitialState",XtCXtToolkitError,
+                  "String to InitialState conversion needs no extra arguments",
+                   (String *) NULL, (Cardinal *)NULL);
+
+    if (CompareISOLatin1(str, "NormalState") == 0) donestr(int, NormalState, XtRInitialState);
+    if (CompareISOLatin1(str, "IconicState") == 0) donestr(int, IconicState, XtRInitialState);
+    {
+	int val;
+	if (IsInteger(str, &val)) donestr( int, val, XtRInitialState );
+    }
+    XtDisplayStringConversionWarning(dpy, str, XtRInitialState);
+    return False;
+}
+
+static XtConvertArgRec const visualConvertArgs[] = {
+    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
+     sizeof(Screen *)},
+    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.depth),
+     sizeof(Cardinal)}
+};
+
+/*ARGSUSED*/
+Boolean XtCvtStringToVisual(
+    Display*	dpy,
+    XrmValuePtr args,		/* Screen, depth */
+    Cardinal    *num_args,	/* 2 */
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)	/* unused */
+{
+    String str = (String)fromVal->addr;
+    int vc;
+    XVisualInfo vinfo;
+    if (*num_args != 2) {
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtStringToVisual",XtCXtToolkitError,
+                  "String to Visual conversion needs screen and depth arguments",
+                   (String *) NULL, (Cardinal *)NULL);
+	return False;
+    }
+
+         if (CompareISOLatin1(str, "StaticGray") == 0)	vc = StaticGray;
+    else if (CompareISOLatin1(str, "StaticColor") == 0)	vc = StaticColor;
+    else if (CompareISOLatin1(str, "TrueColor") == 0)	vc = TrueColor;
+    else if (CompareISOLatin1(str, "GrayScale") == 0)	vc = GrayScale;
+    else if (CompareISOLatin1(str, "PseudoColor") == 0)	vc = PseudoColor;
+    else if (CompareISOLatin1(str, "DirectColor") == 0)	vc = DirectColor;
+    else if (!IsInteger(str, &vc)) {
+	XtDisplayStringConversionWarning(dpy, str, "Visual class name");
+	return False;
+    }
+
+    if (XMatchVisualInfo( XDisplayOfScreen((Screen*)*(Screen**)args[0].addr),
+		     XScreenNumberOfScreen((Screen*)*(Screen**)args[0].addr),
+		     (int)*(int*)args[1].addr,
+		     vc,
+		     &vinfo) ) {
+	donestr( Visual*, vinfo.visual, XtRVisual );
+    }
+    else {
+	String params[2];
+	Cardinal num_params = 2;
+	params[0] = str;
+	params[1] =
+	    DisplayString(XDisplayOfScreen((Screen*)*(Screen**)args[0].addr));
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNconversionError, "stringToVisual", XtCXtToolkitError,
+                  "Cannot find Visual of class %s for display %s",
+		  params, &num_params );
+	return False;
+    }
+}
+
+
+/*ARGSUSED*/
+Boolean XtCvtStringToAtom(
+    Display*	dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr	fromVal,
+    XrmValuePtr	toVal,
+    XtPointer	*closure_ret)
+{
+    Atom atom;
+    if (*num_args != 1) {
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+		  XtNwrongParameters,"cvtStringToAtom",XtCXtToolkitError,
+                  "String to Atom conversion needs Display argument",
+                   (String *) NULL, (Cardinal *)NULL);
+	return False;
+    }
+
+    atom =  XInternAtom( *(Display**)args->addr, (char*)fromVal->addr, False );
+    donestr(Atom, atom, XtRAtom);
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToDirectoryString(
+    Display	*dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer	*closure_ret)
+{
+    String str;
+    char directory[PATH_MAX+1];
+
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+           XtNwrongParameters,"cvtStringToDirectoryString",XtCXtToolkitError,
+           "String to DirectoryString conversion needs no extra arguments",
+           (String *)NULL, (Cardinal *)NULL);
+
+    str = (String)fromVal->addr;
+    if (CompareISOLatin1(str, "XtCurrentDirectory") == 0) {
+	/* uglier, but does not depend on compiler knowing return type */
+#if !defined(X_NOT_POSIX) || defined(SYSV) || defined(WIN32)
+	if (getcwd(directory, PATH_MAX + 1))
+	    str = directory;
+#else
+	if (getwd(directory))
+	    str = directory;
+#endif
+	if (!str) {
+	    if (errno == EACCES)
+		errno = 0;	    /* reset errno */
+	    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
+					     XtRDirectoryString);
+	    return False;
+	}
+    }
+
+    /* Since memory from the resource database or from static buffers of
+     * system libraries may be freed or overwritten, allocate memory.
+     * The memory is freed when all cache references are released.
+     */
+    str = XtNewString(str);
+    donestr(String, str, XtRDirectoryString);
+}
+
+/*ARGSUSED*/
+static void FreeDirectoryString(
+    XtAppContext app,
+    XrmValuePtr	toVal,
+    XtPointer	closure,	/* unused */
+    XrmValuePtr	args,
+    Cardinal	*num_args)
+{
+    if (*num_args != 0)
+	XtAppWarningMsg(app,
+		 XtNwrongParameters,"freeDirectoryString",XtCXtToolkitError,
+		 "Free Directory String requires no extra arguments",
+                 (String *) NULL, (Cardinal *) NULL);
+
+    XtFree((char *) toVal->addr);
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToRestartStyle(
+    Display	*dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer	*closure_ret)
+{
+    String str = (String)fromVal->addr;
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+	      XtNwrongParameters,"cvtStringToRestartStyle",XtCXtToolkitError,
+              "String to RestartStyle conversion needs no extra arguments",
+              (String *)NULL, (Cardinal *)NULL);
+
+    if (CompareISOLatin1(str, "RestartIfRunning") == 0)
+	donestr(unsigned char, SmRestartIfRunning, XtRRestartStyle);
+    if (CompareISOLatin1(str, "RestartAnyway") == 0)
+	donestr(unsigned char, SmRestartAnyway, XtRRestartStyle);
+    if (CompareISOLatin1(str, "RestartImmediately") == 0)
+	donestr(unsigned char, SmRestartImmediately, XtRRestartStyle);
+    if (CompareISOLatin1(str, "RestartNever") == 0)
+	donestr(unsigned char, SmRestartNever, XtRRestartStyle);
+    XtDisplayStringConversionWarning(dpy, str, XtRRestartStyle);
+    return False;
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToCommandArgArray(
+    Display	*dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer	*closure_ret)
+{
+    String *strarray, *ptr;
+    char *src;
+    char *dst, *dst_str;
+    char *start;
+    int tokens, len;
+
+    if (*num_args != 0)
+	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+            XtNwrongParameters,"cvtStringToCommandArgArray",XtCXtToolkitError,
+            "String to CommandArgArray conversion needs no extra arguments",
+            (String *)NULL, (Cardinal *)NULL);
+
+    src = fromVal->addr;
+    dst = dst_str = __XtMalloc((unsigned) strlen(src) + 1);
+    tokens = 0;
+
+    while (*src != '\0') {
+	/* skip whitespace */
+	while (IsWhitespace(*src) || IsNewline(*src))
+	    src++;
+	/* test for end of string */
+	if (*src == '\0')
+	    break;
+
+	/* start new token */
+	tokens++;
+	start = src;
+	while (*src != '\0' && !IsWhitespace(*src) && !IsNewline(*src)) {
+	    if (*src == '\\' &&
+		(IsWhitespace(*(src+1)) || IsNewline(*(src+1)))) {
+		len = src - start;
+		if (len) {
+		    /* copy preceeding part of token */
+		    memcpy(dst, start, len);
+		    dst += len;
+		}
+		/* skip backslash */
+		src++;
+		/* next part of token starts at whitespace */
+		start = src;
+	    }
+	    src++;
+	}
+	len = src - start;
+	if (len) {
+	    /* copy last part of token */
+	    memcpy(dst, start, len);
+	    dst += len;
+	}
+	*dst = '\0';
+	if (*src != '\0')
+	    dst++;
+    }
+
+    ptr = strarray = (String*) __XtMalloc((Cardinal)(tokens+1) * sizeof(String));
+    src = dst_str;
+    while (--tokens >= 0) {
+	*ptr = src;
+	ptr++;
+	if (tokens) {
+	    len = strlen(src);
+	    src = src + len + 1;
+	}
+    }
+    *ptr = NULL;
+
+    *closure_ret = (XtPointer) strarray;
+    donestr(char**, strarray, XtRCommandArgArray)
+}
+
+/*ARGSUSED*/
+static void ArgArrayDestructor(
+    XtAppContext app,
+    XrmValuePtr	toVal,
+    XtPointer	closure,
+    XrmValuePtr	args,
+    Cardinal	*num_args)
+{
+    String *strarray;
+
+    if (closure) {
+	strarray = (String*) closure;
+	XtFree(*strarray);
+	XtFree((char *) strarray);
+    }
+}
+
+/*ARGSUSED*/
+Boolean XtCvtStringToGravity (
+    Display* dpy,
+    XrmValuePtr args,
+    Cardinal    *num_args,
+    XrmValuePtr fromVal,
+    XrmValuePtr toVal,
+    XtPointer	*closure_ret)
+{
+    static struct _namepair {
+	XrmQuark quark;
+	char *name;
+	int gravity;
+    } names[] = {
+	{ NULLQUARK, "forget",		ForgetGravity },
+	{ NULLQUARK, "northwest",	NorthWestGravity },
+	{ NULLQUARK, "north",		NorthGravity },
+	{ NULLQUARK, "northeast",	NorthEastGravity },
+	{ NULLQUARK, "west",		WestGravity },
+	{ NULLQUARK, "center",		CenterGravity },
+	{ NULLQUARK, "east",		EastGravity },
+	{ NULLQUARK, "southwest",	SouthWestGravity },
+	{ NULLQUARK, "south",		SouthGravity },
+	{ NULLQUARK, "southeast",	SouthEastGravity },
+	{ NULLQUARK, "static",		StaticGravity },
+	{ NULLQUARK, "unmap",		UnmapGravity },
+	{ NULLQUARK, "0",		ForgetGravity },
+	{ NULLQUARK, "1",		NorthWestGravity },
+	{ NULLQUARK, "2",		NorthGravity },
+	{ NULLQUARK, "3",		NorthEastGravity },
+	{ NULLQUARK, "4",		WestGravity },
+	{ NULLQUARK, "5",		CenterGravity },
+	{ NULLQUARK, "6",		EastGravity },
+	{ NULLQUARK, "7",		SouthWestGravity },
+	{ NULLQUARK, "8",		SouthGravity },
+	{ NULLQUARK, "9",		SouthEastGravity },
+	{ NULLQUARK, "10",		StaticGravity },
+	{ NULLQUARK, NULL,		ForgetGravity }
+    };
+    static Boolean haveQuarks = FALSE;
+    char lowerName[40];
+    XrmQuark q;
+    char *s;
+    struct _namepair *np;
+
+    if (*num_args != 0) {
+        XtAppWarningMsg(XtDisplayToApplicationContext (dpy),
+			"wrongParameters","cvtStringToGravity","XtToolkitError",
+			"String to Gravity conversion needs no extra arguments",
+			(String *) NULL, (Cardinal *)NULL);
+	return False;
+    }
+    if (!haveQuarks) {
+	for (np = names; np->name; np++) {
+	    np->quark = XrmPermStringToQuark (np->name);
+	}
+	haveQuarks = TRUE;
+    }
+    s = (char *) fromVal->addr;
+    if (strlen(s) < sizeof lowerName) {
+	CopyISOLatin1Lowered (lowerName, s);
+	q = XrmStringToQuark (lowerName);
+	for (np = names; np->name; np++)
+	    if (np->quark == q) donestr(int, np->gravity, XtRGravity);
+    }
+    XtDisplayStringConversionWarning(dpy, (char *)fromVal->addr, XtRGravity);
+    return False;
+}
+
+void _XtAddDefaultConverters(
+    ConverterTable table)
+{
+#define Add(from, to, proc, convert_args, num_args, cache) \
+    _XtTableAddConverter(table, from, to, proc, \
+	    (XtConvertArgList) convert_args, (Cardinal)num_args, \
+	    True, cache, (XtDestructor)NULL, True)
+
+#define Add2(from, to, proc, convert_args, num_args, cache, destructor) \
+    _XtTableAddConverter(table, from, to, proc, \
+	    (XtConvertArgList) convert_args, (Cardinal)num_args, \
+	    True, cache, destructor, True)
+
+    Add(XtQColor, XtQPixel,       XtCvtColorToPixel,   NULL, 0, XtCacheNone);
+
+    Add(XtQInt,   XtQBool,	  XtCvtIntToBool,      NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQBoolean,     XtCvtIntToBoolean,   NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQColor,	  XtCvtIntToColor,
+	colorConvertArgs, XtNumber(colorConvertArgs), XtCacheByDisplay);
+    Add(XtQInt,   XtQDimension,   XtCvtIntToShort,     NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQFloat,       XtCvtIntToFloat,     NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQFont,        XtCvtIntToFont,      NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQPixel,       XtCvtIntToPixel,     NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQPixmap,      XtCvtIntToPixmap,    NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQPosition,    XtCvtIntToShort,     NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQShort,       XtCvtIntToShort,     NULL, 0, XtCacheNone);
+    Add(XtQInt,   XtQUnsignedChar,XtCvtIntToUnsignedChar,NULL, 0, XtCacheNone);
+
+    Add(XtQPixel, XtQColor,	  XtCvtIntToColor,
+	colorConvertArgs, XtNumber(colorConvertArgs), XtCacheByDisplay);
+
+    Add(_XtQString, XtQAtom,      XtCvtStringToAtom,
+	displayConvertArg, XtNumber(displayConvertArg), XtCacheNone);
+    Add(_XtQString, XtQBool,      XtCvtStringToBool,    NULL, 0, XtCacheNone);
+    Add(_XtQString, XtQBoolean,   XtCvtStringToBoolean, NULL, 0, XtCacheNone);
+   Add2(_XtQString, XtQCommandArgArray,  XtCvtStringToCommandArgArray,
+	NULL, 0, XtCacheNone | XtCacheRefCount, ArgArrayDestructor);
+   Add2(_XtQString, XtQCursor,    XtCvtStringToCursor,
+	displayConvertArg, XtNumber(displayConvertArg),
+	XtCacheByDisplay, FreeCursor);
+    Add(_XtQString, XtQDimension, XtCvtStringToDimension,NULL, 0, XtCacheNone);
+   Add2(_XtQString, XtQDirectoryString, XtCvtStringToDirectoryString, NULL, 0,
+	XtCacheNone | XtCacheRefCount, FreeDirectoryString);
+    Add(_XtQString, XtQDisplay,   XtCvtStringToDisplay, NULL, 0, XtCacheAll);
+   Add2(_XtQString, XtQFile,      XtCvtStringToFile,    NULL, 0,
+	XtCacheAll | XtCacheRefCount, FreeFile);
+    Add(_XtQString, XtQFloat,     XtCvtStringToFloat,   NULL, 0, XtCacheNone);
+
+   Add2(_XtQString, XtQFont,      XtCvtStringToFont,
+	displayConvertArg, XtNumber(displayConvertArg),
+	XtCacheByDisplay, FreeFont);
+   Add2(_XtQString, XtQFontSet,   XtCvtStringToFontSet,
+	localeDisplayConvertArgs, XtNumber(localeDisplayConvertArgs),
+	XtCacheByDisplay, FreeFontSet);
+   Add2(_XtQString, XtQFontStruct,XtCvtStringToFontStruct,
+	displayConvertArg, XtNumber(displayConvertArg),
+	XtCacheByDisplay, FreeFontStruct);
+
+    Add(_XtQString, XtQGravity,   XtCvtStringToGravity, NULL, 0, XtCacheNone);
+    Add(_XtQString, XtQInitialState, XtCvtStringToInitialState, NULL, 0,
+	XtCacheNone);
+    Add(_XtQString, XtQInt,	     XtCvtStringToInt,    NULL, 0, XtCacheAll);
+   Add2(_XtQString, XtQPixel,        XtCvtStringToPixel,
+	colorConvertArgs, XtNumber(colorConvertArgs),
+	XtCacheByDisplay, FreePixel);
+    Add(_XtQString, XtQPosition,     XtCvtStringToShort,  NULL, 0, XtCacheAll);
+    Add(_XtQString, XtQRestartStyle, XtCvtStringToRestartStyle, NULL, 0,
+	XtCacheNone);
+    Add(_XtQString, XtQShort,        XtCvtStringToShort,  NULL, 0, XtCacheAll);
+    Add(_XtQString, XtQUnsignedChar, XtCvtStringToUnsignedChar,
+	NULL, 0, XtCacheAll);
+   Add2(_XtQString, XtQVisual,       XtCvtStringToVisual,
+	visualConvertArgs, XtNumber(visualConvertArgs),
+	XtCacheByDisplay, NULL);
+
+   _XtAddTMConverters(table);
+}