Return to tkget.c CVS log

Up to [Micropolis - Activity] / micropolis / src / tk

Annotation of micropolis/src/tk/tkget.c, revision 1.1

1.1     ! root        1: /* 
        !             2:  * tkGet.c --
        !             3:  *
        !             4:  *     This file contains a number of "Tk_GetXXX" procedures, which
        !             5:  *     parse text strings into useful forms for Tk.  This file has
        !             6:  *     the simpler procedures, like Tk_GetDirection and Tk_GetUid.
        !             7:  *     The more complex procedures like Tk_GetColor are in separate
        !             8:  *     files.
        !             9:  *
        !            10:  * Copyright 1991 Regents of the University of California
        !            11:  * Permission to use, copy, modify, and distribute this
        !            12:  * software and its documentation for any purpose and without
        !            13:  * fee is hereby granted, provided that the above copyright
        !            14:  * notice appear in all copies.  The University of California
        !            15:  * makes no representations about the suitability of this
        !            16:  * software for any purpose.  It is provided "as is" without
        !            17:  * express or implied warranty.
        !            18:  */
        !            19: 
        !            20: #ifndef lint
        !            21: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkGet.c,v 1.5 92/08/10 09:02:46 ouster Exp $ SPRITE (Berkeley)";
        !            22: #endif /* not lint */
        !            23: 
        !            24: #include <tk.h>
        !            25: #include "tkconfig.h"
        !            26: 
        !            27: /*
        !            28:  * The hash table below is used to keep track of all the Tk_Uids created
        !            29:  * so far.
        !            30:  */
        !            31: 
        !            32: static Tcl_HashTable uidTable;
        !            33: static int initialized = 0;
        !            34: 
        !            35: /*
        !            36:  *--------------------------------------------------------------
        !            37:  *
        !            38:  * Tk_GetAnchor --
        !            39:  *
        !            40:  *     Given a string, return the corresponding Tk_Anchor.
        !            41:  *
        !            42:  * Results:
        !            43:  *     The return value is a standard Tcl return result.  If
        !            44:  *     TCL_OK is returned, then everything went well and the
        !            45:  *     position is stored at *anchorPtr;  otherwise TCL_ERROR
        !            46:  *     is returned and an error message is left in
        !            47:  *     interp->result.
        !            48:  *
        !            49:  * Side effects:
        !            50:  *     None.
        !            51:  *
        !            52:  *--------------------------------------------------------------
        !            53:  */
        !            54: 
        !            55: int
        !            56: Tk_GetAnchor(interp, string, anchorPtr)
        !            57:     Tcl_Interp *interp;                /* Use this for error reporting. */
        !            58:     char *string;              /* String describing a direction. */
        !            59:     Tk_Anchor *anchorPtr;      /* Where to store Tk_Anchor corresponding
        !            60:                                 * to string. */
        !            61: {
        !            62:     switch (string[0]) {
        !            63:        case 'n':
        !            64:            if (string[1] == 0) {
        !            65:                *anchorPtr = TK_ANCHOR_N;
        !            66:                return TCL_OK;
        !            67:            } else if ((string[1] == 'e') && (string[2] == 0)) {
        !            68:                *anchorPtr = TK_ANCHOR_NE;
        !            69:                return TCL_OK;
        !            70:            } else if ((string[1] == 'w') && (string[2] == 0)) {
        !            71:                *anchorPtr = TK_ANCHOR_NW;
        !            72:                return TCL_OK;
        !            73:            }
        !            74:            goto error;
        !            75:        case 's':
        !            76:            if (string[1] == 0) {
        !            77:                *anchorPtr = TK_ANCHOR_S;
        !            78:                return TCL_OK;
        !            79:            } else if ((string[1] == 'e') && (string[2] == 0)) {
        !            80:                *anchorPtr = TK_ANCHOR_SE;
        !            81:                return TCL_OK;
        !            82:            } else if ((string[1] == 'w') && (string[2] == 0)) {
        !            83:                *anchorPtr = TK_ANCHOR_SW;
        !            84:                return TCL_OK;
        !            85:            } else {
        !            86:                goto error;
        !            87:            }
        !            88:        case 'e':
        !            89:            if (string[1] == 0) {
        !            90:                *anchorPtr = TK_ANCHOR_E;
        !            91:                return TCL_OK;
        !            92:            }
        !            93:            goto error;
        !            94:        case 'w':
        !            95:            if (string[1] == 0) {
        !            96:                *anchorPtr = TK_ANCHOR_W;
        !            97:                return TCL_OK;
        !            98:            }
        !            99:            goto error;
        !           100:        case 'c':
        !           101:            if (strncmp(string, "center", strlen(string)) == 0) {
        !           102:                *anchorPtr = TK_ANCHOR_CENTER;
        !           103:                return TCL_OK;
        !           104:            }
        !           105:            goto error;
        !           106:     }
        !           107: 
        !           108:     error:
        !           109:     Tcl_AppendResult(interp, "bad anchor position \"", string,
        !           110:            "\": must be n, ne, e, se, s, sw, w, nw, or center",
        !           111:            (char *) NULL);
        !           112:     return TCL_ERROR;
        !           113: }
        !           114: 
        !           115: /*
        !           116:  *--------------------------------------------------------------
        !           117:  *
        !           118:  * Tk_NameOfAnchor --
        !           119:  *
        !           120:  *     Given a Tk_Anchor, return the string that corresponds
        !           121:  *     to it.
        !           122:  *
        !           123:  * Results:
        !           124:  *     None.
        !           125:  *
        !           126:  * Side effects:
        !           127:  *     None.
        !           128:  *
        !           129:  *--------------------------------------------------------------
        !           130:  */
        !           131: 
        !           132: char *
        !           133: Tk_NameOfAnchor(anchor)
        !           134:     Tk_Anchor anchor;          /* Anchor for which identifying string
        !           135:                                 * is desired. */
        !           136: {
        !           137:     switch (anchor) {
        !           138:        case TK_ANCHOR_N: return "n";
        !           139:        case TK_ANCHOR_NE: return "ne";
        !           140:        case TK_ANCHOR_E: return "e";
        !           141:        case TK_ANCHOR_SE: return "se";
        !           142:        case TK_ANCHOR_S: return "s";
        !           143:        case TK_ANCHOR_SW: return "sw";
        !           144:        case TK_ANCHOR_W: return "w";
        !           145:        case TK_ANCHOR_NW: return "nw";
        !           146:        case TK_ANCHOR_CENTER: return "center";
        !           147:     }
        !           148:     return "unknown anchor position";
        !           149: }
        !           150: 
        !           151: /*
        !           152:  *--------------------------------------------------------------
        !           153:  *
        !           154:  * Tk_GetJoinStyle --
        !           155:  *
        !           156:  *     Given a string, return the corresponding Tk_JoinStyle.
        !           157:  *
        !           158:  * Results:
        !           159:  *     The return value is a standard Tcl return result.  If
        !           160:  *     TCL_OK is returned, then everything went well and the
        !           161:  *     justification is stored at *joinPtr;  otherwise
        !           162:  *     TCL_ERROR is returned and an error message is left in
        !           163:  *     interp->result.
        !           164:  *
        !           165:  * Side effects:
        !           166:  *     None.
        !           167:  *
        !           168:  *--------------------------------------------------------------
        !           169:  */
        !           170: 
        !           171: int
        !           172: Tk_GetJoinStyle(interp, string, joinPtr)
        !           173:     Tcl_Interp *interp;                /* Use this for error reporting. */
        !           174:     char *string;              /* String describing a justification style. */
        !           175:     int *joinPtr;              /* Where to store join style corresponding
        !           176:                                 * to string. */
        !           177: {
        !           178:     int c, length;
        !           179: 
        !           180:     c = string[0];
        !           181:     length = strlen(string);
        !           182: 
        !           183:     if ((c == 'b') && (strncmp(string, "bevel", length) == 0)) {
        !           184:        *joinPtr = JoinBevel;
        !           185:        return TCL_OK;
        !           186:     }
        !           187:     if ((c == 'm') && (strncmp(string, "miter", length) == 0)) {
        !           188:        *joinPtr = JoinMiter;
        !           189:        return TCL_OK;
        !           190:     }
        !           191:     if ((c == 'r') && (strncmp(string, "round", length) == 0)) {
        !           192:        *joinPtr = JoinRound;
        !           193:        return TCL_OK;
        !           194:     }
        !           195: 
        !           196:     Tcl_AppendResult(interp, "bad join style \"", string,
        !           197:            "\": must be bevel, miter, or round",
        !           198:            (char *) NULL);
        !           199:     return TCL_ERROR;
        !           200: }
        !           201: 
        !           202: /*
        !           203:  *--------------------------------------------------------------
        !           204:  *
        !           205:  * Tk_NameOfJoinStyle --
        !           206:  *
        !           207:  *     Given a Tk_JoinStyle, return the string that corresponds
        !           208:  *     to it.
        !           209:  *
        !           210:  * Results:
        !           211:  *     None.
        !           212:  *
        !           213:  * Side effects:
        !           214:  *     None.
        !           215:  *
        !           216:  *--------------------------------------------------------------
        !           217:  */
        !           218: 
        !           219: char *
        !           220: Tk_NameOfJoinStyle(join)
        !           221:     int join;                  /* Join style for which identifying string
        !           222:                                 * is desired. */
        !           223: {
        !           224:     switch (join) {
        !           225:        case JoinBevel: return "bevel";
        !           226:        case JoinMiter: return "miter";
        !           227:        case JoinRound: return "round";
        !           228:     }
        !           229:     return "unknown join style";
        !           230: }
        !           231: 
        !           232: /*
        !           233:  *--------------------------------------------------------------
        !           234:  *
        !           235:  * Tk_GetCapStyle --
        !           236:  *
        !           237:  *     Given a string, return the corresponding Tk_CapStyle.
        !           238:  *
        !           239:  * Results:
        !           240:  *     The return value is a standard Tcl return result.  If
        !           241:  *     TCL_OK is returned, then everything went well and the
        !           242:  *     justification is stored at *capPtr;  otherwise
        !           243:  *     TCL_ERROR is returned and an error message is left in
        !           244:  *     interp->result.
        !           245:  *
        !           246:  * Side effects:
        !           247:  *     None.
        !           248:  *
        !           249:  *--------------------------------------------------------------
        !           250:  */
        !           251: 
        !           252: int
        !           253: Tk_GetCapStyle(interp, string, capPtr)
        !           254:     Tcl_Interp *interp;                /* Use this for error reporting. */
        !           255:     char *string;              /* String describing a justification style. */
        !           256:     int *capPtr;               /* Where to store cap style corresponding
        !           257:                                 * to string. */
        !           258: {
        !           259:     int c, length;
        !           260: 
        !           261:     c = string[0];
        !           262:     length = strlen(string);
        !           263: 
        !           264:     if ((c == 'b') && (strncmp(string, "butt", length) == 0)) {
        !           265:        *capPtr = CapButt;
        !           266:        return TCL_OK;
        !           267:     }
        !           268:     if ((c == 'p') && (strncmp(string, "projecting", length) == 0)) {
        !           269:        *capPtr = CapProjecting;
        !           270:        return TCL_OK;
        !           271:     }
        !           272:     if ((c == 'r') && (strncmp(string, "round", length) == 0)) {
        !           273:        *capPtr = CapRound;
        !           274:        return TCL_OK;
        !           275:     }
        !           276: 
        !           277:     Tcl_AppendResult(interp, "bad cap style \"", string,
        !           278:            "\": must be butt, projecting, or round",
        !           279:            (char *) NULL);
        !           280:     return TCL_ERROR;
        !           281: }
        !           282: 
        !           283: /*
        !           284:  *--------------------------------------------------------------
        !           285:  *
        !           286:  * Tk_NameOfCapStyle --
        !           287:  *
        !           288:  *     Given a Tk_CapStyle, return the string that corresponds
        !           289:  *     to it.
        !           290:  *
        !           291:  * Results:
        !           292:  *     None.
        !           293:  *
        !           294:  * Side effects:
        !           295:  *     None.
        !           296:  *
        !           297:  *--------------------------------------------------------------
        !           298:  */
        !           299: 
        !           300: char *
        !           301: Tk_NameOfCapStyle(cap)
        !           302:     int cap;                   /* Cap style for which identifying string
        !           303:                                 * is desired. */
        !           304: {
        !           305:     switch (cap) {
        !           306:        case CapButt: return "butt";
        !           307:        case CapProjecting: return "projecting";
        !           308:        case CapRound: return "round";
        !           309:     }
        !           310:     return "unknown cap style";
        !           311: }
        !           312: 
        !           313: /*
        !           314:  *--------------------------------------------------------------
        !           315:  *
        !           316:  * Tk_GetJustify --
        !           317:  *
        !           318:  *     Given a string, return the corresponding Tk_Justify.
        !           319:  *
        !           320:  * Results:
        !           321:  *     The return value is a standard Tcl return result.  If
        !           322:  *     TCL_OK is returned, then everything went well and the
        !           323:  *     justification is stored at *justifyPtr;  otherwise
        !           324:  *     TCL_ERROR is returned and an error message is left in
        !           325:  *     interp->result.
        !           326:  *
        !           327:  * Side effects:
        !           328:  *     None.
        !           329:  *
        !           330:  *--------------------------------------------------------------
        !           331:  */
        !           332: 
        !           333: int
        !           334: Tk_GetJustify(interp, string, justifyPtr)
        !           335:     Tcl_Interp *interp;                /* Use this for error reporting. */
        !           336:     char *string;              /* String describing a justification style. */
        !           337:     Tk_Justify *justifyPtr;    /* Where to store Tk_Justify corresponding
        !           338:                                 * to string. */
        !           339: {
        !           340:     int c, length;
        !           341: 
        !           342:     c = string[0];
        !           343:     length = strlen(string);
        !           344: 
        !           345:     if ((c == 'l') && (strncmp(string, "left", length) == 0)) {
        !           346:        *justifyPtr = TK_JUSTIFY_LEFT;
        !           347:        return TCL_OK;
        !           348:     }
        !           349:     if ((c == 'r') && (strncmp(string, "right", length) == 0)) {
        !           350:        *justifyPtr = TK_JUSTIFY_RIGHT;
        !           351:        return TCL_OK;
        !           352:     }
        !           353:     if ((c == 'c') && (strncmp(string, "center", length) == 0)) {
        !           354:        *justifyPtr = TK_JUSTIFY_CENTER;
        !           355:        return TCL_OK;
        !           356:     }
        !           357:     if ((c == 'f') && (strncmp(string, "fill", length) == 0)) {
        !           358:        *justifyPtr = TK_JUSTIFY_FILL;
        !           359:        return TCL_OK;
        !           360:     }
        !           361: 
        !           362:     Tcl_AppendResult(interp, "bad justification \"", string,
        !           363:            "\": must be left, right, center, or fill",
        !           364:            (char *) NULL);
        !           365:     return TCL_ERROR;
        !           366: }
        !           367: 
        !           368: /*
        !           369:  *--------------------------------------------------------------
        !           370:  *
        !           371:  * Tk_NameOfJustify --
        !           372:  *
        !           373:  *     Given a Tk_Justify, return the string that corresponds
        !           374:  *     to it.
        !           375:  *
        !           376:  * Results:
        !           377:  *     None.
        !           378:  *
        !           379:  * Side effects:
        !           380:  *     None.
        !           381:  *
        !           382:  *--------------------------------------------------------------
        !           383:  */
        !           384: 
        !           385: char *
        !           386: Tk_NameOfJustify(justify)
        !           387:     Tk_Justify justify;                /* Justification style for which
        !           388:                                 * identifying string is desired. */
        !           389: {
        !           390:     switch (justify) {
        !           391:        case TK_JUSTIFY_LEFT: return "left";
        !           392:        case TK_JUSTIFY_RIGHT: return "right";
        !           393:        case TK_JUSTIFY_CENTER: return "center";
        !           394:        case TK_JUSTIFY_FILL: return "fill";
        !           395:     }
        !           396:     return "unknown justification style";
        !           397: }
        !           398: 
        !           399: /*
        !           400:  *----------------------------------------------------------------------
        !           401:  *
        !           402:  * Tk_GetUid --
        !           403:  *
        !           404:  *     Given a string, this procedure returns a unique identifier
        !           405:  *     for the string.
        !           406:  *
        !           407:  * Results:
        !           408:  *     This procedure returns a Tk_Uid corresponding to the "string"
        !           409:  *     argument.  The Tk_Uid has a string value identical to string
        !           410:  *     (strcmp will return 0), but it's guaranteed that any other
        !           411:  *     calls to this procedure with a string equal to "string" will
        !           412:  *     return exactly the same result (i.e. can compare Tk_Uid
        !           413:  *     *values* directly, without having to call strcmp on what they
        !           414:  *     point to).
        !           415:  *
        !           416:  * Side effects:
        !           417:  *     New information may be entered into the identifier table.
        !           418:  *
        !           419:  *----------------------------------------------------------------------
        !           420:  */
        !           421: 
        !           422: Tk_Uid
        !           423: Tk_GetUid(string)
        !           424:     char *string;              /* String to convert. */
        !           425: {
        !           426:     int dummy;
        !           427: 
        !           428:     if (!initialized) {
        !           429:        Tcl_InitHashTable(&uidTable, TCL_STRING_KEYS);
        !           430:        initialized = 1;
        !           431:     }
        !           432:     return (Tk_Uid) Tcl_GetHashKey(&uidTable,
        !           433:            Tcl_CreateHashEntry(&uidTable, string, &dummy));
        !           434: }
        !           435: 
        !           436: /*
        !           437:  *--------------------------------------------------------------
        !           438:  *
        !           439:  * Tk_GetScreenMM --
        !           440:  *
        !           441:  *     Given a string, returns the number of screen millimeters
        !           442:  *     corresponding to that string.
        !           443:  *
        !           444:  * Results:
        !           445:  *     The return value is a standard Tcl return result.  If
        !           446:  *     TCL_OK is returned, then everything went well and the
        !           447:  *     screen distance is stored at *doublePtr;  otherwise
        !           448:  *     TCL_ERROR is returned and an error message is left in
        !           449:  *     interp->result.
        !           450:  *
        !           451:  * Side effects:
        !           452:  *     None.
        !           453:  *
        !           454:  *--------------------------------------------------------------
        !           455:  */
        !           456: 
        !           457: int
        !           458: Tk_GetScreenMM(interp, tkwin, string, doublePtr)
        !           459:     Tcl_Interp *interp;                /* Use this for error reporting. */
        !           460:     Tk_Window tkwin;           /* Window whose screen determines conversion
        !           461:                                 * from centimeters and other absolute
        !           462:                                 * units. */
        !           463:     char *string;              /* String describing a screen distance. */
        !           464:     double *doublePtr;         /* Place to store converted result. */
        !           465: {
        !           466:     char *end;
        !           467:     double d;
        !           468: 
        !           469:     d = strtod(string, &end);
        !           470:     if (end == string) {
        !           471:        error:
        !           472:        Tcl_AppendResult(interp, "bad screen distance \"", string,
        !           473:                "\"", (char *) NULL);
        !           474:        return TCL_ERROR;
        !           475:     }
        !           476:     while ((*end != '\0') && isspace(*end)) {
        !           477:        end++;
        !           478:     }
        !           479:     switch (*end) {
        !           480:        case 0:
        !           481:            d /= WidthOfScreen(Tk_Screen(tkwin));
        !           482:            d *= WidthMMOfScreen(Tk_Screen(tkwin));
        !           483:            break;
        !           484:        case 'c':
        !           485:            d *= 10;
        !           486:            end++;
        !           487:            break;
        !           488:        case 'i':
        !           489:            d *= 25.4;
        !           490:            end++;
        !           491:            break;
        !           492:        case 'm':
        !           493:            end++;
        !           494:            break;
        !           495:        case 'p':
        !           496:            d *= 25.4/72.0;
        !           497:            end++;
        !           498:            break;
        !           499:        default:
        !           500:            goto error;
        !           501:     }
        !           502:     while ((*end != '\0') && isspace(*end)) {
        !           503:        end++;
        !           504:     }
        !           505:     if (*end != 0) {
        !           506:        goto error;
        !           507:     }
        !           508:     *doublePtr = d;
        !           509:     return TCL_OK;
        !           510: }
        !           511: 
        !           512: /*
        !           513:  *--------------------------------------------------------------
        !           514:  *
        !           515:  * Tk_GetPixels --
        !           516:  *
        !           517:  *     Given a string, returns the number of pixels corresponding
        !           518:  *     to that string.
        !           519:  *
        !           520:  * Results:
        !           521:  *     The return value is a standard Tcl return result.  If
        !           522:  *     TCL_OK is returned, then everything went well and the
        !           523:  *     rounded pixel distance is stored at *intPtr;  otherwise
        !           524:  *     TCL_ERROR is returned and an error message is left in
        !           525:  *     interp->result.
        !           526:  *
        !           527:  * Side effects:
        !           528:  *     None.
        !           529:  *
        !           530:  *--------------------------------------------------------------
        !           531:  */
        !           532: 
        !           533: int
        !           534: Tk_GetPixels(interp, tkwin, string, intPtr)
        !           535:     Tcl_Interp *interp;                /* Use this for error reporting. */
        !           536:     Tk_Window tkwin;           /* Window whose screen determines conversion
        !           537:                                 * from centimeters and other absolute
        !           538:                                 * units. */
        !           539:     char *string;              /* String describing a justification style. */
        !           540:     int *intPtr;               /* Place to store converted result. */
        !           541: {
        !           542:     char *end;
        !           543:     double d;
        !           544: 
        !           545:     d = strtod(string, &end);
        !           546:     if (end == string) {
        !           547:        error:
        !           548:        Tcl_AppendResult(interp, "bad screen distance \"", string,
        !           549:                "\"", (char *) NULL);
        !           550:        return TCL_ERROR;
        !           551:     }
        !           552:     while ((*end != '\0') && isspace(*end)) {
        !           553:        end++;
        !           554:     }
        !           555:     switch (*end) {
        !           556:        case 0:
        !           557:            break;
        !           558:        case 'c':
        !           559:            d *= 10*WidthOfScreen(Tk_Screen(tkwin));
        !           560:            d /= WidthMMOfScreen(Tk_Screen(tkwin));
        !           561:            end++;
        !           562:            break;
        !           563:        case 'i':
        !           564:            d *= 25.4*WidthOfScreen(Tk_Screen(tkwin));
        !           565:            d /= WidthMMOfScreen(Tk_Screen(tkwin));
        !           566:            end++;
        !           567:            break;
        !           568:        case 'm':
        !           569:            d *= WidthOfScreen(Tk_Screen(tkwin));
        !           570:            d /= WidthMMOfScreen(Tk_Screen(tkwin));
        !           571:            end++;
        !           572:            break;
        !           573:        case 'p':
        !           574:            d *= (25.4/72.0)*WidthOfScreen(Tk_Screen(tkwin));
        !           575:            d /= WidthMMOfScreen(Tk_Screen(tkwin));
        !           576:            end++;
        !           577:            break;
        !           578:        default:
        !           579:            goto error;
        !           580:     }
        !           581:     while ((*end != '\0') && isspace(*end)) {
        !           582:        end++;
        !           583:     }
        !           584:     if (*end != 0) {
        !           585:        goto error;
        !           586:     }
        !           587:     if (d < 0) {
        !           588:        *intPtr = (int) (d - 0.5);
        !           589:     } else {
        !           590:        *intPtr = (int) (d + 0.5);
        !           591:     }
        !           592:     return TCL_OK;
        !           593: }

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