Return to Conversion.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / Xrm

Annotation of researchv9/X11/src/X.V11R1/lib/Xrm/Conversion.c, revision 1.1

1.1     ! root        1: /* $Header: Conversion.c,v 1.2 87/09/12 12:34:55 toddb Exp $ */
        !             2: #ifndef lint
        !             3: static char *sccsid = "@(#)Conversion.c        1.11    3/19/87";
        !             4: #endif lint
        !             5: 
        !             6: /*
        !             7:  * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
        !             8:  * 
        !             9:  *                         All Rights Reserved
        !            10:  * 
        !            11:  * Permission to use, copy, modify, and distribute this software and its 
        !            12:  * documentation for any purpose and without fee is hereby granted, 
        !            13:  * provided that the above copyright notice appear in all copies and that
        !            14:  * both that copyright notice and this permission notice appear in 
        !            15:  * supporting documentation, and that the name of Digital Equipment
        !            16:  * Corporation not be used in advertising or publicity pertaining to
        !            17:  * distribution of the software without specific, written prior permission.  
        !            18:  * 
        !            19:  * 
        !            20:  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
        !            21:  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
        !            22:  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
        !            23:  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
        !            24:  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
        !            25:  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
        !            26:  * SOFTWARE.
        !            27:  */
        !            28: 
        !            29: 
        !            30: /* Conversion.c - implementations of resource type conversion procs */
        !            31: 
        !            32: #include       "Xlib.h"
        !            33: #include       "Xutil.h"
        !            34: #include       "Xresource.h"
        !            35: #include       "XrmConvert.h"
        !            36: #include       "Conversion.h"
        !            37: #include       "Quarks.h"
        !            38: #include       <sys/file.h>
        !            39: #include       <stdio.h>
        !            40: 
        !            41: #define        done(address, type) \
        !            42:        { (*toVal).size = sizeof(type); (*toVal).addr = (caddr_t) address; }
        !            43: 
        !            44: static void CvtXColorToPixel();
        !            45: 
        !            46: static void CvtGeometryToDims();
        !            47: 
        !            48: static void CvtIntToBoolean();
        !            49: static void CvtIntToFont();
        !            50: static void CvtIntOrPixelToXColor();
        !            51: static void CvtIntToPixel();
        !            52: 
        !            53: static void CvtStringToBoolean();
        !            54: static void CvtStringToXColor();
        !            55: static void CvtStringToDisplay();
        !            56: extern void CvtStringToEventBindings();
        !            57: static void CvtStringToFile();
        !            58: static void CvtStringToFont();
        !            59: static void CvtStringToFontStruct();
        !            60: static void CvtStringToGeometry();
        !            61: static void CvtStringToInt();
        !            62: static void CvtStringToPixel();
        !            63: static void CvtStringToPixmap();
        !            64: 
        !            65: void _XLowerCase(source, dest)
        !            66:     register char  *source, *dest;
        !            67: {
        !            68:     register char ch;
        !            69: 
        !            70:     for (; (ch = *source) != 0; source++, dest++) {
        !            71:        if ('A' <= ch && ch <= 'Z')
        !            72:            *dest = ch - 'A' + 'a';
        !            73:        else
        !            74:            *dest = ch;
        !            75:     }
        !            76:     *dest = 0;
        !            77: }
        !            78: 
        !            79: 
        !            80: /*ARGSUSED*/
        !            81: static void CvtIntToBoolean(screen, fromVal, toVal)
        !            82:     Screen     *screen;
        !            83:     XrmValuePtr        fromVal;
        !            84:     XrmValuePtr        toVal;
        !            85: {
        !            86:     static int b;
        !            87: 
        !            88:     b = (int) (*(int *)fromVal->addr != 0);
        !            89:     done(&b, int);
        !            90: };
        !            91: 
        !            92: 
        !            93: /*ARGSUSED*/
        !            94: static void CvtStringToBoolean(screen, fromVal, toVal)
        !            95:     Screen     *screen;
        !            96:     XrmValuePtr        fromVal;
        !            97:     XrmValuePtr        toVal;
        !            98: {
        !            99:     static int b;
        !           100:     XrmQuark   q;
        !           101:     char       lowerName[1000];
        !           102: 
        !           103:     _XLowerCase((char *) fromVal->addr, lowerName);
        !           104:     q = XrmAtomToQuark(lowerName);
        !           105: 
        !           106:     if (q == XrmQEtrue)        { b = 1; done(&b, int); return; }
        !           107:     if (q == XrmQEon)  { b = 1; done(&b, int); return; }
        !           108:     if (q == XrmQEyes) { b = 1; done(&b, int); return; }
        !           109: 
        !           110:     if (q == XrmQEfalse)       { b = 0; done(&b, int); return; }
        !           111:     if (q == XrmQEoff) { b = 0; done(&b, int); return; }
        !           112:     if (q == XrmQEno)  { b = 0; done(&b, int); return; }
        !           113: };
        !           114: 
        !           115: 
        !           116: /*ARGSUSED*/
        !           117: static void CvtIntOrPixelToXColor(screen, fromVal, toVal)
        !           118:     Screen     *screen;
        !           119:     XrmValuePtr        fromVal;
        !           120:     XrmValuePtr        toVal;
        !           121: {    
        !           122:     static XColor      c;
        !           123: 
        !           124:     if (DefaultVisualOfScreen(screen)->class == StaticGray)
        !           125:        return;
        !           126: 
        !           127:     c.pixel = *(int *)fromVal->addr;
        !           128:     XQueryColor(DisplayOfScreen(screen),
        !           129:        DefaultColormapOfScreen(screen), &c);
        !           130:                                /* !!! Need some error checking ... ||| */
        !           131:     done(&c, XColor);
        !           132: };
        !           133: 
        !           134: 
        !           135: /*ARGSUSED*/
        !           136: static void CvtStringToXColor(screen, fromVal, toVal)
        !           137:     Screen     *screen;
        !           138:     XrmValuePtr        fromVal;
        !           139:     XrmValuePtr        toVal;
        !           140: {
        !           141:     static XColor      c;
        !           142:     Status             s;
        !           143: 
        !           144:     if (DefaultVisualOfScreen(screen)->class == StaticGray)
        !           145:        return;
        !           146: 
        !           147:     s = XParseColor(DisplayOfScreen(screen), DefaultColormapOfScreen(screen),
        !           148:                        (char *)fromVal->addr, &c);
        !           149:     if (s == 0) return;
        !           150:     s = XAllocColor(DisplayOfScreen(screen), DefaultColormapOfScreen(screen), &c);
        !           151:     if (s == 0) return;
        !           152:     done(&c, XColor);
        !           153: };
        !           154: 
        !           155: 
        !           156: /*ARGSUSED*/
        !           157: static void CvtGeometryToDims(screen, fromVal, toVal)
        !           158:     Screen     *screen;
        !           159:     XrmValuePtr        fromVal;
        !           160:     XrmValuePtr        toVal;
        !           161: {
        !           162:     done(&((Geometry *)fromVal->addr)->dims, Dims);
        !           163: };
        !           164: 
        !           165: 
        !           166: /*ARGSUSED*/
        !           167: static void CvtStringToDisplay(screen, fromVal, toVal)
        !           168:     Screen     *screen;
        !           169:     XrmValuePtr        fromVal;
        !           170:     XrmValuePtr        toVal;
        !           171: {
        !           172:     static Display     *d;
        !           173: 
        !           174:     d = XOpenDisplay((char *)fromVal->addr);
        !           175:     if (d != NULL) { done(d, Display); }
        !           176: };
        !           177: 
        !           178: 
        !           179: /*ARGSUSED*/
        !           180: static void CvtStringToFile(screen, fromVal, toVal)
        !           181:     Screen     *screen;
        !           182:     XrmValuePtr        fromVal;
        !           183:     XrmValuePtr        toVal;
        !           184: {
        !           185:     static FILE        *f;
        !           186: 
        !           187:     f = fopen((char *)fromVal->addr, "r");
        !           188:     if (f != NULL) { done(f, FILE); }
        !           189: };
        !           190: 
        !           191: 
        !           192: /*ARGSUSED*/
        !           193: static void CvtStringToFont(screen, fromVal, toVal)
        !           194:     Screen     *screen;
        !           195:     XrmValuePtr        fromVal;
        !           196:     XrmValuePtr        toVal;
        !           197: {
        !           198:     static Font        f;
        !           199: 
        !           200:     f = XLoadFont(DisplayOfScreen(screen), (char *)fromVal->addr);
        !           201:     if (f != 0) { done(&f, Font); }
        !           202: }
        !           203: 
        !           204: 
        !           205: /*ARGSUSED*/
        !           206: static void CvtIntToFont(screen, fromVal, toVal)
        !           207:     Screen     *screen;
        !           208:     XrmValuePtr        fromVal;
        !           209:     XrmValuePtr        toVal;
        !           210: {
        !           211:     done(fromVal->addr, int);
        !           212: };
        !           213: 
        !           214: 
        !           215: /*ARGSUSED*/
        !           216: static void CvtStringToFontStruct(screen, fromVal, toVal)
        !           217:     Screen     *screen;
        !           218:     XrmValuePtr        fromVal;
        !           219:     XrmValuePtr        toVal;
        !           220: {
        !           221:     static XFontStruct *f;
        !           222: 
        !           223:     f = XLoadQueryFont(DisplayOfScreen(screen), (char *)fromVal->addr);
        !           224:     if (f != NULL) { done(&f, XFontStruct *); }
        !           225: }
        !           226: 
        !           227: /*ARGSUSED*/
        !           228: static void CvtStringToGeometry(screen, fromVal, toVal)
        !           229:     Screen     *screen;
        !           230:     XrmValuePtr        fromVal;
        !           231:     XrmValuePtr        toVal;
        !           232: {
        !           233:     static Geometry    g;
        !           234:     int                        i;
        !           235: 
        !           236:     g.pos.xpos = g.pos.ypos = g.dims.width = g.dims.height = 0;
        !           237:     i = XParseGeometry((char *) fromVal->addr,
        !           238:            &g.pos.xpos, &g.pos.ypos, &g.dims.width, &g.dims.height);
        !           239:     if (i == NoValue) return;
        !           240:     if (i & XNegative)
        !           241:        g.pos.xpos = WidthOfScreen(screen)-1-g.pos.xpos;
        !           242:     if (i & YNegative)
        !           243:        g.pos.ypos = HeightOfScreen(screen)-1-g.pos.ypos;
        !           244:     done(&g, Geometry);
        !           245: };
        !           246: 
        !           247: 
        !           248: /*ARGSUSED*/
        !           249: static void CvtStringToInt(screen, fromVal, toVal)
        !           250:     Screen     *screen;
        !           251:     XrmValuePtr        fromVal;
        !           252:     XrmValuePtr        toVal;
        !           253: {
        !           254:     static int i;
        !           255: 
        !           256:     if (sscanf((char *)fromVal->addr, "%d", &i) == 1) { done(&i, int); }
        !           257: }
        !           258: 
        !           259: 
        !           260: /*ARGSUSED*/
        !           261: static void CvtStringToPixel(screen, fromVal, toVal)
        !           262:     Screen     *screen;
        !           263:     XrmValuePtr        fromVal;
        !           264:     XrmValuePtr        toVal;
        !           265: {
        !           266:     _XrmConvert(screen, XrmQString, fromVal, XrmQColor, toVal);
        !           267:     if ((*toVal).addr == NULL) return;
        !           268:     done(&((XColor *)((*toVal).addr))->pixel, int)
        !           269: };
        !           270: 
        !           271: 
        !           272: /*ARGSUSED*/
        !           273: static void CvtXColorToPixel(screen, fromVal, toVal)
        !           274:     Screen     *screen;
        !           275:     XrmValuePtr        fromVal;
        !           276:     XrmValuePtr        toVal;
        !           277: {
        !           278:     done(&((XColor *)fromVal->addr)->pixel, int);
        !           279: };
        !           280: 
        !           281: 
        !           282: /*ARGSUSED*/
        !           283: static void CvtIntToPixel(screen, fromVal, toVal)
        !           284:     Screen     *screen;
        !           285:     XrmValuePtr        fromVal;
        !           286:     XrmValuePtr        toVal;
        !           287: {
        !           288:        done(fromVal->addr, int);
        !           289: };
        !           290: 
        !           291: 
        !           292: /*ARGSUSED*/
        !           293: static void CvtStringToPixmap(screen, fromVal, toVal)
        !           294:     Screen     *screen;
        !           295:     XrmValuePtr        fromVal;
        !           296:     XrmValuePtr        toVal;
        !           297: {
        !           298:     XrmValue   pixelVal;
        !           299: 
        !           300:     _XrmConvert(screen, XrmQString, fromVal, XrmQPixel, &pixelVal);
        !           301:     if (pixelVal.addr == NULL) return;
        !           302:     _XrmConvert(screen, XrmQPixel, &pixelVal, XrmQPixmap, toVal);
        !           303: }
        !           304: 
        !           305: 
        !           306: static Bool initialized = False;
        !           307: 
        !           308: void XrmInitialize()
        !           309: {
        !           310:     if (initialized)
        !           311:        return;
        !           312:     initialized = True;
        !           313: 
        !           314:     _XrmRegisterTypeConverter(XrmQColor, XrmQPixel,    CvtXColorToPixel);
        !           315: 
        !           316:     _XrmRegisterTypeConverter(XrmQGeometry, XrmQDims,  CvtGeometryToDims);
        !           317: 
        !           318:     _XrmRegisterTypeConverter(XrmQInt,         XrmQBoolean,    CvtIntToBoolean);
        !           319:     _XrmRegisterTypeConverter(XrmQInt,         XrmQPixel,      CvtIntToPixel);
        !           320:     _XrmRegisterTypeConverter(XrmQInt,         XrmQFont,       CvtIntToFont);
        !           321:     _XrmRegisterTypeConverter(XrmQInt,         XrmQColor,      CvtIntOrPixelToXColor);
        !           322: 
        !           323:     _XrmRegisterTypeConverter(XrmQString, XrmQBoolean, CvtStringToBoolean);
        !           324:     _XrmRegisterTypeConverter(XrmQString, XrmQColor,   CvtStringToXColor);
        !           325:     _XrmRegisterTypeConverter(XrmQString, XrmQDisplay, CvtStringToDisplay);
        !           326:     _XrmRegisterTypeConverter(XrmQString, XrmQFile,    CvtStringToFile);
        !           327:     _XrmRegisterTypeConverter(XrmQString, XrmQFont,    CvtStringToFont);
        !           328:     _XrmRegisterTypeConverter(XrmQString, XrmQFontStruct,      CvtStringToFontStruct);
        !           329:     _XrmRegisterTypeConverter(XrmQString, XrmQGeometry,        CvtStringToGeometry);
        !           330:     _XrmRegisterTypeConverter(XrmQString, XrmQInt,     CvtStringToInt);
        !           331:     _XrmRegisterTypeConverter(XrmQString, XrmQPixel,   CvtStringToPixel);
        !           332:     _XrmRegisterTypeConverter(XrmQString, XrmQPixmap,  CvtStringToPixmap);
        !           333: 
        !           334:     _XrmRegisterTypeConverter(XrmQPixel, XrmQColor,    CvtIntOrPixelToXColor);
        !           335: 
        !           336: }
        !           337: 
        !           338: #ifndef lint
        !           339: /*
        !           340:  * This hack is to pull in the right error description code from
        !           341:  * the resource manager library if you have a load line:
        !           342:  *     cc -o foo *.o -loldRm -lX
        !           343:  * or
        !           344:  *     cc -o foo *.o -lnewRm -lX
        !           345:  * This should be removed as soon as the resource manager makes its way
        !           346:  * into Xlib.
        !           347:  */
        !           348: static kludge()
        !           349: {
        !           350:        XGetErrorText();
        !           351: }
        !           352: #endif /* lint */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.