static Boolean
__XmCvtStringToRep(Display *display,
XrmValue *args,
Cardinal *num_args,
XrmValue *from,
XrmValue *to,
XtPointer *converter_data)
{
XmRepTypeEntry entry = rep_types + *(int *)args[0].addr;
int result;
static unsigned char value;
DEBUGOUT(_LtDebug(__FILE__, NULL, "__XmCvtStringToRep()\n"));
if (from->addr == NULL)
{
XtDisplayStringConversionWarning(display, from->addr,
entry->rep_type_name);
return False;
}
result = __XmRepTypeStringToValue(entry, (String)from->addr);
if (result < 0)
{
XtDisplayStringConversionWarning(display, from->addr,
entry->rep_type_name);
return False;
}
value = (unsigned char)result;
if (to->addr == NULL)
{
to->addr = (XPointer)&value;
}
else
{
if (to->size >= sizeof value)
{
*(unsigned char *)to->addr = value;
}
else
{
XtDisplayStringConversionWarning(display, from->addr,
entry->rep_type_name);
return False;
}
}
to->size = sizeof value;
return True;
}
Boolean CvtStringToWidget(Display *display,
XrmValue *args, Cardinal *num_args,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *)
{
// Convert first arg into parent
if (*num_args != 1)
{
XtAppErrorMsg(XtDisplayToApplicationContext(display),
"wrongParameters", "CvtStringToWidget",
"XtToolkitError",
"String to Widget conversion needs parent arg",
(String *)0, (Cardinal *)0);
}
Widget parent = *(Widget *) args[0].addr;
// Get widget
const string value = str(fromVal, false);
Widget w = XtNameToWidget(parent, value.chars());
if (w == 0)
{
XtDisplayStringConversionWarning(display, fromVal->addr, XtRWidget);
return False;
}
done(Widget, w);
}
Boolean
neXtawcvtStringToTilePixmap(
Display *display,
XrmValue * args,
Cardinal *num_args,
XrmValuePtr from,
XrmValuePtr to,
XtPointer *converter_data)
{
String file = (String) from->addr;
XpmAttributes attr;
Pixmap pixmap, mask;
Window win;
if (*num_args != 2)
XtAppErrorMsg(XtDisplayToApplicationContext(display),
"cvtStringToTilePixmap", "wrongParameters",
"XtToolkitError",
"String to TilePixmap conversion needs screen and colormap arguments",
(String *) NULL, (Cardinal *) NULL);
win = RootWindow(display,
XScreenNumberOfScreen(*((Screen **) args[0].addr)));
attr.colormap = *((Colormap *) args[1].addr);
attr.valuemask = XpmSize | XpmReturnPixels | XpmColormap;
if (XpmReadFileToPixmap(display, win, file, &pixmap, &mask,
&attr) != XpmSuccess) {
XtDisplayStringConversionWarning(display, file, XtRTilePixmap);
return False;
}
if (mask != None)
XFreePixmap(display, mask);
if (to->addr != NULL) {
if (to->size < sizeof(Pixmap)) {
to->size = sizeof(Pixmap);
XtDisplayStringConversionWarning(display, file, XtRTilePixmap);
return False;
}
*(Pixmap *) (to->addr) = pixmap;
} else {
static Pixmap s_pixmap;
s_pixmap = pixmap;
to->addr = (XtPointer) &s_pixmap;
}
to->size = sizeof(Pixmap);
return True;
}
// Convert String to Pixmap (using XmGetPixmap)
// A Pixmap will be read in as bitmap file
// 1 and 0 values are set according to the widget's
// foreground/background colors.
static Boolean CvtStringToPixmap(Display *display,
XrmValue *args, Cardinal *num_args,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *)
{
// Default parameters
Screen *screen = DefaultScreenOfDisplay(display);
Pixel background = WhitePixelOfScreen(screen);
Pixel foreground = BlackPixelOfScreen(screen);
if (*num_args >= 1)
{
// convert first arg into widget
Widget w = *(Widget *) args[0].addr;
background = w->core.background_pixel;
screen = XtScreen(w);
if (XtIsWidget(w) && XmIsPrimitive(w))
{
// Get foreground color from widget
foreground = XmPrimitiveWidget(w)->primitive.foreground;
}
else
{
// Ask Motif for a default foreground color
Pixel newfg, newtop, newbot, newselect;
XmGetColors(screen, w->core.colormap, background,
&newfg, &newtop, &newbot, &newselect);
foreground = newfg;
}
}
// Get pixmap
Pixmap p = XmUNSPECIFIED_PIXMAP;
string value = str(fromVal, false);
// Some Motif versions use `unspecified_pixmap' and `unspecified pixmap'
// as values for XmUNSPECIFIED_PIXMAP. Check for this.
string v = downcase(value);
v.gsub(" ", "_");
if (v.contains("xm", 0))
v = v.after("xm");
if (v != "unspecified_pixmap")
{
p = XmGetPixmap(screen, XMST(value.chars()), foreground, background);
if (p == XmUNSPECIFIED_PIXMAP)
{
XtDisplayStringConversionWarning(display, fromVal->addr,
XmRPixmap);
return False;
}
}
done(Pixmap, p);
}
/*
* string->help function type converter
*/
static Boolean
string2help(Display *dpy, XrmValue *a, Cardinal *n, XrmValue *from,
XrmValue *to, XtPointer *data)
{
int i, alloced = FALSE;
char *lower, *p;
USEUP(dpy); USEUP(a); USEUP(n); USEUP(data);
/*
* Sanity.
*/
if(*n != 0) {
XtWarningMsg("wrongParameters", "cvsStringToHelpType",
"XtToolkitError",
"String to HelpType conversion needs no extra arguments",
NULL, NULL);
}
if(from->addr == NULL)
return False;
if(to->addr != NULL && to->size < sizeof(XtPointer)) {
to->size = sizeof(XtPointer);
return False;
}
if(to->addr == NULL) {
to->addr = XtMalloc(sizeof(XtPointer));
to->size = sizeof(XtPointer);
alloced = TRUE;
}
lower = XtNewString((String)from->addr);
for(p = lower; *p != '\0'; ++p)
*p = tolower(*p);
for(i = 0; i < N_HELPTYPES; ++i) {
if(strcmp(lower, helptypes[i].s) != 0)
continue;
*(XtPointer *)to->addr = (XtPointer)helptypes[i].f;
XtFree(lower);
return True;
}
if(alloced) {
XtFree(to->addr);
to->addr = NULL;
}
XtDisplayStringConversionWarning(dpy, (String)from->addr, XwlRHelpType);
XtFree(lower);
return False;
}
/*ARGSUSED*/
static Boolean
_XawCvtStringToPixmap(Display *dpy, XrmValue *args, Cardinal *num_args,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *converter_data)
{
XawPixmap *xaw_pixmap;
Pixmap pixmap;
Screen *screen;
Colormap colormap;
int depth;
String name;
if (*num_args != 3)
{
XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
XtNwrongParameters, "cvtStringToPixmap",
XtCToolkitError,
"String to Pixmap conversion needs screen, "
"colormap, and depth arguments",
NULL, NULL);
return (False);
}
screen = *(Screen **)args[0].addr;
colormap = *(Colormap *)args[1].addr;
depth = *(int *)args[2].addr;
name = (String)(fromVal[0].addr);
if (XmuCompareISOLatin1(name, "None") == 0)
pixmap = None;
else if (XmuCompareISOLatin1(name, "ParentRelative") == 0)
pixmap = ParentRelative;
else if (XmuCompareISOLatin1(name, "XtUnspecifiedPixmap") == 0)
pixmap = XtUnspecifiedPixmap;
else
{
xaw_pixmap = XawLoadPixmap(name, screen, colormap, depth);
if (!xaw_pixmap)
{
XtDisplayStringConversionWarning(dpy, (String)fromVal->addr,
XtRPixmap);
toVal->addr = (XtPointer)XtUnspecifiedPixmap;
toVal->size = sizeof(Pixmap);
return (False);
}
else
pixmap = xaw_pixmap->pixmap;
}
done(Pixmap, pixmap);
}
Boolean
XmLCvtStringToUChar(Display *dpy,
char *resname,
XmLStringToUCharMap *map,
XrmValuePtr fromVal,
XrmValuePtr toVal)
{
char *from;
int i, /*num,*/ valid;
from = (char *)fromVal->addr;
valid = 0;
i = 0;
while (map[i].name)
{
if (!strcmp(from, map[i].name))
{
valid = 1;
break;
}
i++;
}
if (!valid)
{
XtDisplayStringConversionWarning(dpy, from, resname);
toVal->size = 0;
toVal->addr = 0;
return False;
}
if (toVal->addr)
{
if (toVal->size < sizeof(unsigned char))
{
toVal->size = sizeof(unsigned char);
return False;
}
*(unsigned char *)(toVal->addr) = map[i].value;
}
else
toVal->addr = (caddr_t)&map[i].value;
toVal->size = sizeof(unsigned char);
return True;
}
/*ARGSUSED*/
Boolean
XmuCvtStringToShapeStyle(Display *dpy, XrmValue *args, Cardinal *num_args,
XrmValue *from, XrmValue *toVal, XtPointer *data)
{
String name = (String)from->addr;
if (XmuCompareISOLatin1(name, XtERectangle) == 0)
done(int, XmuShapeRectangle);
if (XmuCompareISOLatin1(name, XtEOval) == 0)
done(int, XmuShapeOval);
if (XmuCompareISOLatin1(name, XtEEllipse) == 0)
done(int, XmuShapeEllipse);
if (XmuCompareISOLatin1(name, XtERoundedRectangle) == 0)
done(int, XmuShapeRoundedRectangle);
XtDisplayStringConversionWarning(dpy, name, XtRShapeStyle);
return (False);
}
/*ARGSUSED*/
static Boolean
_XawCvtStringToDisplayList(Display *dpy, XrmValue *args, Cardinal *num_args,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *converter_data)
{
XawDisplayList *dlist;
Screen *screen;
Colormap colormap;
int depth;
String commands;
if (*num_args != 3)
{
XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
XtNwrongParameters, "cvtStringToDisplayList",
XtCToolkitError,
"String to DisplayList conversion needs screen, "
"colormap, and depth arguments",
NULL, NULL);
return (False);
}
screen = *(Screen **)args[0].addr;
colormap = *(Colormap *)args[1].addr;
depth = *(int *)args[2].addr;
commands = (String)(fromVal[0].addr);
dlist = XawCreateDisplayList(commands, screen, colormap, depth);
if (!dlist)
{
XtDisplayStringConversionWarning(dpy, (String)fromVal->addr,
XawRDisplayList);
toVal->addr = NULL;
toVal->size = sizeof(XawDisplayList*);
return (False);
}
done(XawDisplayList*, dlist);
}
// Convert String to Bitmap
// A Bitmap will be read in as bitmap file -- 1 and 0 values remain unchanged.
static Boolean CvtStringToBitmap(Display *display,
XrmValue *, Cardinal *,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *)
{
// Fetch a drawable
Window window = None;
#if 0
if (*num_args >= 1)
{
// convert first arg into widget
Widget w = *(Widget *) args[0].addr;
if (XtIsRealized(w))
window = XtWindow(w);
}
#endif
if (window == None)
window = DefaultRootWindow(display);
// Locate file
const string basename = str(fromVal, false);
String filename = locateBitmap(display, basename.chars());
if (filename == 0)
{
// Cannot find file -- check for predefined motif bitmaps
for (Cardinal i = 0; i < XtNumber(bitmap_name_set); i++)
{
if (basename == bitmap_name_set[i])
{
Pixmap bitmap = XCreateBitmapFromData(display, window,
(char *)(bitmaps[i]),
16, 16);
if (bitmap == None)
break;
done(Pixmap, bitmap);
}
}
// Cannot find file and no predefined bitmap found
XtDisplayStringConversionWarning(display, fromVal->addr, XtRBitmap);
return False;
}
// create pixmap
unsigned int width, height;
Pixmap bitmap;
int x_hot, y_hot;
int success = XReadBitmapFile(display, window, filename,
&width, &height, &bitmap, &x_hot, &y_hot);
if (success != BitmapSuccess)
{
XtDisplayStringConversionWarning(display, fromVal->addr, XtRBitmap);
XtFree(filename);
return False;
}
done(Pixmap, bitmap);
}
/* ARGSUSED */
static Boolean
_XawCvtStringToPixmap(Display *dpy, XrmValuePtr args, Cardinal *nargs,
XrmValuePtr from, XrmValuePtr to, XtPointer *data)
{
static Pixmap pixmap;
Window win;
XpmAttributes attr;
XpmColorSymbol colors[1];
if (*nargs != 3)
XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
"_XawCvtStringToPixmap", "wrongParameters", "XtToolkitError",
"_XawCvtStringToPixmap needs screen, colormap, and background_pixel",
(String *) NULL, (Cardinal *) NULL);
if (strcmp(from->addr, "None") == 0)
{
pixmap = None;
DONE(Pixmap, &pixmap);
return (True);
}
if (strcmp(from->addr, "ParentRelative") == 0)
{
pixmap = ParentRelative;
DONE(Pixmap, &pixmap);
return (True);
}
win = RootWindowOfScreen(*((Screen **) args[0].addr));
attr.colormap = *((Colormap *) args[1].addr);
attr.closeness = 32768; /* might help on 8-bpp displays? */
attr.valuemask = XpmColormap | XpmCloseness;
colors[0].name = NULL;
colors[0].value = "none";
colors[0].pixel = *((Pixel *) args[2].addr);
attr.colorsymbols = colors;
attr.numsymbols = 1;
attr.valuemask |= XpmColorSymbols;
if (XpmReadFileToPixmap(dpy, win, (String) from->addr,
&pixmap, NULL, &attr) != XpmSuccess)
{
if ((pixmap = XmuLocateBitmapFile(*((Screen **) args[0].addr),
(char *)from->addr, NULL, 0, NULL, NULL, NULL, NULL)) == None)
{
XtDisplayStringConversionWarning(dpy, (String) from->addr,
XtRPixmap);
return (False);
}
}
if (to->addr == NULL)
to->addr = (XtPointer) & pixmap;
else
{
if (to->size < sizeof(Pixmap))
{
to->size = sizeof(Pixmap);
XtDisplayStringConversionWarning(dpy, (String) from->addr,
XtRPixmap);
return (False);
}
*((Pixmap *) to->addr) = pixmap;
}
to->size = sizeof(Pixmap);
return (True);
}
