#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>
#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";
#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
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
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
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;
#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;
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;
}
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));
}
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));
}
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;
}
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));
}
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)}
};
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;
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);
}
}
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
);
}
}
XtConvertArgRec const screenConvertArg[] = {
{XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
sizeof(Screen *)}
};
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);
value->size = sizeof(Display*);
value->addr = (XPointer)&DisplayOfScreen(XtScreenOfObject(widget));
}
static XtConvertArgRec const displayConvertArg[] = {
{XtProcedureArg, (XtPointer)FetchDisplayArg, 0},
};
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;
}
static void FreeCursor(
XtAppContext app,
XrmValuePtr toVal,
XtPointer closure,
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 );
}
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;
}
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;
}
static void FreeFile(
XtAppContext app,
XrmValuePtr toVal,
XtPointer closure,
XrmValuePtr args,
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 );
}
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));
}
Boolean XtCvtStringToFloat(
Display* dpy,
XrmValuePtr args,
Cardinal *num_args,
XrmValuePtr fromVal,
XrmValuePtr toVal,
XtPointer *closure_ret)
{
int ret;
float f, nan;
#ifndef ISC
(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);
}
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);
}
{
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;
}
}
}
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;
}
static void FreeFont(
XtAppContext app,
XrmValuePtr toVal,
XtPointer closure,
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 );
}
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);
}
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);
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);
}
{
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);
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;
}
}
}
f = XCreateFontSet(display, "-*-*-*-R-*-*-*-120-*-*-*-*,*",
&missing_charset_list, &missing_charset_count, &def_string);
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;
}
static void FreeFontSet(
XtAppContext app,
XrmValuePtr toVal,
XtPointer closure,
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 );
}
static void FetchLocaleArg(
Widget widget,
Cardinal *size,
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},
};
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);
}
{
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;
}
}
}
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;
}
static void FreeFontStruct(
XtAppContext app,
XrmValuePtr toVal,
XtPointer closure,
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 );
}
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;
}
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;
}
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;
}
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));
}
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;
}
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);
}
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);
}
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)) {
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';
}
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)}
};
Boolean XtCvtStringToVisual(
Display* dpy,
XrmValuePtr args,
Cardinal *num_args,
XrmValuePtr fromVal,
XrmValuePtr toVal,
XtPointer *closure_ret)
{
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;
}
}
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);
}
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) {
#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;
XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
XtRDirectoryString);
return False;
}
}
str = XtNewString(str);
donestr(String, str, XtRDirectoryString);
}
static void FreeDirectoryString(
XtAppContext app,
XrmValuePtr toVal,
XtPointer closure,
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);
}
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;
}
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') {
while (IsWhitespace(*src) || IsNewline(*src))
src++;
if (*src == '\0')
break;
tokens++;
start = src;
while (*src != '\0' && !IsWhitespace(*src) && !IsNewline(*src)) {
if (*src == '\\' &&
(IsWhitespace(*(src+1)) || IsNewline(*(src+1)))) {
len = src - start;
if (len) {
memcpy(dst, start, len);
dst += len;
}
src++;
start = src;
}
src++;
}
len = src - start;
if (len) {
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)
}
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);
}
}
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);
}