Return to tkcvpoly.c CVS log

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

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

1.1     ! root        1: /* 
        !             2:  * tkCanvPoly.c --
        !             3:  *
        !             4:  *     This file implements polygon items for canvas widgets.
        !             5:  *
        !             6:  * Copyright 1991-1992 Regents of the University of California.
        !             7:  * Permission to use, copy, modify, and distribute this
        !             8:  * software and its documentation for any purpose and without
        !             9:  * fee is hereby granted, provided that the above copyright
        !            10:  * notice appear in all copies.  The University of California
        !            11:  * makes no representations about the suitability of this
        !            12:  * software for any purpose.  It is provided "as is" without
        !            13:  * express or implied warranty.
        !            14:  */
        !            15: 
        !            16: #ifndef lint
        !            17: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkCanvPoly.c,v 1.6 92/07/28 15:40:10 ouster Exp $ SPRITE (Berkeley)";
        !            18: #endif
        !            19: 
        !            20: #include <stdio.h>
        !            21: #include <math.h>
        !            22: #include "tkint.h"
        !            23: #include "tkcanvas.h"
        !            24: #include "tkconfig.h"
        !            25: 
        !            26: /*
        !            27:  * The structure below defines the record for each polygon item.
        !            28:  */
        !            29: 
        !            30: typedef struct PolygonItem  {
        !            31:     Tk_Item header;            /* Generic stuff that's the same for all
        !            32:                                 * types.  MUST BE FIRST IN STRUCTURE. */
        !            33:     int numPoints;             /* Number of points in polygon (always >= 3).
        !            34:                                 * Polygon is always closed. */
        !            35:     double *coordPtr;          /* Pointer to malloc-ed array containing
        !            36:                                 * x- and y-coords of all points in polygon.
        !            37:                                 * X-coords are even-valued indices, y-coords
        !            38:                                 * are corresponding odd-valued indices. */
        !            39:     XColor *fg;                        /* Foreground color for polygon. */
        !            40:     Pixmap fillStipple;                /* Stipple bitmap for filling polygon. */
        !            41:     GC gc;                     /* Graphics context for filling polygon. */
        !            42:     int smooth;                        /* Non-zero means draw shape smoothed (i.e.
        !            43:                                 * with Bezier splines). */
        !            44:     int splineSteps;           /* Number of steps in each spline segment. */
        !            45: } PolygonItem;
        !            46: 
        !            47: /*
        !            48:  * Information used for parsing configuration specs:
        !            49:  */
        !            50: 
        !            51: static Tk_ConfigSpec configSpecs[] = {
        !            52:     {TK_CONFIG_COLOR, "-fill", (char *) NULL, (char *) NULL,
        !            53:        "black", Tk_Offset(PolygonItem, fg), TK_CONFIG_NULL_OK},
        !            54:     {TK_CONFIG_BOOLEAN, "-smooth", (char *) NULL, (char *) NULL,
        !            55:        "no", Tk_Offset(PolygonItem, smooth), TK_CONFIG_DONT_SET_DEFAULT},
        !            56:     {TK_CONFIG_INT, "-splinesteps", (char *) NULL, (char *) NULL,
        !            57:        "12", Tk_Offset(PolygonItem, splineSteps), TK_CONFIG_DONT_SET_DEFAULT},
        !            58:     {TK_CONFIG_BITMAP, "-stipple", (char *) NULL, (char *) NULL,
        !            59:        (char *) NULL, Tk_Offset(PolygonItem, fillStipple), TK_CONFIG_NULL_OK},
        !            60:     {TK_CONFIG_CUSTOM, "-tags", (char *) NULL, (char *) NULL,
        !            61:        (char *) NULL, 0, TK_CONFIG_NULL_OK, &tkCanvasTagsOption},
        !            62:     {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
        !            63:        (char *) NULL, 0, 0}
        !            64: };
        !            65: 
        !            66: /*
        !            67:  * Prototypes for procedures defined in this file:
        !            68:  */
        !            69: 
        !            70: static void            ComputePolygonBbox _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !            71:                            PolygonItem *polyPtr));
        !            72: static int             ConfigurePolygon _ANSI_ARGS_((
        !            73:                            Tk_Canvas *canvasPtr, Tk_Item *itemPtr, int argc,
        !            74:                            char **argv, int flags));
        !            75: static int             CreatePolygon _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !            76:                            struct Tk_Item *itemPtr, int argc, char **argv));
        !            77: static void            DeletePolygon _ANSI_ARGS_((Tk_Item *itemPtr));
        !            78: static void            DisplayPolygon _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !            79:                            Tk_Item *itemPtr, Drawable dst));
        !            80: static int             PolygonCoords _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !            81:                            Tk_Item *itemPtr, int argc, char **argv));
        !            82: static int             PolygonToArea _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !            83:                            Tk_Item *itemPtr, double *rectPtr));
        !            84: static double          PolygonToPoint _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !            85:                            Tk_Item *itemPtr, double *pointPtr));
        !            86: static void            ScalePolygon _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !            87:                            Tk_Item *itemPtr, double originX, double originY,
        !            88:                            double scaleX, double scaleY));
        !            89: static void            TranslatePolygon _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !            90:                            Tk_Item *itemPtr, double deltaX, double deltaY));
        !            91: 
        !            92: /*
        !            93:  * The structures below defines the polygon item type by means
        !            94:  * of procedures that can be invoked by generic item code.
        !            95:  */
        !            96: 
        !            97: Tk_ItemType TkPolygonType = {
        !            98:     "polygon",                         /* name */
        !            99:     sizeof(PolygonItem),               /* itemSize */
        !           100:     CreatePolygon,                     /* createProc */
        !           101:     configSpecs,                       /* configSpecs */
        !           102:     ConfigurePolygon,                  /* configureProc */
        !           103:     PolygonCoords,                     /* coordProc */
        !           104:     DeletePolygon,                     /* deleteProc */
        !           105:     DisplayPolygon,                    /* displayProc */
        !           106:     0,                                 /* alwaysRedraw */
        !           107:     PolygonToPoint,                    /* pointProc */
        !           108:     PolygonToArea,                     /* areaProc */
        !           109:     (Tk_ItemPostscriptProc *) NULL,    /* postscriptProc */
        !           110:     ScalePolygon,                      /* scaleProc */
        !           111:     TranslatePolygon,                  /* translateProc */
        !           112:     (Tk_ItemIndexProc *) NULL,         /* indexProc */
        !           113:     (Tk_ItemCursorProc *) NULL,                /* cursorProc */
        !           114:     (Tk_ItemSelectionProc *) NULL,     /* selectionProc */
        !           115:     (Tk_ItemInsertProc *) NULL,                /* insertProc */
        !           116:     (Tk_ItemDCharsProc *) NULL,                /* dTextProc */
        !           117:     (Tk_ItemType *) NULL               /* nextPtr */
        !           118: };
        !           119: 
        !           120: /*
        !           121:  * The definition below determines how large are static arrays
        !           122:  * used to hold spline points (splines larger than this have to
        !           123:  * have their arrays malloc-ed).
        !           124:  */
        !           125: 
        !           126: #define MAX_STATIC_POINTS 200
        !           127: 
        !           128: /*
        !           129:  *--------------------------------------------------------------
        !           130:  *
        !           131:  * CreatePolygon --
        !           132:  *
        !           133:  *     This procedure is invoked to create a new polygon item in
        !           134:  *     a canvas.
        !           135:  *
        !           136:  * Results:
        !           137:  *     A standard Tcl return value.  If an error occurred in
        !           138:  *     creating the item, then an error message is left in
        !           139:  *     canvasPtr->interp->result;  in this case itemPtr is
        !           140:  *     left uninitialized, so it can be safely freed by the
        !           141:  *     caller.
        !           142:  *
        !           143:  * Side effects:
        !           144:  *     A new polygon item is created.
        !           145:  *
        !           146:  *--------------------------------------------------------------
        !           147:  */
        !           148: 
        !           149: static int
        !           150: CreatePolygon(canvasPtr, itemPtr, argc, argv)
        !           151:     register Tk_Canvas *canvasPtr;     /* Canvas to hold new item. */
        !           152:     Tk_Item *itemPtr;                  /* Record to hold new item;  header
        !           153:                                         * has been initialized by caller. */
        !           154:     int argc;                          /* Number of arguments in argv. */
        !           155:     char **argv;                       /* Arguments describing polygon. */
        !           156: {
        !           157:     register PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           158:     int i;
        !           159: 
        !           160:     if (argc < 6) {
        !           161:        Tcl_AppendResult(canvasPtr->interp, "wrong # args:  should be \"",
        !           162:                Tk_PathName(canvasPtr->tkwin),
        !           163:                "\" create x1 y1 x2 y2 x3 y3 ?x4 y4 ...? ?options?",
        !           164:                (char *) NULL);
        !           165:        return TCL_ERROR;
        !           166:     }
        !           167: 
        !           168:     /*
        !           169:      * Carry out initialization that is needed in order to clean
        !           170:      * up after errors during the the remainder of this procedure.
        !           171:      */
        !           172: 
        !           173:     polyPtr->numPoints = 0;
        !           174:     polyPtr->coordPtr = NULL;
        !           175:     polyPtr->fg = None;
        !           176:     polyPtr->fillStipple = None;
        !           177:     polyPtr->gc = None;
        !           178:     polyPtr->smooth = 0;
        !           179:     polyPtr->splineSteps = 12;
        !           180: 
        !           181:     /*
        !           182:      * Count the number of points and then parse them into a point
        !           183:      * array.  Leading arguments are assumed to be points if they
        !           184:      * start with a digit or a minus sign followed by a digit.
        !           185:      */
        !           186: 
        !           187:     for (i = 4; i < (argc-1); i+=2) {
        !           188:        if ((!isdigit(argv[i][0])) &&
        !           189:                ((argv[i][0] != '-') || (!isdigit(argv[i][1])))) {
        !           190:            break;
        !           191:        }
        !           192:     }
        !           193:     if (PolygonCoords(canvasPtr, itemPtr, i, argv) != TCL_OK) {
        !           194:        goto error;
        !           195:     }
        !           196: 
        !           197:     if (ConfigurePolygon(canvasPtr, itemPtr, argc-i, argv+i, 0) == TCL_OK) {
        !           198:        return TCL_OK;
        !           199:     }
        !           200: 
        !           201:     error:
        !           202:     DeletePolygon(itemPtr);
        !           203:     return TCL_ERROR;
        !           204: }
        !           205: 
        !           206: /*
        !           207:  *--------------------------------------------------------------
        !           208:  *
        !           209:  * PolygonCoords --
        !           210:  *
        !           211:  *     This procedure is invoked to process the "coords" widget
        !           212:  *     command on polygons.  See the user documentation for details
        !           213:  *     on what it does.
        !           214:  *
        !           215:  * Results:
        !           216:  *     Returns TCL_OK or TCL_ERROR, and sets canvasPtr->interp->result.
        !           217:  *
        !           218:  * Side effects:
        !           219:  *     The coordinates for the given item may be changed.
        !           220:  *
        !           221:  *--------------------------------------------------------------
        !           222:  */
        !           223: 
        !           224: static int
        !           225: PolygonCoords(canvasPtr, itemPtr, argc, argv)
        !           226:     register Tk_Canvas *canvasPtr;     /* Canvas containing item. */
        !           227:     Tk_Item *itemPtr;                  /* Item whose coordinates are to be
        !           228:                                         * read or modified. */
        !           229:     int argc;                          /* Number of coordinates supplied in
        !           230:                                         * argv. */
        !           231:     char **argv;                       /* Array of coordinates: x1, y1,
        !           232:                                         * x2, y2, ... */
        !           233: {
        !           234:     register PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           235:     char buffer[300];
        !           236:     int i, numPoints;
        !           237: 
        !           238:     if (argc == 0) {
        !           239:        for (i = 0; i < 2*polyPtr->numPoints; i++) {
        !           240:            sprintf(buffer, "%g", polyPtr->coordPtr[i]);
        !           241:            Tcl_AppendElement(canvasPtr->interp, buffer, 0);
        !           242:        }
        !           243:     } else if (argc < 6) {
        !           244:        Tcl_AppendResult(canvasPtr->interp,
        !           245:                "too few coordinates for polygon:  must have at least 6",
        !           246:                (char *) NULL);
        !           247:        return TCL_ERROR;
        !           248:     } else if (argc & 1) {
        !           249:        Tcl_AppendResult(canvasPtr->interp,
        !           250:                "odd number of coordinates specified for polygon",
        !           251:                (char *) NULL);
        !           252:        return TCL_ERROR;
        !           253:     } else {
        !           254:        numPoints = argc/2;
        !           255:        if (polyPtr->numPoints != numPoints) {
        !           256:            if (polyPtr->coordPtr != NULL) {
        !           257:                ckfree((char *) polyPtr->coordPtr);
        !           258:            }
        !           259: 
        !           260:            /*
        !           261:             * One extra point gets allocated here, just in case we have
        !           262:             * to add another point to close the polygon.
        !           263:             */
        !           264: 
        !           265:            polyPtr->coordPtr = (double *) ckalloc((unsigned)
        !           266:                    (sizeof(double) * (argc+2)));
        !           267:            polyPtr->numPoints = numPoints;
        !           268:        }
        !           269:        for (i = argc-1; i >= 0; i--) {
        !           270:            if (TkGetCanvasCoord(canvasPtr, argv[i], &polyPtr->coordPtr[i])
        !           271:                    != TCL_OK) {
        !           272:                return TCL_ERROR;
        !           273:            }
        !           274:        }
        !           275:     
        !           276:        /*
        !           277:         * Close the polygon if it isn't already closed.
        !           278:         */
        !           279:     
        !           280:        if ((polyPtr->coordPtr[argc-2] != polyPtr->coordPtr[0])
        !           281:                || (polyPtr->coordPtr[argc-1] != polyPtr->coordPtr[1])) {
        !           282:            polyPtr->numPoints++;
        !           283:            polyPtr->coordPtr[argc] = polyPtr->coordPtr[0];
        !           284:            polyPtr->coordPtr[argc+1] = polyPtr->coordPtr[1];
        !           285:        }
        !           286:        ComputePolygonBbox(canvasPtr, polyPtr);
        !           287:     }
        !           288:     return TCL_OK;
        !           289: }
        !           290: 
        !           291: /*
        !           292:  *--------------------------------------------------------------
        !           293:  *
        !           294:  * ConfigurePolygon --
        !           295:  *
        !           296:  *     This procedure is invoked to configure various aspects
        !           297:  *     of a polygon item such as its background color.
        !           298:  *
        !           299:  * Results:
        !           300:  *     A standard Tcl result code.  If an error occurs, then
        !           301:  *     an error message is left in canvasPtr->interp->result.
        !           302:  *
        !           303:  * Side effects:
        !           304:  *     Configuration information, such as colors and stipple
        !           305:  *     patterns, may be set for itemPtr.
        !           306:  *
        !           307:  *--------------------------------------------------------------
        !           308:  */
        !           309: 
        !           310: static int
        !           311: ConfigurePolygon(canvasPtr, itemPtr, argc, argv, flags)
        !           312:     Tk_Canvas *canvasPtr;      /* Canvas containing itemPtr. */
        !           313:     Tk_Item *itemPtr;          /* Polygon item to reconfigure. */
        !           314:     int argc;                  /* Number of elements in argv.  */
        !           315:     char **argv;               /* Arguments describing things to configure. */
        !           316:     int flags;                 /* Flags to pass to Tk_ConfigureWidget. */
        !           317: {
        !           318:     register PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           319:     XGCValues gcValues;
        !           320:     GC newGC;
        !           321:     unsigned long mask;
        !           322: 
        !           323:     if (Tk_ConfigureWidget(canvasPtr->interp, canvasPtr->tkwin,
        !           324:            configSpecs, argc, argv, (char *) polyPtr, flags) != TCL_OK) {
        !           325:        return TCL_ERROR;
        !           326:     }
        !           327: 
        !           328:     /*
        !           329:      * A few of the options require additional processing, such as
        !           330:      * graphics contexts.
        !           331:      */
        !           332: 
        !           333:     if (polyPtr->fg == NULL) {
        !           334:        newGC = None;
        !           335:     } else {
        !           336:        gcValues.foreground = polyPtr->fg->pixel;
        !           337:        mask = GCForeground;
        !           338:        if (polyPtr->fillStipple != None) {
        !           339:            gcValues.stipple = polyPtr->fillStipple;
        !           340:            gcValues.fill_style = FillStippled;
        !           341:            mask |= GCStipple|GCFillStyle;
        !           342:        }
        !           343:        newGC = Tk_GetGC(canvasPtr->tkwin, mask, &gcValues);
        !           344:     }
        !           345:     if (polyPtr->gc != None) {
        !           346:        Tk_FreeGC(polyPtr->gc);
        !           347:     }
        !           348:     polyPtr->gc = newGC;
        !           349: 
        !           350:     /*
        !           351:      * Keep spline parameters within reasonable limits.
        !           352:      */
        !           353: 
        !           354:     if (polyPtr->splineSteps < 1) {
        !           355:        polyPtr->splineSteps = 1;
        !           356:     } else if (polyPtr->splineSteps > 100) {
        !           357:        polyPtr->splineSteps = 100;
        !           358:     }
        !           359: 
        !           360:     ComputePolygonBbox(canvasPtr, polyPtr);
        !           361:     return TCL_OK;
        !           362: }
        !           363: 
        !           364: /*
        !           365:  *--------------------------------------------------------------
        !           366:  *
        !           367:  * DeletePolygon --
        !           368:  *
        !           369:  *     This procedure is called to clean up the data structure
        !           370:  *     associated with a polygon item.
        !           371:  *
        !           372:  * Results:
        !           373:  *     None.
        !           374:  *
        !           375:  * Side effects:
        !           376:  *     Resources associated with itemPtr are released.
        !           377:  *
        !           378:  *--------------------------------------------------------------
        !           379:  */
        !           380: 
        !           381: static void
        !           382: DeletePolygon(itemPtr)
        !           383:     Tk_Item *itemPtr;                  /* Item that is being deleted. */
        !           384: {
        !           385:     register PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           386: 
        !           387:     if (polyPtr->coordPtr != NULL) {
        !           388:        ckfree((char *) polyPtr->coordPtr);
        !           389:     }
        !           390:     if (polyPtr->fg != NULL) {
        !           391:        Tk_FreeColor(polyPtr->fg);
        !           392:     }
        !           393:     if (polyPtr->fillStipple != None) {
        !           394:        Tk_FreeBitmap(polyPtr->fillStipple);
        !           395:     }
        !           396:     if (polyPtr->gc != None) {
        !           397:        Tk_FreeGC(polyPtr->gc);
        !           398:     }
        !           399: }
        !           400: 
        !           401: /*
        !           402:  *--------------------------------------------------------------
        !           403:  *
        !           404:  * ComputePolygonBbox --
        !           405:  *
        !           406:  *     This procedure is invoked to compute the bounding box of
        !           407:  *     all the pixels that may be drawn as part of a polygon.
        !           408:  *
        !           409:  * Results:
        !           410:  *     None.
        !           411:  *
        !           412:  * Side effects:
        !           413:  *     The fields x1, y1, x2, and y2 are updated in the header
        !           414:  *     for itemPtr.
        !           415:  *
        !           416:  *--------------------------------------------------------------
        !           417:  */
        !           418: 
        !           419: static void
        !           420: ComputePolygonBbox(canvasPtr, polyPtr)
        !           421:     register Tk_Canvas *canvasPtr;     /* Canvas that contains item. */
        !           422:     PolygonItem *polyPtr;              /* Item whose bbox is to be
        !           423:                                         * recomputed. */
        !           424: {
        !           425:     register double *coordPtr;
        !           426:     int i;
        !           427: 
        !           428:     coordPtr = polyPtr->coordPtr;
        !           429:     polyPtr->header.x1 = polyPtr->header.x2 = *coordPtr;
        !           430:     polyPtr->header.y1 = polyPtr->header.y2 = coordPtr[1];
        !           431: 
        !           432:     for (i = 1, coordPtr = polyPtr->coordPtr+2; i < polyPtr->numPoints;
        !           433:            i++, coordPtr += 2) {
        !           434:        TkIncludePoint(canvasPtr, (Tk_Item *) polyPtr, coordPtr);
        !           435:     }
        !           436: 
        !           437:     /*
        !           438:      * Add one more pixel of fudge factor just to be safe (e.g.
        !           439:      * X may round differently than we do).
        !           440:      */
        !           441: 
        !           442:     polyPtr->header.x1 -= 1;
        !           443:     polyPtr->header.x2 += 1;
        !           444:     polyPtr->header.y1 -= 1;
        !           445:     polyPtr->header.y2 += 1;
        !           446: }
        !           447: 
        !           448: /*
        !           449:  *--------------------------------------------------------------
        !           450:  *
        !           451:  * TkFillPolygon --
        !           452:  *
        !           453:  *     This procedure is invoked to convert a polygon to screen
        !           454:  *     coordinates and display it using a particular GC.
        !           455:  *
        !           456:  * Results:
        !           457:  *     None.
        !           458:  *
        !           459:  * Side effects:
        !           460:  *     ItemPtr is drawn in drawable using the transformation
        !           461:  *     information in canvasPtr.
        !           462:  *
        !           463:  *--------------------------------------------------------------
        !           464:  */
        !           465: 
        !           466: void
        !           467: TkFillPolygon(canvasPtr, coordPtr, numPoints, drawable, gc)
        !           468:     register Tk_Canvas *canvasPtr;     /* Canvas whose coordinate system
        !           469:                                         * is to be used for drawing. */
        !           470:     double *coordPtr;                  /* Array of coordinates for polygon:
        !           471:                                         * x1, y1, x2, y2, .... */
        !           472:     int numPoints;                     /* Twice this many coordinates are
        !           473:                                         * present at *coordPtr. */
        !           474:     Drawable drawable;                 /* Pixmap or window in which to draw
        !           475:                                         * polygon. */
        !           476:     GC gc;                             /* Graphics context for drawing. */
        !           477: {
        !           478:     XPoint staticPoints[MAX_STATIC_POINTS];
        !           479:     XPoint *pointPtr;
        !           480:     register XPoint *pPtr;
        !           481:     int i;
        !           482: 
        !           483:     /*
        !           484:      * Build up an array of points in screen coordinates.  Use a
        !           485:      * static array unless the polygon has an enormous number of points;
        !           486:      * in this case, dynamically allocate an array.
        !           487:      */
        !           488: 
        !           489:     if (numPoints <= MAX_STATIC_POINTS) {
        !           490:        pointPtr = staticPoints;
        !           491:     } else {
        !           492:        pointPtr = (XPoint *) ckalloc((unsigned) (numPoints * sizeof(XPoint)));
        !           493:     }
        !           494: 
        !           495:     for (i = 0, pPtr = pointPtr; i < numPoints; i += 1, coordPtr += 2, pPtr++) {
        !           496:        pPtr->x = SCREEN_X(canvasPtr, coordPtr[0]);
        !           497:        pPtr->y = SCREEN_Y(canvasPtr, coordPtr[1]);
        !           498:     }
        !           499: 
        !           500:     /*
        !           501:      * Display polygon, then free up polygon storage if it was dynamically
        !           502:      * allocated.
        !           503:      */
        !           504: 
        !           505:     XFillPolygon(Tk_Display(canvasPtr->tkwin), drawable, gc, pointPtr,
        !           506:            numPoints, Complex, CoordModeOrigin);
        !           507:     if (pointPtr != staticPoints) {
        !           508:        ckfree((char *) pointPtr);
        !           509:     }
        !           510: 
        !           511: }
        !           512: 
        !           513: /*
        !           514:  *--------------------------------------------------------------
        !           515:  *
        !           516:  * DisplayPolygon --
        !           517:  *
        !           518:  *     This procedure is invoked to draw a polygon item in a given
        !           519:  *     drawable.
        !           520:  *
        !           521:  * Results:
        !           522:  *     None.
        !           523:  *
        !           524:  * Side effects:
        !           525:  *     ItemPtr is drawn in drawable using the transformation
        !           526:  *     information in canvasPtr.
        !           527:  *
        !           528:  *--------------------------------------------------------------
        !           529:  */
        !           530: 
        !           531: static void
        !           532: DisplayPolygon(canvasPtr, itemPtr, drawable)
        !           533:     register Tk_Canvas *canvasPtr;     /* Canvas that contains item. */
        !           534:     Tk_Item *itemPtr;                  /* Item to be displayed. */
        !           535:     Drawable drawable;                 /* Pixmap or window in which to draw
        !           536:                                         * item. */
        !           537: {
        !           538:     register PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           539: 
        !           540:     if (polyPtr->gc == None) {
        !           541:        return;
        !           542:     }
        !           543: 
        !           544:     if (!polyPtr->smooth) {
        !           545:        TkFillPolygon(canvasPtr, polyPtr->coordPtr, polyPtr->numPoints,
        !           546:                drawable, polyPtr->gc);
        !           547:     } else {
        !           548:        int numPoints;
        !           549:        XPoint staticPoints[MAX_STATIC_POINTS];
        !           550:        XPoint *pointPtr;
        !           551: 
        !           552:        /*
        !           553:         * This is a smoothed polygon.  Display using a set of generated
        !           554:         * spline points rather than the original points.
        !           555:         */
        !           556: 
        !           557:        numPoints = 1 + polyPtr->numPoints*polyPtr->splineSteps;
        !           558:        if (numPoints <= MAX_STATIC_POINTS) {
        !           559:            pointPtr = staticPoints;
        !           560:        } else {
        !           561:            pointPtr = (XPoint *) ckalloc((unsigned)
        !           562:                    (numPoints * sizeof(XPoint)));
        !           563:        }
        !           564:        numPoints = TkMakeBezierCurve(canvasPtr, polyPtr->coordPtr,
        !           565:                polyPtr->numPoints, polyPtr->splineSteps, pointPtr,
        !           566:                (double *) NULL);
        !           567:        XFillPolygon(Tk_Display(canvasPtr->tkwin), drawable, polyPtr->gc,
        !           568:                pointPtr, numPoints, Complex, CoordModeOrigin);
        !           569:        if (pointPtr != staticPoints) {
        !           570:            ckfree((char *) pointPtr);
        !           571:        }
        !           572:     }
        !           573: }
        !           574: 
        !           575: /*
        !           576:  *--------------------------------------------------------------
        !           577:  *
        !           578:  * PolygonToPoint --
        !           579:  *
        !           580:  *     Computes the distance from a given point to a given
        !           581:  *     polygon, in canvas units.
        !           582:  *
        !           583:  * Results:
        !           584:  *     The return value is 0 if the point whose x and y coordinates
        !           585:  *     are pointPtr[0] and pointPtr[1] is inside the polygon.  If the
        !           586:  *     point isn't inside the polygon then the return value is the
        !           587:  *     distance from the point to the polygon.
        !           588:  *
        !           589:  * Side effects:
        !           590:  *     None.
        !           591:  *
        !           592:  *--------------------------------------------------------------
        !           593:  */
        !           594: 
        !           595:        /* ARGSUSED */
        !           596: static double
        !           597: PolygonToPoint(canvasPtr, itemPtr, pointPtr)
        !           598:     Tk_Canvas *canvasPtr;      /* Canvas containing item. */
        !           599:     Tk_Item *itemPtr;          /* Item to check against point. */
        !           600:     double *pointPtr;          /* Pointer to x and y coordinates. */
        !           601: {
        !           602:     PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           603:     double *coordPtr, distance;
        !           604:     double staticSpace[2*MAX_STATIC_POINTS];
        !           605:     int numPoints;
        !           606: 
        !           607:     if (!polyPtr->smooth) {
        !           608:        return TkPolygonToPoint(polyPtr->coordPtr, polyPtr->numPoints,
        !           609:                pointPtr);
        !           610:     }
        !           611: 
        !           612:     /*
        !           613:      * Smoothed polygon.  Generate a new set of points and use them
        !           614:      * for comparison.
        !           615:      */
        !           616: 
        !           617:     numPoints = 1 + polyPtr->numPoints*polyPtr->splineSteps;
        !           618:     if (numPoints <= MAX_STATIC_POINTS) {
        !           619:        coordPtr = staticSpace;
        !           620:     } else {
        !           621:        coordPtr = (double *) ckalloc((unsigned)
        !           622:                (2*numPoints*sizeof(double)));
        !           623:     }
        !           624:     numPoints = TkMakeBezierCurve(canvasPtr, polyPtr->coordPtr,
        !           625:            polyPtr->numPoints, polyPtr->splineSteps, (XPoint *) NULL,
        !           626:            coordPtr);
        !           627:     distance = TkPolygonToPoint(coordPtr, numPoints, pointPtr);
        !           628:     if (coordPtr != staticSpace) {
        !           629:        ckfree((char *) coordPtr);
        !           630:     }
        !           631:     return distance;
        !           632: }
        !           633: 
        !           634: /*
        !           635:  *--------------------------------------------------------------
        !           636:  *
        !           637:  * PolygonToArea --
        !           638:  *
        !           639:  *     This procedure is called to determine whether an item
        !           640:  *     lies entirely inside, entirely outside, or overlapping
        !           641:  *     a given rectangular area.
        !           642:  *
        !           643:  * Results:
        !           644:  *     -1 is returned if the item is entirely outside the area
        !           645:  *     given by rectPtr, 0 if it overlaps, and 1 if it is entirely
        !           646:  *     inside the given area.
        !           647:  *
        !           648:  * Side effects:
        !           649:  *     None.
        !           650:  *
        !           651:  *--------------------------------------------------------------
        !           652:  */
        !           653: 
        !           654:        /* ARGSUSED */
        !           655: static int
        !           656: PolygonToArea(canvasPtr, itemPtr, rectPtr)
        !           657:     Tk_Canvas *canvasPtr;      /* Canvas containing item. */
        !           658:     Tk_Item *itemPtr;          /* Item to check against polygon. */
        !           659:     double *rectPtr;           /* Pointer to array of four coordinates
        !           660:                                 * (x1, y1, x2, y2) describing rectangular
        !           661:                                 * area.  */
        !           662: {
        !           663:     PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           664:     double *coordPtr;
        !           665:     double staticSpace[2*MAX_STATIC_POINTS];
        !           666:     int numPoints, result;
        !           667: 
        !           668:     if (!polyPtr->smooth) {
        !           669:        return TkPolygonToArea(polyPtr->coordPtr, polyPtr->numPoints, rectPtr);
        !           670:     }
        !           671: 
        !           672:     /*
        !           673:      * Smoothed polygon.  Generate a new set of points and use them
        !           674:      * for comparison.
        !           675:      */
        !           676: 
        !           677:     numPoints = 1 + polyPtr->numPoints*polyPtr->splineSteps;
        !           678:     if (numPoints <= MAX_STATIC_POINTS) {
        !           679:        coordPtr = staticSpace;
        !           680:     } else {
        !           681:        coordPtr = (double *) ckalloc((unsigned)
        !           682:                (2*numPoints*sizeof(double)));
        !           683:     }
        !           684:     numPoints = TkMakeBezierCurve(canvasPtr, polyPtr->coordPtr,
        !           685:            polyPtr->numPoints, polyPtr->splineSteps, (XPoint *) NULL,
        !           686:            coordPtr);
        !           687:     result = TkPolygonToArea(coordPtr, numPoints, rectPtr);
        !           688:     if (coordPtr != staticSpace) {
        !           689:        ckfree((char *) coordPtr);
        !           690:     }
        !           691:     return result;
        !           692: }
        !           693: 
        !           694: /*
        !           695:  *--------------------------------------------------------------
        !           696:  *
        !           697:  * ScalePolygon --
        !           698:  *
        !           699:  *     This procedure is invoked to rescale a polygon item.
        !           700:  *
        !           701:  * Results:
        !           702:  *     None.
        !           703:  *
        !           704:  * Side effects:
        !           705:  *     The polygon referred to by itemPtr is rescaled so that the
        !           706:  *     following transformation is applied to all point
        !           707:  *     coordinates:
        !           708:  *             x' = originX + scaleX*(x-originX)
        !           709:  *             y' = originY + scaleY*(y-originY)
        !           710:  *
        !           711:  *--------------------------------------------------------------
        !           712:  */
        !           713: 
        !           714: static void
        !           715: ScalePolygon(canvasPtr, itemPtr, originX, originY, scaleX, scaleY)
        !           716:     Tk_Canvas *canvasPtr;              /* Canvas containing polygon. */
        !           717:     Tk_Item *itemPtr;                  /* Polygon to be scaled. */
        !           718:     double originX, originY;           /* Origin about which to scale rect. */
        !           719:     double scaleX;                     /* Amount to scale in X direction. */
        !           720:     double scaleY;                     /* Amount to scale in Y direction. */
        !           721: {
        !           722:     PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           723:     register double *coordPtr;
        !           724:     int i;
        !           725: 
        !           726:     for (i = 0, coordPtr = polyPtr->coordPtr; i < polyPtr->numPoints;
        !           727:            i++, coordPtr += 2) {
        !           728:        *coordPtr = originX + scaleX*(*coordPtr - originX);
        !           729:        coordPtr[1] = originY + scaleY*(coordPtr[1] - originY);
        !           730:     }
        !           731:     ComputePolygonBbox(canvasPtr, polyPtr);
        !           732: }
        !           733: 
        !           734: /*
        !           735:  *--------------------------------------------------------------
        !           736:  *
        !           737:  * TranslatePolygon --
        !           738:  *
        !           739:  *     This procedure is called to move a polygon by a given
        !           740:  *     amount.
        !           741:  *
        !           742:  * Results:
        !           743:  *     None.
        !           744:  *
        !           745:  * Side effects:
        !           746:  *     The position of the polygon is offset by (xDelta, yDelta),
        !           747:  *     and the bounding box is updated in the generic part of the
        !           748:  *     item structure.
        !           749:  *
        !           750:  *--------------------------------------------------------------
        !           751:  */
        !           752: 
        !           753: static void
        !           754: TranslatePolygon(canvasPtr, itemPtr, deltaX, deltaY)
        !           755:     Tk_Canvas *canvasPtr;              /* Canvas containing item. */
        !           756:     Tk_Item *itemPtr;                  /* Item that is being moved. */
        !           757:     double deltaX, deltaY;             /* Amount by which item is to be
        !           758:                                         * moved. */
        !           759: {
        !           760:     PolygonItem *polyPtr = (PolygonItem *) itemPtr;
        !           761:     register double *coordPtr;
        !           762:     int i;
        !           763: 
        !           764:     for (i = 0, coordPtr = polyPtr->coordPtr; i < polyPtr->numPoints;
        !           765:            i++, coordPtr += 2) {
        !           766:        *coordPtr += deltaX;
        !           767:        coordPtr[1] += deltaY;
        !           768:     }
        !           769:     ComputePolygonBbox(canvasPtr, polyPtr);
        !           770: }

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