702 lines
19 KiB
C
702 lines
19 KiB
C
/*
|
|
* Copyright (c) 1998 by The XFree86 Project, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* 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 XFREE86 PROJECT 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 XFree86 Project 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
|
|
* XFree86 Project.
|
|
*/
|
|
|
|
/* $XFree86: xc/lib/Xaw/Converters.c,v 3.13 1999/06/06 08:47:54 dawes Exp $ */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#include <X11/IntrinsicP.h>
|
|
#include <X11/StringDefs.h>
|
|
#include <X11/Xmu/CharSet.h>
|
|
#include <X11/Xmu/SysUtil.h>
|
|
#include <X11/Xaw/Simple.h>
|
|
#include <X11/Xaw/XawInit.h>
|
|
#include "Private.h"
|
|
|
|
#ifndef OLDXAW
|
|
|
|
/*
|
|
* Definitions
|
|
*/
|
|
#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); \
|
|
}
|
|
|
|
#define string_done(value) \
|
|
{ \
|
|
if (toVal->addr != NULL) \
|
|
{ \
|
|
if (toVal->size < size) \
|
|
{ \
|
|
toVal->size = size; \
|
|
return (False); \
|
|
} \
|
|
strcpy((char *)toVal->addr, (value)); \
|
|
} \
|
|
else \
|
|
toVal->addr = (XPointer)(value); \
|
|
toVal->size = size; \
|
|
return (True); \
|
|
}
|
|
|
|
/*
|
|
* Prototypes
|
|
*/
|
|
static Boolean _XawCvtAtomToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtBooleanToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtBoolToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtCARD32ToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtCardinalToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtDimensionToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtDisplayListToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtFontStructToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtIntToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtPixelToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtPixmapToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtShortToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtPositionToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtStringToDisplayList(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtStringToPixmap(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static Boolean _XawCvtUnsignedCharToString(Display*, XrmValue*, Cardinal*,
|
|
XrmValue*, XrmValue*, XtPointer*);
|
|
static void TypeToStringNoArgsWarning(Display*, String);
|
|
|
|
/*
|
|
* Initialization
|
|
*/
|
|
static XtConvertArgRec PixelArgs[] = {
|
|
{XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
|
|
sizeof(Colormap)},
|
|
};
|
|
|
|
static XtConvertArgRec DLArgs[] = {
|
|
{XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
|
|
sizeof(Screen *)},
|
|
{XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
|
|
sizeof(Colormap)},
|
|
{XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.depth),
|
|
sizeof(int)},
|
|
};
|
|
#endif /* OLDXAW */
|
|
|
|
static String XtCToolkitError = "ToolkitError";
|
|
static String XtNconversionError = "conversionError";
|
|
|
|
#ifndef OLDXAW
|
|
static String XtNwrongParameters = "wrongParameters";
|
|
|
|
/*
|
|
* Implementation
|
|
*/
|
|
void
|
|
XawInitializeDefaultConverters(void)
|
|
{
|
|
static Boolean first_time = True;
|
|
|
|
if (first_time == False)
|
|
return;
|
|
|
|
first_time = False;
|
|
|
|
/* Replace with more apropriate converters */
|
|
XtSetTypeConverter(XtRCallback, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRColormap, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRFunction, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRPointer, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRScreen, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRStringArray, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRVisual, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRWidget, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRWidgetList, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRWindow, XtRString, _XawCvtCARD32ToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
|
|
XtSetTypeConverter(XtRAtom, XtRString, _XawCvtAtomToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRBool, XtRString, _XawCvtBoolToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRBoolean, XtRString, _XawCvtBooleanToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRCardinal, XtRString, _XawCvtCardinalToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRDimension, XtRString, _XawCvtDimensionToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XawRDisplayList, XtRString, _XawCvtDisplayListToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRFontStruct, XtRString, _XawCvtFontStructToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRInt, XtRString, _XawCvtIntToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRPixel, XtRString, _XawCvtPixelToString,
|
|
&PixelArgs[0], XtNumber(PixelArgs), XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRPixmap, XtRString, _XawCvtPixmapToString,
|
|
&DLArgs[0], XtNumber(DLArgs), XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRPosition, XtRString, _XawCvtPositionToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRShort, XtRString, _XawCvtShortToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
XtSetTypeConverter(XtRString, XawRDisplayList, _XawCvtStringToDisplayList,
|
|
&DLArgs[0], XtNumber(DLArgs), XtCacheAll, NULL);
|
|
XtSetTypeConverter(XtRString, XtRPixmap, _XawCvtStringToPixmap,
|
|
&DLArgs[0], XtNumber(DLArgs), XtCacheAll, NULL);
|
|
XtSetTypeConverter(XtRUnsignedChar, XtRString, _XawCvtUnsignedCharToString,
|
|
NULL, 0, XtCacheNone, NULL);
|
|
}
|
|
#endif /* OLDXAW */
|
|
|
|
void
|
|
XawTypeToStringWarning(Display *dpy, String type)
|
|
{
|
|
char fname[64];
|
|
String params[1];
|
|
Cardinal num_params;
|
|
|
|
XmuSnprintf(fname, sizeof(fname), "cvt%sToString", type);
|
|
|
|
params[0] = type;
|
|
num_params = 1;
|
|
XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
|
|
XtNconversionError, fname, XtCToolkitError,
|
|
"Cannot convert %s to String",
|
|
params, &num_params);
|
|
}
|
|
|
|
#ifndef OLDXAW
|
|
static void
|
|
TypeToStringNoArgsWarning(Display *dpy, String type)
|
|
{
|
|
char fname[64];
|
|
String params[1];
|
|
Cardinal num_params;
|
|
|
|
XmuSnprintf(fname, sizeof(fname), "cvt%sToString", type);
|
|
|
|
params[0] = type;
|
|
num_params = 1;
|
|
XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
|
|
XtNconversionError, fname,
|
|
XtCToolkitError,
|
|
"%s to String conversion needs no extra arguments",
|
|
params, &num_params);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtBooleanToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[6];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRBoolean);
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "%s",
|
|
*(Boolean *)fromVal->addr ? XtEtrue : XtEfalse);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtBoolToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[6];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRBool);
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "%s",
|
|
*(Bool *)fromVal->addr ? XtEtrue : XtEfalse);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtPositionToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[7];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRPosition);
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "%d", *(Position *)fromVal->addr);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtShortToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[7];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRShort);
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "%d", *(short *)fromVal->addr);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtDimensionToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[6];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRDimension);
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "%u", *(Dimension *)fromVal->addr);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtCARD32ToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[11];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, "CARD32");
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "0x%08hx", *(int *)fromVal->addr);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtIntToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[12];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRInt);
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "%d", *(int *)fromVal->addr);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtCardinalToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[11];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRCardinal);
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "%u", *(Cardinal *)fromVal->addr);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtAtomToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char *buffer = NULL;
|
|
static char *nullatom = "NULL";
|
|
Cardinal size;
|
|
Atom atom;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRAtom);
|
|
|
|
if (buffer && buffer != nullatom)
|
|
XFree(buffer);
|
|
|
|
atom = *(Atom *)fromVal[0].addr;
|
|
if (atom == 0)
|
|
buffer = nullatom;
|
|
else if ((buffer = XGetAtomName(dpy, *(Atom *)fromVal[0].addr)) == NULL)
|
|
{
|
|
XawTypeToStringWarning(dpy, XtRAtom);
|
|
toVal->addr = NULL;
|
|
toVal->size = sizeof(String);
|
|
return (False);
|
|
}
|
|
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtPixelToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[19];
|
|
Cardinal size;
|
|
Colormap colormap;
|
|
XColor color;
|
|
|
|
if (*num_args != 1)
|
|
{
|
|
XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
|
|
XtNwrongParameters, "cvtPixelToString",
|
|
XtCToolkitError,
|
|
"Pixel to String conversion needs colormap argument",
|
|
NULL, NULL);
|
|
return (False);
|
|
}
|
|
|
|
colormap = *(Colormap *)args[0].addr;
|
|
color.pixel = *(Pixel *)fromVal->addr;
|
|
|
|
/* Note:
|
|
* If we know the visual type, we can calculate the xcolor
|
|
* without asking Xlib.
|
|
*/
|
|
XQueryColor(dpy, colormap, &color);
|
|
XmuSnprintf(buffer, sizeof(buffer), "rgb:%04hx/%04hx/%04hx",
|
|
color.red, color.green, color.blue);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtFontStructToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[128];
|
|
Cardinal size;
|
|
Atom atom;
|
|
unsigned long value;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRFontStruct);
|
|
|
|
if ((atom = XInternAtom(dpy, "FONT", True)) == None)
|
|
return (False);
|
|
|
|
size = 0;
|
|
|
|
if (XGetFontProperty(*(XFontStruct **)fromVal->addr, atom, &value))
|
|
{
|
|
char *tmp = XGetAtomName(dpy, value);
|
|
|
|
if (tmp)
|
|
{
|
|
XmuSnprintf(buffer, sizeof(buffer), "%s", tmp);
|
|
size = strlen(tmp);
|
|
XFree(tmp);
|
|
}
|
|
}
|
|
|
|
if (size)
|
|
{
|
|
++size;
|
|
string_done(buffer);
|
|
}
|
|
|
|
XawTypeToStringWarning(dpy, XtRFontStruct);
|
|
|
|
return (False);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtUnsignedCharToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
static char buffer[4];
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XtRUnsignedChar);
|
|
|
|
XmuSnprintf(buffer, sizeof(buffer), "%u",
|
|
*(unsigned char *)fromVal->addr);
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*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);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtDisplayListToString(Display *dpy, XrmValue *args, Cardinal *num_args,
|
|
XrmValue *fromVal, XrmValue *toVal,
|
|
XtPointer *converter_data)
|
|
{
|
|
String buffer;
|
|
Cardinal size;
|
|
|
|
if (*num_args != 0)
|
|
TypeToStringNoArgsWarning(dpy, XawRDisplayList);
|
|
|
|
buffer = XawDisplayListString(*(XawDisplayList **)(fromVal[0].addr));
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
/*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);
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Boolean
|
|
_XawCvtPixmapToString(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 buffer = NULL;
|
|
Cardinal size;
|
|
|
|
if (*num_args != 3)
|
|
{
|
|
XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
|
|
XtNwrongParameters, "cvtPixmapToString",
|
|
XtCToolkitError,
|
|
"Pixmap to String 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;
|
|
|
|
pixmap = *(Pixmap *)(fromVal[0].addr);
|
|
|
|
switch (pixmap)
|
|
{
|
|
case None:
|
|
buffer = "None";
|
|
break;
|
|
case ParentRelative:
|
|
buffer = "ParentRelative";
|
|
break;
|
|
case XtUnspecifiedPixmap:
|
|
buffer = "XtUnspecifiedPixmap";
|
|
break;
|
|
default:
|
|
xaw_pixmap = XawPixmapFromXPixmap(pixmap, screen, colormap, depth);
|
|
if (xaw_pixmap)
|
|
buffer = xaw_pixmap->name;
|
|
break;
|
|
}
|
|
|
|
if (!buffer)
|
|
/* Bad Pixmap or Pixmap was not loaded by XawLoadPixmap() */
|
|
return (_XawCvtCARD32ToString(dpy, args, num_args, fromVal, toVal,
|
|
converter_data));
|
|
|
|
size = strlen(buffer) + 1;
|
|
|
|
string_done(buffer);
|
|
}
|
|
|
|
#endif /* OLDXAW */
|