Return to tkcvarc.c CVS log

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

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

1.1     ! root        1: /* 
        !             2:  * tkCanvArc.c --
        !             3:  *
        !             4:  *     This file implements arc items for canvas widgets.
        !             5:  *
        !             6:  * Copyright 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/tkCanvArc.c,v 1.5 92/08/16 15:42:20 ouster Exp $ SPRITE (Berkeley)";
        !            18: #endif
        !            19: 
        !            20: #include <stdio.h>
        !            21: #include <math.h>
        !            22: #include "tkint.h"
        !            23: #include "tkcanvas.h"
        !            24: 
        !            25: /*
        !            26:  * The structure below defines the record for each arc item.
        !            27:  */
        !            28: 
        !            29: typedef struct ArcItem  {
        !            30:     Tk_Item header;            /* Generic stuff that's the same for all
        !            31:                                 * types.  MUST BE FIRST IN STRUCTURE. */
        !            32:     double bbox[4];            /* Coordinates (x1, y1, x2, y2) of bounding
        !            33:                                 * box for oval of which arc is a piece. */
        !            34:     double start;              /* Angle at which arc begins, in degrees
        !            35:                                 * between 0 and 360. */
        !            36:     double extent;             /* Extent of arc (angular distance from
        !            37:                                 * start to end of arc) in degrees between
        !            38:                                 * -360 and 360. */
        !            39:     double *outlinePtr;                /* Points to (x,y) coordinates for points
        !            40:                                 * that define one or two closed polygons
        !            41:                                 * representing the portion of the outline
        !            42:                                 * that isn't part of the arc (the V-shape
        !            43:                                 * for a pie slice or a line-like segment
        !            44:                                 * for a chord).  Malloc'ed. */
        !            45:     int numOutlinePoints;      /* Number of points at outlinePtr.  Zero
        !            46:                                 * means no space allocated. */
        !            47:     int width;                 /* Width of outline (in pixels). */
        !            48:     XColor *outlineColor;      /* Color for outline.  NULL means don't
        !            49:                                 * draw outline. */
        !            50:     XColor *fillColor;         /* Color for filling arc (used for drawing
        !            51:                                 * outline too when style is "arc").  NULL
        !            52:                                 * means don't fill arc. */
        !            53:     Pixmap fillStipple;                /* Stipple bitmap for filling item. */
        !            54:     Tk_Uid style;              /* How to draw arc: arc, chord, or pieslice. */
        !            55:     GC outlineGC;              /* Graphics context for outline. */
        !            56:     GC fillGC;                 /* Graphics context for filling item. */
        !            57:     double center1[2];         /* Coordinates of center of arc outline at
        !            58:                                 * start (see ComputeArcOutline). */
        !            59:     double center2[2];         /* Coordinates of center of arc outline at
        !            60:                                 * start+extent (see ComputeArcOutline). */
        !            61: } ArcItem;
        !            62: 
        !            63: /*
        !            64:  * The definitions below define the sizes of the polygons used to
        !            65:  * display outline information for various styles of arcs:
        !            66:  */
        !            67: 
        !            68: #define CHORD_OUTLINE_PTS      7
        !            69: #define PIE_OUTLINE1_PTS       6
        !            70: #define PIE_OUTLINE2_PTS       7
        !            71: 
        !            72: /*
        !            73:  * Information used for parsing configuration specs:
        !            74:  */
        !            75: 
        !            76: static Tk_ConfigSpec configSpecs[] = {
        !            77:     {TK_CONFIG_DOUBLE, "-extent", (char *) NULL, (char *) NULL,
        !            78:        "90", Tk_Offset(ArcItem, extent), TK_CONFIG_DONT_SET_DEFAULT},
        !            79:     {TK_CONFIG_COLOR, "-fill", (char *) NULL, (char *) NULL,
        !            80:        (char *) NULL, Tk_Offset(ArcItem, fillColor), TK_CONFIG_NULL_OK},
        !            81:     {TK_CONFIG_COLOR, "-outline", (char *) NULL, (char *) NULL,
        !            82:        "black", Tk_Offset(ArcItem, outlineColor), TK_CONFIG_NULL_OK},
        !            83:     {TK_CONFIG_DOUBLE, "-start", (char *) NULL, (char *) NULL,
        !            84:        "0", Tk_Offset(ArcItem, start), TK_CONFIG_DONT_SET_DEFAULT},
        !            85:     {TK_CONFIG_BITMAP, "-stipple", (char *) NULL, (char *) NULL,
        !            86:        (char *) NULL, Tk_Offset(ArcItem, fillStipple), TK_CONFIG_NULL_OK},
        !            87:     {TK_CONFIG_UID, "-style", (char *) NULL, (char *) NULL,
        !            88:        "pieslice", Tk_Offset(ArcItem, style), TK_CONFIG_DONT_SET_DEFAULT},
        !            89:     {TK_CONFIG_CUSTOM, "-tags", (char *) NULL, (char *) NULL,
        !            90:        (char *) NULL, 0, TK_CONFIG_NULL_OK, &tkCanvasTagsOption},
        !            91:     {TK_CONFIG_PIXELS, "-width", (char *) NULL, (char *) NULL,
        !            92:        "1", Tk_Offset(ArcItem, width), TK_CONFIG_DONT_SET_DEFAULT},
        !            93:     {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
        !            94:        (char *) NULL, 0, 0}
        !            95: };
        !            96: 
        !            97: /*
        !            98:  * Prototypes for procedures defined in this file:
        !            99:  */
        !           100: 
        !           101: static int             ArcCoords _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !           102:                            Tk_Item *itemPtr, int argc, char **argv));
        !           103: static int             AngleInRange _ANSI_ARGS_((double x, double y,
        !           104:                            double start, double extent));
        !           105: static int             ArcToArea _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !           106:                            Tk_Item *itemPtr, double *rectPtr));
        !           107: static double          ArcToPoint _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !           108:                            Tk_Item *itemPtr, double *coordPtr));
        !           109: static void            ComputeArcBbox _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !           110:                            ArcItem *arcPtr));
        !           111: static void            ComputeArcOutline _ANSI_ARGS_((ArcItem *arcPtr));
        !           112: static int             ConfigureArc _ANSI_ARGS_((
        !           113:                            Tk_Canvas *canvasPtr, Tk_Item *itemPtr, int argc,
        !           114:                            char **argv, int flags));
        !           115: static int             CreateArc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !           116:                            struct Tk_Item *itemPtr, int argc, char **argv));
        !           117: static void            DeleteArc _ANSI_ARGS_((Tk_Item *itemPtr));
        !           118: static void            DisplayArc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !           119:                            Tk_Item *itemPtr, Drawable dst));
        !           120: static int             HorizLineToArc _ANSI_ARGS_((double x1, double x2,
        !           121:                            double y, double rx, double ry,
        !           122:                            double start, double extent));
        !           123: static void            ScaleArc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !           124:                            Tk_Item *itemPtr, double originX, double originY,
        !           125:                            double scaleX, double scaleY));
        !           126: static void            TranslateArc _ANSI_ARGS_((Tk_Canvas *canvasPtr,
        !           127:                            Tk_Item *itemPtr, double deltaX, double deltaY));
        !           128: static int             VertLineToArc _ANSI_ARGS_((double x, double y1,
        !           129:                            double y2, double rx, double ry,
        !           130:                            double start, double extent));
        !           131: 
        !           132: /*
        !           133:  * The structures below defines the arc item types by means of procedures
        !           134:  * that can be invoked by generic item code.
        !           135:  */
        !           136: 
        !           137: Tk_ItemType TkArcType = {
        !           138:     "arc",                             /* name */
        !           139:     sizeof(ArcItem),                   /* itemSize */
        !           140:     CreateArc,                         /* createProc */
        !           141:     configSpecs,                       /* configSpecs */
        !           142:     ConfigureArc,                      /* configureProc */
        !           143:     ArcCoords,                         /* coordProc */
        !           144:     DeleteArc,                         /* deleteProc */
        !           145:     DisplayArc,                                /* displayProc */
        !           146:     0,                                 /* alwaysRedraw */
        !           147:     ArcToPoint,                                /* pointProc */
        !           148:     ArcToArea,                         /* areaProc */
        !           149:     (Tk_ItemPostscriptProc *) NULL,    /* postscriptProc */
        !           150:     ScaleArc,                          /* scaleProc */
        !           151:     TranslateArc,                      /* translateProc */
        !           152:     (Tk_ItemIndexProc *) NULL,         /* indexProc */
        !           153:     (Tk_ItemCursorProc *) NULL,                /* cursorProc */
        !           154:     (Tk_ItemSelectionProc *) NULL,     /* selectionProc */
        !           155:     (Tk_ItemInsertProc *) NULL,                /* insertProc */
        !           156:     (Tk_ItemDCharsProc *) NULL,                /* dTextProc */
        !           157:     (Tk_ItemType *) NULL               /* nextPtr */
        !           158: };
        !           159: 
        !           160: #define PI 3.14159265358979323846
        !           161: 
        !           162: /*
        !           163:  * The uid's below comprise the legal values for the "-style"
        !           164:  * option for arcs.
        !           165:  */
        !           166: 
        !           167: static Tk_Uid arcUid =  NULL;
        !           168: static Tk_Uid chordUid =  NULL;
        !           169: static Tk_Uid pieSliceUid = NULL;
        !           170: 
        !           171: /*
        !           172:  *--------------------------------------------------------------
        !           173:  *
        !           174:  * CreateArc --
        !           175:  *
        !           176:  *     This procedure is invoked to create a new arc item in
        !           177:  *     a canvas.
        !           178:  *
        !           179:  * Results:
        !           180:  *     A standard Tcl return value.  If an error occurred in
        !           181:  *     creating the item, then an error message is left in
        !           182:  *     canvasPtr->interp->result;  in this case itemPtr is
        !           183:  *     left uninitialized, so it can be safely freed by the
        !           184:  *     caller.
        !           185:  *
        !           186:  * Side effects:
        !           187:  *     A new arc item is created.
        !           188:  *
        !           189:  *--------------------------------------------------------------
        !           190:  */
        !           191: 
        !           192: static int
        !           193: CreateArc(canvasPtr, itemPtr, argc, argv)
        !           194:     register Tk_Canvas *canvasPtr;     /* Canvas to hold new item. */
        !           195:     Tk_Item *itemPtr;                  /* Record to hold new item;  header
        !           196:                                         * has been initialized by caller. */
        !           197:     int argc;                          /* Number of arguments in argv. */
        !           198:     char **argv;                       /* Arguments describing arc. */
        !           199: {
        !           200:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !           201: 
        !           202:     if (argc < 4) {
        !           203:        Tcl_AppendResult(canvasPtr->interp, "wrong # args:  should be \"",
        !           204:                Tk_PathName(canvasPtr->tkwin), "\" create ",
        !           205:                itemPtr->typePtr->name, " x1 y1 x2 y2 ?options?",
        !           206:                (char *) NULL);
        !           207:        return TCL_ERROR;
        !           208:     }
        !           209: 
        !           210:     /*
        !           211:      * Carry out once-only initialization.
        !           212:      */
        !           213: 
        !           214:     if (arcUid == NULL) {
        !           215:        arcUid = Tk_GetUid("arc");
        !           216:        chordUid = Tk_GetUid("chord");
        !           217:        pieSliceUid = Tk_GetUid("pieslice");
        !           218:     }
        !           219: 
        !           220:     /*
        !           221:      * Carry out initialization that is needed in order to clean
        !           222:      * up after errors during the the remainder of this procedure.
        !           223:      */
        !           224: 
        !           225:     arcPtr->start = 0;
        !           226:     arcPtr->extent = 90;
        !           227:     arcPtr->outlinePtr = NULL;
        !           228:     arcPtr->numOutlinePoints = 0;
        !           229:     arcPtr->width = 1;
        !           230:     arcPtr->outlineColor = NULL;
        !           231:     arcPtr->fillColor = NULL;
        !           232:     arcPtr->fillStipple = None;
        !           233:     arcPtr->style = pieSliceUid;
        !           234:     arcPtr->outlineGC = None;
        !           235:     arcPtr->fillGC = None;
        !           236: 
        !           237:     /*
        !           238:      * Process the arguments to fill in the item record.
        !           239:      */
        !           240: 
        !           241:     if ((TkGetCanvasCoord(canvasPtr, argv[0], &arcPtr->bbox[0]) != TCL_OK)
        !           242:            || (TkGetCanvasCoord(canvasPtr, argv[1],
        !           243:                &arcPtr->bbox[1]) != TCL_OK)
        !           244:            || (TkGetCanvasCoord(canvasPtr, argv[2],
        !           245:                    &arcPtr->bbox[2]) != TCL_OK)
        !           246:            || (TkGetCanvasCoord(canvasPtr, argv[3],
        !           247:                    &arcPtr->bbox[3]) != TCL_OK)) {
        !           248:        return TCL_ERROR;
        !           249:     }
        !           250: 
        !           251:     if (ConfigureArc(canvasPtr, itemPtr, argc-4, argv+4, 0) != TCL_OK) {
        !           252:        DeleteArc(itemPtr);
        !           253:        return TCL_ERROR;
        !           254:     }
        !           255:     return TCL_OK;
        !           256: }
        !           257: 
        !           258: /*
        !           259:  *--------------------------------------------------------------
        !           260:  *
        !           261:  * ArcCoords --
        !           262:  *
        !           263:  *     This procedure is invoked to process the "coords" widget
        !           264:  *     command on arcs.  See the user documentation for details
        !           265:  *     on what it does.
        !           266:  *
        !           267:  * Results:
        !           268:  *     Returns TCL_OK or TCL_ERROR, and sets canvasPtr->interp->result.
        !           269:  *
        !           270:  * Side effects:
        !           271:  *     The coordinates for the given item may be changed.
        !           272:  *
        !           273:  *--------------------------------------------------------------
        !           274:  */
        !           275: 
        !           276: static int
        !           277: ArcCoords(canvasPtr, itemPtr, argc, argv)
        !           278:     register Tk_Canvas *canvasPtr;     /* Canvas containing item. */
        !           279:     Tk_Item *itemPtr;                  /* Item whose coordinates are to be
        !           280:                                         * read or modified. */
        !           281:     int argc;                          /* Number of coordinates supplied in
        !           282:                                         * argv. */
        !           283:     char **argv;                       /* Array of coordinates: x1, y1,
        !           284:                                         * x2, y2, ... */
        !           285: {
        !           286:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !           287:     char buffer[500];
        !           288: 
        !           289:     if (argc == 0) {
        !           290:        sprintf(buffer, "%g %g %g %g", arcPtr->bbox[0],
        !           291:                arcPtr->bbox[1], arcPtr->bbox[2],
        !           292:                arcPtr->bbox[3]);
        !           293:        Tcl_SetResult(canvasPtr->interp, buffer, TCL_VOLATILE);
        !           294:     } else if (argc == 4) {
        !           295:        if ((TkGetCanvasCoord(canvasPtr, argv[0],
        !           296:                    &arcPtr->bbox[0]) != TCL_OK)
        !           297:                || (TkGetCanvasCoord(canvasPtr, argv[1],
        !           298:                    &arcPtr->bbox[1]) != TCL_OK)
        !           299:                || (TkGetCanvasCoord(canvasPtr, argv[2],
        !           300:                        &arcPtr->bbox[2]) != TCL_OK)
        !           301:                || (TkGetCanvasCoord(canvasPtr, argv[3],
        !           302:                        &arcPtr->bbox[3]) != TCL_OK)) {
        !           303:            return TCL_ERROR;
        !           304:        }
        !           305:        ComputeArcBbox(canvasPtr, arcPtr);
        !           306:     } else {
        !           307:        sprintf(canvasPtr->interp->result,
        !           308:                "wrong # coordinates:  expected 0 or 4, got %d",
        !           309:                argc);
        !           310:        return TCL_ERROR;
        !           311:     }
        !           312:     return TCL_OK;
        !           313: }
        !           314: 
        !           315: /*
        !           316:  *--------------------------------------------------------------
        !           317:  *
        !           318:  * ConfigureArc --
        !           319:  *
        !           320:  *     This procedure is invoked to configure various aspects
        !           321:  *     of a arc item, such as its outline and fill colors.
        !           322:  *
        !           323:  * Results:
        !           324:  *     A standard Tcl result code.  If an error occurs, then
        !           325:  *     an error message is left in canvasPtr->interp->result.
        !           326:  *
        !           327:  * Side effects:
        !           328:  *     Configuration information, such as colors and stipple
        !           329:  *     patterns, may be set for itemPtr.
        !           330:  *
        !           331:  *--------------------------------------------------------------
        !           332:  */
        !           333: 
        !           334: static int
        !           335: ConfigureArc(canvasPtr, itemPtr, argc, argv, flags)
        !           336:     Tk_Canvas *canvasPtr;      /* Canvas containing itemPtr. */
        !           337:     Tk_Item *itemPtr;          /* Arc item to reconfigure. */
        !           338:     int argc;                  /* Number of elements in argv.  */
        !           339:     char **argv;               /* Arguments describing things to configure. */
        !           340:     int flags;                 /* Flags to pass to Tk_ConfigureWidget. */
        !           341: {
        !           342:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !           343:     XGCValues gcValues;
        !           344:     GC newGC;
        !           345:     unsigned long mask;
        !           346:     int i;
        !           347: 
        !           348:     if (Tk_ConfigureWidget(canvasPtr->interp, canvasPtr->tkwin,
        !           349:            configSpecs, argc, argv, (char *) arcPtr, flags) != TCL_OK) {
        !           350:        return TCL_ERROR;
        !           351:     }
        !           352: 
        !           353:     /*
        !           354:      * A few of the options require additional processing, such as
        !           355:      * style and graphics contexts.
        !           356:      */
        !           357: 
        !           358:     i = arcPtr->start/360.0;
        !           359:     arcPtr->start -= i*360.0;
        !           360:     if (arcPtr->start < 0) {
        !           361:        arcPtr->start += 360.0;
        !           362:     }
        !           363:     i = arcPtr->extent/360.0;
        !           364:     arcPtr->extent -= i*360.0;
        !           365: 
        !           366:     if ((arcPtr->style != arcUid) && (arcPtr->style != chordUid)
        !           367:            && (arcPtr->style != pieSliceUid)) {
        !           368:        Tcl_AppendResult(canvasPtr->interp, "bad -style option \"",
        !           369:                arcPtr->style, "\": must be arc, chord, or pieslice",
        !           370:                (char *) NULL);
        !           371:        arcPtr->style = pieSliceUid;
        !           372:        return TCL_ERROR;
        !           373:     }
        !           374: 
        !           375:     if (arcPtr->width < 0) {
        !           376:        arcPtr->width = 1;
        !           377:     }
        !           378:     if (arcPtr->style == arcUid) {
        !           379:        if (arcPtr->fillColor == NULL) {
        !           380:            newGC = None;
        !           381:        } else {
        !           382:            gcValues.foreground = arcPtr->fillColor->pixel;
        !           383:            gcValues.cap_style = CapButt;
        !           384:            gcValues.line_width = arcPtr->width;
        !           385:            mask = GCForeground|GCCapStyle|GCLineWidth;
        !           386:            if (arcPtr->fillStipple != None) {
        !           387:                gcValues.stipple = arcPtr->fillStipple;
        !           388:                gcValues.fill_style = FillStippled;
        !           389:                mask |= GCStipple|GCFillStyle;
        !           390:            }
        !           391:            newGC = Tk_GetGC(canvasPtr->tkwin, mask, &gcValues);
        !           392:        }
        !           393:     } else if (arcPtr->outlineColor == NULL) {
        !           394:        newGC = None;
        !           395:     } else {
        !           396:        gcValues.foreground = arcPtr->outlineColor->pixel;
        !           397:        gcValues.cap_style = CapButt;
        !           398:        gcValues.line_width = arcPtr->width;
        !           399:        mask = GCForeground|GCCapStyle|GCLineWidth;
        !           400:        newGC = Tk_GetGC(canvasPtr->tkwin, mask, &gcValues);
        !           401:     }
        !           402:     if (arcPtr->outlineGC != None) {
        !           403:        Tk_FreeGC(arcPtr->outlineGC);
        !           404:     }
        !           405:     arcPtr->outlineGC = newGC;
        !           406: 
        !           407:     if ((arcPtr->fillColor == NULL) || (arcPtr->style == arcUid)) {
        !           408:        newGC = None;
        !           409:     } else {
        !           410:        gcValues.foreground = arcPtr->fillColor->pixel;
        !           411:        if (arcPtr->style == chordUid) {
        !           412:            gcValues.arc_mode = ArcChord;
        !           413:        } else {
        !           414:            gcValues.arc_mode = ArcPieSlice;
        !           415:        }
        !           416:        mask = GCForeground|GCArcMode;
        !           417:        if (arcPtr->fillStipple != None) {
        !           418:            gcValues.stipple = arcPtr->fillStipple;
        !           419:            gcValues.fill_style = FillStippled;
        !           420:            mask |= GCStipple|GCFillStyle;
        !           421:        }
        !           422:        newGC = Tk_GetGC(canvasPtr->tkwin, mask, &gcValues);
        !           423:     }
        !           424:     if (arcPtr->fillGC != None) {
        !           425:        Tk_FreeGC(arcPtr->fillGC);
        !           426:     }
        !           427:     arcPtr->fillGC = newGC;
        !           428: 
        !           429:     ComputeArcBbox(canvasPtr, arcPtr);
        !           430:     return TCL_OK;
        !           431: }
        !           432: 
        !           433: /*
        !           434:  *--------------------------------------------------------------
        !           435:  *
        !           436:  * DeleteArc --
        !           437:  *
        !           438:  *     This procedure is called to clean up the data structure
        !           439:  *     associated with a arc item.
        !           440:  *
        !           441:  * Results:
        !           442:  *     None.
        !           443:  *
        !           444:  * Side effects:
        !           445:  *     Resources associated with itemPtr are released.
        !           446:  *
        !           447:  *--------------------------------------------------------------
        !           448:  */
        !           449: 
        !           450: static void
        !           451: DeleteArc(itemPtr)
        !           452:     Tk_Item *itemPtr;                  /* Item that is being deleted. */
        !           453: {
        !           454:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !           455: 
        !           456:     if (arcPtr->numOutlinePoints != 0) {
        !           457:        ckfree((char *) arcPtr->outlinePtr);
        !           458:     }
        !           459:     if (arcPtr->outlineColor != NULL) {
        !           460:        Tk_FreeColor(arcPtr->outlineColor);
        !           461:     }
        !           462:     if (arcPtr->fillColor != NULL) {
        !           463:        Tk_FreeColor(arcPtr->fillColor);
        !           464:     }
        !           465:     if (arcPtr->fillStipple != None) {
        !           466:        Tk_FreeBitmap(arcPtr->fillStipple);
        !           467:     }
        !           468:     if (arcPtr->outlineGC != None) {
        !           469:        Tk_FreeGC(arcPtr->outlineGC);
        !           470:     }
        !           471:     if (arcPtr->fillGC != None) {
        !           472:        Tk_FreeGC(arcPtr->fillGC);
        !           473:     }
        !           474: }
        !           475: 
        !           476: /*
        !           477:  *--------------------------------------------------------------
        !           478:  *
        !           479:  * ComputeArcBbox --
        !           480:  *
        !           481:  *     This procedure is invoked to compute the bounding box of
        !           482:  *     all the pixels that may be drawn as part of an arc.
        !           483:  *
        !           484:  * Results:
        !           485:  *     None.
        !           486:  *
        !           487:  * Side effects:
        !           488:  *     The fields x1, y1, x2, and y2 are updated in the header
        !           489:  *     for itemPtr.
        !           490:  *
        !           491:  *--------------------------------------------------------------
        !           492:  */
        !           493: 
        !           494:        /* ARGSUSED */
        !           495: static void
        !           496: ComputeArcBbox(canvasPtr, arcPtr)
        !           497:     register Tk_Canvas *canvasPtr;     /* Canvas that contains item. */
        !           498:     register ArcItem *arcPtr;          /* Item whose bbox is to be
        !           499:                                         * recomputed. */
        !           500: {
        !           501:     double tmp, center[2], point[2];
        !           502: 
        !           503:     /*
        !           504:      * Make sure that the first coordinates are the lowest ones.
        !           505:      */
        !           506: 
        !           507:     if (arcPtr->bbox[1] > arcPtr->bbox[3]) {
        !           508:        double tmp;
        !           509:        tmp = arcPtr->bbox[3];
        !           510:        arcPtr->bbox[3] = arcPtr->bbox[1];
        !           511:        arcPtr->bbox[1] = tmp;
        !           512:     }
        !           513:     if (arcPtr->bbox[0] > arcPtr->bbox[2]) {
        !           514:        double tmp;
        !           515:        tmp = arcPtr->bbox[2];
        !           516:        arcPtr->bbox[2] = arcPtr->bbox[0];
        !           517:        arcPtr->bbox[0] = tmp;
        !           518:     }
        !           519: 
        !           520:     ComputeArcOutline(arcPtr);
        !           521: 
        !           522:     /*
        !           523:      * To compute the bounding box, start with the the bbox formed
        !           524:      * by the two endpoints of the arc.  Then add in the center of
        !           525:      * the arc's oval (if relevant) and the 3-o'clock, 6-o'clock,
        !           526:      * 9-o'clock, and 12-o'clock positions, if they are relevant.
        !           527:      */
        !           528: 
        !           529:     arcPtr->header.x1 = arcPtr->header.x2 = arcPtr->center1[0];
        !           530:     arcPtr->header.y1 = arcPtr->header.y2 = arcPtr->center1[1];
        !           531:     TkIncludePoint(canvasPtr, (Tk_Item *) arcPtr, arcPtr->center2);
        !           532:     center[0] = (arcPtr->bbox[0] + arcPtr->bbox[2])/2;
        !           533:     center[1] = (arcPtr->bbox[1] + arcPtr->bbox[3])/2;
        !           534:     if (arcPtr->style != arcUid) {
        !           535:        TkIncludePoint(canvasPtr, (Tk_Item *) arcPtr, center);
        !           536:     }
        !           537: 
        !           538:     tmp = -arcPtr->start;
        !           539:     if (tmp < 0) {
        !           540:        tmp += 360.0;
        !           541:     }
        !           542:     if ((tmp < arcPtr->extent) || ((tmp-360) > arcPtr->extent)) {
        !           543:        point[0] = arcPtr->bbox[2];
        !           544:        point[1] = center[1];
        !           545:        TkIncludePoint(canvasPtr, (Tk_Item *) arcPtr, point);
        !           546:     }
        !           547:     tmp = 90.0 - arcPtr->start;
        !           548:     if (tmp < 0) {
        !           549:        tmp += 360.0;
        !           550:     }
        !           551:     if ((tmp < arcPtr->extent) || ((tmp-360) > arcPtr->extent)) {
        !           552:        point[0] = center[0];
        !           553:        point[1] = arcPtr->bbox[1];
        !           554:        TkIncludePoint(canvasPtr, (Tk_Item *) arcPtr, point);
        !           555:     }
        !           556:     tmp = 180.0 - arcPtr->start;
        !           557:     if (tmp < 0) {
        !           558:        tmp += 360.0;
        !           559:     }
        !           560:     if ((tmp < arcPtr->extent) || ((tmp-360) > arcPtr->extent)) {
        !           561:        point[0] = arcPtr->bbox[0];
        !           562:        point[1] = center[1];
        !           563:        TkIncludePoint(canvasPtr, (Tk_Item *) arcPtr, point);
        !           564:     }
        !           565:     tmp = 270.0 - arcPtr->start;
        !           566:     if (tmp < 0) {
        !           567:        tmp += 360.0;
        !           568:     }
        !           569:     if ((tmp < arcPtr->extent) || ((tmp-360) > arcPtr->extent)) {
        !           570:        point[0] = center[0];
        !           571:        point[1] = arcPtr->bbox[3];
        !           572:        TkIncludePoint(canvasPtr, (Tk_Item *) arcPtr, point);
        !           573:     }
        !           574: 
        !           575:     /*
        !           576:      * Lastly, expand by the width of the arc (if the arc's outline is
        !           577:      * being drawn) and add one extra pixel just for safety.
        !           578:      */
        !           579: 
        !           580:     if (arcPtr->outlineColor == NULL) {
        !           581:        tmp = 1;
        !           582:     } else {
        !           583:        tmp = (arcPtr->width + 1)/2 + 1;
        !           584:     }
        !           585:     arcPtr->header.x1 -= tmp;
        !           586:     arcPtr->header.y1 -= tmp;
        !           587:     arcPtr->header.x2 += tmp;
        !           588:     arcPtr->header.y2 += tmp;
        !           589: }
        !           590: 
        !           591: /*
        !           592:  *--------------------------------------------------------------
        !           593:  *
        !           594:  * DisplayArc --
        !           595:  *
        !           596:  *     This procedure is invoked to draw an arc item in a given
        !           597:  *     drawable.
        !           598:  *
        !           599:  * Results:
        !           600:  *     None.
        !           601:  *
        !           602:  * Side effects:
        !           603:  *     ItemPtr is drawn in drawable using the transformation
        !           604:  *     information in canvasPtr.
        !           605:  *
        !           606:  *--------------------------------------------------------------
        !           607:  */
        !           608: 
        !           609: static void
        !           610: DisplayArc(canvasPtr, itemPtr, drawable)
        !           611:     register Tk_Canvas *canvasPtr;     /* Canvas that contains item. */
        !           612:     Tk_Item *itemPtr;                  /* Item to be displayed. */
        !           613:     Drawable drawable;                 /* Pixmap or window in which to draw
        !           614:                                         * item. */
        !           615: {
        !           616:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !           617:     Display *display = Tk_Display(canvasPtr->tkwin);
        !           618:     int x1, y1, x2, y2, start, extent;
        !           619: 
        !           620:     /*
        !           621:      * Compute the screen coordinates of the bounding box for the item,
        !           622:      * plus integer values for the angles.
        !           623:      */
        !           624: 
        !           625:     x1 = SCREEN_X(canvasPtr, arcPtr->bbox[0]);
        !           626:     y1 = SCREEN_Y(canvasPtr, arcPtr->bbox[1]);
        !           627:     x2 = SCREEN_X(canvasPtr, arcPtr->bbox[2]);
        !           628:     y2 = SCREEN_Y(canvasPtr, arcPtr->bbox[3]);
        !           629:     if (x2 <= x1) {
        !           630:        x2 = x1+1;
        !           631:     }
        !           632:     if (y2 <= y1) {
        !           633:        y2 = y1+1;
        !           634:     }
        !           635:     start = (64*arcPtr->start) + 0.5;
        !           636:     extent = (64*arcPtr->extent) + 0.5;
        !           637: 
        !           638:     /*
        !           639:      * Display filled arc first (if wanted), then outline.
        !           640:      */
        !           641: 
        !           642:     if (arcPtr->fillGC != None) {
        !           643:        XFillArc(display, drawable, arcPtr->fillGC, x1, y1, (x2-x1),
        !           644:                (y2-y1), start, extent);
        !           645:     }
        !           646:     if (arcPtr->outlineGC != None) {
        !           647:        XDrawArc(display, drawable, arcPtr->outlineGC, x1, y1, (x2-x1),
        !           648:                (y2-y1), start, extent);
        !           649: 
        !           650:        /*
        !           651:         * If the outline width is very thin, don't use polygons to draw
        !           652:         * the linear parts of the outline (this often results in nothing
        !           653:         * being displayed); just draw lines instead.
        !           654:         */
        !           655: 
        !           656:        if (arcPtr->width <= 2) {
        !           657:            x1 = SCREEN_X(canvasPtr, arcPtr->center1[0]);
        !           658:            y1 = SCREEN_Y(canvasPtr, arcPtr->center1[1]);
        !           659:            x2 = SCREEN_X(canvasPtr, arcPtr->center2[0]);
        !           660:            y2 = SCREEN_Y(canvasPtr, arcPtr->center2[1]);
        !           661: 
        !           662:            if (arcPtr->style == chordUid) {
        !           663:                XDrawLine(display, drawable, arcPtr->outlineGC,
        !           664:                        x1, y1, x2, y2);
        !           665:            } else if (arcPtr->style == pieSliceUid) {
        !           666:                int cx, cy;
        !           667:     
        !           668:                cx = SCREEN_X(canvasPtr, (arcPtr->bbox[0] + arcPtr->bbox[2])/2.0);
        !           669:                cy = SCREEN_Y(canvasPtr, (arcPtr->bbox[1] + arcPtr->bbox[3])/2.0);
        !           670:                XDrawLine(display, drawable, arcPtr->outlineGC,
        !           671:                        cx, cy, x1, y1);
        !           672:                XDrawLine(display, drawable, arcPtr->outlineGC,
        !           673:                        cx, cy, x2, y2);
        !           674:            }
        !           675:        } else {
        !           676:            if (arcPtr->style == chordUid) {
        !           677:                TkFillPolygon(canvasPtr, arcPtr->outlinePtr,
        !           678:                        CHORD_OUTLINE_PTS, drawable, arcPtr->outlineGC);
        !           679:            } else if (arcPtr->style == pieSliceUid) {
        !           680:                TkFillPolygon(canvasPtr, arcPtr->outlinePtr,
        !           681:                        PIE_OUTLINE1_PTS, drawable, arcPtr->outlineGC);
        !           682:                TkFillPolygon(canvasPtr,
        !           683:                        arcPtr->outlinePtr + 2*PIE_OUTLINE1_PTS,
        !           684:                        PIE_OUTLINE2_PTS, drawable, arcPtr->outlineGC);
        !           685:            }
        !           686:        }
        !           687:     }
        !           688: }
        !           689: 
        !           690: /*
        !           691:  *--------------------------------------------------------------
        !           692:  *
        !           693:  * ArcToPoint --
        !           694:  *
        !           695:  *     Computes the distance from a given point to a given
        !           696:  *     arc, in canvas units.
        !           697:  *
        !           698:  * Results:
        !           699:  *     The return value is 0 if the point whose x and y coordinates
        !           700:  *     are coordPtr[0] and coordPtr[1] is inside the arc.  If the
        !           701:  *     point isn't inside the arc then the return value is the
        !           702:  *     distance from the point to the arc.  If itemPtr is filled,
        !           703:  *     then anywhere in the interior is considered "inside"; if
        !           704:  *     itemPtr isn't filled, then "inside" means only the area
        !           705:  *     occupied by the outline.
        !           706:  *
        !           707:  * Side effects:
        !           708:  *     None.
        !           709:  *
        !           710:  *--------------------------------------------------------------
        !           711:  */
        !           712: 
        !           713:        /* ARGSUSED */
        !           714: static double
        !           715: ArcToPoint(canvasPtr, itemPtr, pointPtr)
        !           716:     Tk_Canvas *canvasPtr;      /* Canvas containing item. */
        !           717:     Tk_Item *itemPtr;          /* Item to check against point. */
        !           718:     double *pointPtr;          /* Pointer to x and y coordinates. */
        !           719: {
        !           720:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !           721:     double vertex[2], pointAngle, diff, dist, newDist;
        !           722:     double poly[8], polyDist, width;
        !           723:     int filled, angleInRange;
        !           724: 
        !           725:     if ((arcPtr->fillGC != None) || (arcPtr->outlineGC == None)) {
        !           726:        filled = 1;
        !           727:     } else {
        !           728:        filled = 0;
        !           729:     }
        !           730: 
        !           731:     /*
        !           732:      * See if the point is within the angular range of the arc.
        !           733:      * Remember, X angles are backwards from the way we'd normally
        !           734:      * think of them.  Also, compensate for any eccentricity of
        !           735:      * the oval.
        !           736:      */
        !           737: 
        !           738:     vertex[0] = (arcPtr->bbox[0] + arcPtr->bbox[2])/2.0;
        !           739:     vertex[1] = (arcPtr->bbox[1] + arcPtr->bbox[3])/2.0;
        !           740:     pointAngle = -atan2((pointPtr[1] - vertex[1])
        !           741:            /(arcPtr->bbox[3] - arcPtr->bbox[1]),
        !           742:            (pointPtr[0] - vertex[0])/(arcPtr->bbox[2] - arcPtr->bbox[0]));
        !           743:     pointAngle *= 180/PI;
        !           744:     diff = pointAngle - arcPtr->start;
        !           745:     diff -= ((int) (diff/360.0) * 360.0);
        !           746:     if (diff < 0) {
        !           747:        diff += 360.0;
        !           748:     }
        !           749:     angleInRange = (diff <= arcPtr->extent) ||
        !           750:            ((arcPtr->extent < 0) && ((diff - 360.0) >= arcPtr->extent));
        !           751: 
        !           752:     /*
        !           753:      * Now perform different tests depending on what kind of arc
        !           754:      * we're dealing with.
        !           755:      */
        !           756: 
        !           757:     if (arcPtr->style == arcUid) {
        !           758:        if (angleInRange) {
        !           759:            return TkOvalToPoint(arcPtr->bbox, (double) arcPtr->width,
        !           760:                    0, pointPtr);
        !           761:        }
        !           762:        dist = hypot(pointPtr[0] - arcPtr->center1[0],
        !           763:                pointPtr[1] - arcPtr->center1[1]);
        !           764:        newDist = hypot(pointPtr[0] - arcPtr->center2[0],
        !           765:                pointPtr[1] - arcPtr->center2[1]);
        !           766:        if (newDist < dist) {
        !           767:            return newDist;
        !           768:        }
        !           769:        return dist;
        !           770:     }
        !           771: 
        !           772:     if ((arcPtr->fillGC != None) || (arcPtr->outlineGC == None)) {
        !           773:        filled = 1;
        !           774:     } else {
        !           775:        filled = 0;
        !           776:     }
        !           777:     if (arcPtr->outlineGC == None) {
        !           778:        width = 0.0;
        !           779:     } else {
        !           780:        width = arcPtr->width;
        !           781:     }
        !           782: 
        !           783:     if (arcPtr->style == pieSliceUid) {
        !           784:        if (width > 1.0) {
        !           785:            dist = TkPolygonToPoint(arcPtr->outlinePtr, PIE_OUTLINE1_PTS,
        !           786:                    pointPtr);
        !           787:            newDist = TkPolygonToPoint(arcPtr->outlinePtr + 2*PIE_OUTLINE1_PTS,
        !           788:                        PIE_OUTLINE2_PTS, pointPtr);
        !           789:        } else {
        !           790:            dist = TkLineToPoint(vertex, arcPtr->center1, pointPtr);
        !           791:            newDist = TkLineToPoint(vertex, arcPtr->center2, pointPtr);
        !           792:        }
        !           793:        if (newDist < dist) {
        !           794:            dist = newDist;
        !           795:        }
        !           796:        if (angleInRange) {
        !           797:            newDist = TkOvalToPoint(arcPtr->bbox, width, filled, pointPtr);
        !           798:            if (newDist < dist) {
        !           799:                dist = newDist;
        !           800:            }
        !           801:        }
        !           802:        return dist;
        !           803:     }
        !           804: 
        !           805:     /*
        !           806:      * This is a chord-style arc.  We have to deal specially with the
        !           807:      * triangular piece that represents the difference between a
        !           808:      * chord-style arc and a pie-slice arc (for small angles this piece
        !           809:      * is excluded here where it would be included for pie slices;
        !           810:      * for large angles the piece is included here but would be
        !           811:      * excluded for pie slices).
        !           812:      */
        !           813: 
        !           814:     if (width > 1.0) {
        !           815:        dist = TkPolygonToPoint(arcPtr->outlinePtr, CHORD_OUTLINE_PTS,
        !           816:                    pointPtr);
        !           817:     } else {
        !           818:        dist = TkLineToPoint(arcPtr->center1, arcPtr->center2, pointPtr);
        !           819:     }
        !           820:     poly[0] = poly[6] = vertex[0];
        !           821:     poly[1] = poly[7] = vertex[1];
        !           822:     poly[2] = arcPtr->center1[0];
        !           823:     poly[3] = arcPtr->center1[1];
        !           824:     poly[4] = arcPtr->center2[0];
        !           825:     poly[5] = arcPtr->center2[1];
        !           826:     polyDist = TkPolygonToPoint(poly, 4, pointPtr);
        !           827:     if (angleInRange) {
        !           828:        if ((arcPtr->extent < -180.0) || (arcPtr->extent > 180.0)
        !           829:                || (polyDist > 0.0)) {
        !           830:            newDist = TkOvalToPoint(arcPtr->bbox, width, filled, pointPtr);
        !           831:            if (newDist < dist) {
        !           832:                dist = newDist;
        !           833:            }
        !           834:        }
        !           835:     } else {
        !           836:        if ((arcPtr->extent < -180.0) || (arcPtr->extent > 180.0)) {
        !           837:            if (filled && (polyDist < dist)) {
        !           838:                dist = polyDist;
        !           839:            }
        !           840:        }
        !           841:     }
        !           842:     return dist;
        !           843: }
        !           844: 
        !           845: /*
        !           846:  *--------------------------------------------------------------
        !           847:  *
        !           848:  * ArcToArea --
        !           849:  *
        !           850:  *     This procedure is called to determine whether an item
        !           851:  *     lies entirely inside, entirely outside, or overlapping
        !           852:  *     a given area.
        !           853:  *
        !           854:  * Results:
        !           855:  *     -1 is returned if the item is entirely outside the area
        !           856:  *     given by rectPtr, 0 if it overlaps, and 1 if it is entirely
        !           857:  *     inside the given area.
        !           858:  *
        !           859:  * Side effects:
        !           860:  *     None.
        !           861:  *
        !           862:  *--------------------------------------------------------------
        !           863:  */
        !           864: 
        !           865:        /* ARGSUSED */
        !           866: static int
        !           867: ArcToArea(canvasPtr, itemPtr, rectPtr)
        !           868:     Tk_Canvas *canvasPtr;      /* Canvas containing item. */
        !           869:     Tk_Item *itemPtr;          /* Item to check against arc. */
        !           870:     double *rectPtr;           /* Pointer to array of four coordinates
        !           871:                                 * (x1, y1, x2, y2) describing rectangular
        !           872:                                 * area.  */
        !           873: {
        !           874:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !           875:     double rx, ry;             /* Radii for transformed oval:  these define
        !           876:                                 * an oval centered at the origin. */
        !           877:     double tRect[4];           /* Transformed version of x1, y1, x2, y2,
        !           878:                                 * for coord. system where arc is centered
        !           879:                                 * on the origin. */
        !           880:     double center[2], width, angle, tmp;
        !           881:     double points[20], *pointPtr;
        !           882:     int numPoints, filled;
        !           883:     int inside;                        /* Non-zero means every test so far suggests
        !           884:                                 * that arc is inside rectangle.  0 means
        !           885:                                 * every test so far shows arc to be outside
        !           886:                                 * of rectangle. */
        !           887:     int newInside;
        !           888: 
        !           889:     if ((arcPtr->fillGC != None) || (arcPtr->outlineGC == None)) {
        !           890:        filled = 1;
        !           891:     } else {
        !           892:        filled = 0;
        !           893:     }
        !           894:     if (arcPtr->outlineGC == None) {
        !           895:        width = 0.0;
        !           896:     } else {
        !           897:        width = arcPtr->width;
        !           898:     }
        !           899: 
        !           900:     /*
        !           901:      * Transform both the arc and the rectangle so that the arc's oval
        !           902:      * is centered on the origin.
        !           903:      */
        !           904: 
        !           905:     center[0] = (arcPtr->bbox[0] + arcPtr->bbox[2])/2.0;
        !           906:     center[1] = (arcPtr->bbox[1] + arcPtr->bbox[3])/2.0;
        !           907:     tRect[0] = rectPtr[0] - center[0];
        !           908:     tRect[1] = rectPtr[1] - center[1];
        !           909:     tRect[2] = rectPtr[2] - center[0];
        !           910:     tRect[3] = rectPtr[3] - center[1];
        !           911:     rx = arcPtr->bbox[2] - center[0] + width/2.0;
        !           912:     ry = arcPtr->bbox[3] - center[1] + width/2.0;
        !           913: 
        !           914:     /*
        !           915:      * Find the extreme points of the arc and see whether these are all
        !           916:      * inside the rectangle (in which case we're done), partly in and
        !           917:      * partly out (in which case we're done), or all outside (in which
        !           918:      * case we have more work to do).  The extreme points include the
        !           919:      * following, which are checked in order:
        !           920:      *
        !           921:      * 1. The outside points of the arc, corresponding to start and
        !           922:      *   extent.
        !           923:      * 2. The center of the arc (but only in pie-slice mode).
        !           924:      * 3. The 12, 3, 6, and 9-o'clock positions (but only if the arc
        !           925:      *    includes those angles).
        !           926:      */
        !           927: 
        !           928:     pointPtr = points;
        !           929:     numPoints = 0;
        !           930:     angle = -arcPtr->start*(PI/180.0);
        !           931:     pointPtr[0] = rx*cos(angle);
        !           932:     pointPtr[1] = ry*sin(angle);
        !           933:     angle += -arcPtr->extent*(PI/180.0);
        !           934:     pointPtr[2] = rx*cos(angle);
        !           935:     pointPtr[3] = ry*sin(angle);
        !           936:     numPoints = 2;
        !           937:     pointPtr += 4;
        !           938: 
        !           939:     if ((arcPtr->style == pieSliceUid) && (arcPtr->extent < 180.0)) {
        !           940:        pointPtr[0] = 0.0;
        !           941:        pointPtr[1] = 0.0;
        !           942:        numPoints++;
        !           943:        pointPtr += 2;
        !           944:     }
        !           945: 
        !           946:     tmp = -arcPtr->start;
        !           947:     if (tmp < 0) {
        !           948:        tmp += 360.0;
        !           949:     }
        !           950:     if ((tmp < arcPtr->extent) || ((tmp-360) > arcPtr->extent)) {
        !           951:        pointPtr[0] = rx;
        !           952:        pointPtr[1] = 0.0;
        !           953:        numPoints++;
        !           954:        pointPtr += 2;
        !           955:     }
        !           956:     tmp = 90.0 - arcPtr->start;
        !           957:     if (tmp < 0) {
        !           958:        tmp += 360.0;
        !           959:     }
        !           960:     if ((tmp < arcPtr->extent) || ((tmp-360) > arcPtr->extent)) {
        !           961:        pointPtr[0] = 0.0;
        !           962:        pointPtr[1] = -ry;
        !           963:        numPoints++;
        !           964:        pointPtr += 2;
        !           965:     }
        !           966:     tmp = 180.0 - arcPtr->start;
        !           967:     if (tmp < 0) {
        !           968:        tmp += 360.0;
        !           969:     }
        !           970:     if ((tmp < arcPtr->extent) || ((tmp-360) > arcPtr->extent)) {
        !           971:        pointPtr[0] = -rx;
        !           972:        pointPtr[1] = 0.0;
        !           973:        numPoints++;
        !           974:        pointPtr += 2;
        !           975:     }
        !           976:     tmp = 270.0 - arcPtr->start;
        !           977:     if (tmp < 0) {
        !           978:        tmp += 360.0;
        !           979:     }
        !           980:     if ((tmp < arcPtr->extent) || ((tmp-360) > arcPtr->extent)) {
        !           981:        pointPtr[0] = 0.0;
        !           982:        pointPtr[1] = ry;
        !           983:        numPoints++;
        !           984:        pointPtr += 2;
        !           985:     }
        !           986: 
        !           987:     /*
        !           988:      * Now that we've located the extreme points, loop through them all
        !           989:      * to see which are inside the rectangle.
        !           990:      */
        !           991: 
        !           992:     inside = (points[0] > tRect[0]) && (points[0] < tRect[2])
        !           993:            && (points[1] > tRect[1]) && (points[1] < tRect[3]);
        !           994:     for (pointPtr = points+2; numPoints > 1; pointPtr += 2, numPoints--) {
        !           995:        newInside = (pointPtr[0] > tRect[0]) && (pointPtr[0] < tRect[2])
        !           996:                && (pointPtr[1] > tRect[1]) && (pointPtr[1] < tRect[3]);
        !           997:        if (newInside != inside) {
        !           998:            return 0;
        !           999:        }
        !          1000:     }
        !          1001: 
        !          1002:     if (inside) {
        !          1003:        return 1;
        !          1004:     }
        !          1005: 
        !          1006:     /*
        !          1007:      * So far, oval appears to be outside rectangle, but can't yet tell
        !          1008:      * for sure.  Next, test each of the four sides of the rectangle
        !          1009:      * against the bounding region for the arc.  If any intersections
        !          1010:      * are found, then return "overlapping".  First, test against the
        !          1011:      * polygon(s) forming the sides of a chord or pie-slice.
        !          1012:      */
        !          1013: 
        !          1014:     if (arcPtr->style == pieSliceUid) {
        !          1015:        if (width >= 1.0) {
        !          1016:            if (TkPolygonToArea(arcPtr->outlinePtr, PIE_OUTLINE1_PTS,
        !          1017:                    rectPtr) != -1)  {
        !          1018:                return 0;
        !          1019:            }
        !          1020:            if (TkPolygonToArea(arcPtr->outlinePtr + 2*PIE_OUTLINE1_PTS,
        !          1021:                    PIE_OUTLINE2_PTS, rectPtr) != -1) {
        !          1022:                return 0;
        !          1023:            }
        !          1024:        } else {
        !          1025:            if ((TkLineToArea(center, arcPtr->center1, rectPtr) != -1) ||
        !          1026:                    (TkLineToArea(center, arcPtr->center2, rectPtr) != -1)) {
        !          1027:                return 0;
        !          1028:            }
        !          1029:        }
        !          1030:     } else if (arcPtr->style == chordUid) {
        !          1031:        if (width >= 1.0) {
        !          1032:            if (TkPolygonToArea(arcPtr->outlinePtr, CHORD_OUTLINE_PTS,
        !          1033:                    rectPtr) != -1) {
        !          1034:                return 0;
        !          1035:            }
        !          1036:        } else {
        !          1037:            if (TkLineToArea(arcPtr->center1, arcPtr->center2,
        !          1038:                    rectPtr) != -1) {
        !          1039:                return 0;
        !          1040:            }
        !          1041:        }
        !          1042:     }
        !          1043: 
        !          1044:     /*
        !          1045:      * Next check for overlap between each of the four sides and the
        !          1046:      * outer perimiter of the arc.  If the arc isn't filled, then also
        !          1047:      * check the inner perimeter of the arc.
        !          1048:      */
        !          1049: 
        !          1050:     if (HorizLineToArc(tRect[0], tRect[2], tRect[1], rx, ry, arcPtr->start,
        !          1051:                arcPtr->extent)
        !          1052:            || HorizLineToArc(tRect[0], tRect[2], tRect[3], rx, ry,
        !          1053:                arcPtr->start, arcPtr->extent)
        !          1054:            || VertLineToArc(tRect[0], tRect[1], tRect[3], rx, ry,
        !          1055:                arcPtr->start, arcPtr->extent)
        !          1056:            || VertLineToArc(tRect[2], tRect[1], tRect[3], rx, ry,
        !          1057:                arcPtr->start, arcPtr->extent)) {
        !          1058:        return 0;
        !          1059:     }
        !          1060:     if ((width > 1.0) && !filled) {
        !          1061:        rx -= width;
        !          1062:        ry -= width;
        !          1063:        if (HorizLineToArc(tRect[0], tRect[2], tRect[1], rx, ry, arcPtr->start,
        !          1064:                    arcPtr->extent)
        !          1065:                || HorizLineToArc(tRect[0], tRect[2], tRect[3], rx, ry,
        !          1066:                    arcPtr->start, arcPtr->extent)
        !          1067:                || VertLineToArc(tRect[0], tRect[1], tRect[3], rx, ry,
        !          1068:                    arcPtr->start, arcPtr->extent)
        !          1069:                || VertLineToArc(tRect[2], tRect[1], tRect[3], rx, ry,
        !          1070:                    arcPtr->start, arcPtr->extent)) {
        !          1071:            return 0;
        !          1072:        }
        !          1073:     }
        !          1074: 
        !          1075:     /*
        !          1076:      * The arc still appears to be totally disjoint from the rectangle,
        !          1077:      * but it's also possible that the rectangle is totally inside the arc.
        !          1078:      * Do one last check, which is to check one point of the rectangle
        !          1079:      * to see if it's inside the arc.  If it is, we've got overlap.  If
        !          1080:      * it isn't, the arc's really outside the rectangle.
        !          1081:      */
        !          1082: 
        !          1083:     if (ArcToPoint(canvasPtr, itemPtr, rectPtr) == 0.0) {
        !          1084:        return 0;
        !          1085:     }
        !          1086:     return -1;
        !          1087: }
        !          1088: 
        !          1089: /*
        !          1090:  *--------------------------------------------------------------
        !          1091:  *
        !          1092:  * ScaleArc --
        !          1093:  *
        !          1094:  *     This procedure is invoked to rescale an arc item.
        !          1095:  *
        !          1096:  * Results:
        !          1097:  *     None.
        !          1098:  *
        !          1099:  * Side effects:
        !          1100:  *     The arc referred to by itemPtr is rescaled so that the
        !          1101:  *     following transformation is applied to all point
        !          1102:  *     coordinates:
        !          1103:  *             x' = originX + scaleX*(x-originX)
        !          1104:  *             y' = originY + scaleY*(y-originY)
        !          1105:  *
        !          1106:  *--------------------------------------------------------------
        !          1107:  */
        !          1108: 
        !          1109: static void
        !          1110: ScaleArc(canvasPtr, itemPtr, originX, originY, scaleX, scaleY)
        !          1111:     Tk_Canvas *canvasPtr;              /* Canvas containing arc. */
        !          1112:     Tk_Item *itemPtr;                  /* Arc to be scaled. */
        !          1113:     double originX, originY;           /* Origin about which to scale rect. */
        !          1114:     double scaleX;                     /* Amount to scale in X direction. */
        !          1115:     double scaleY;                     /* Amount to scale in Y direction. */
        !          1116: {
        !          1117:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !          1118: 
        !          1119:     arcPtr->bbox[0] = originX + scaleX*(arcPtr->bbox[0] - originX);
        !          1120:     arcPtr->bbox[1] = originY + scaleY*(arcPtr->bbox[1] - originY);
        !          1121:     arcPtr->bbox[2] = originX + scaleX*(arcPtr->bbox[2] - originX);
        !          1122:     arcPtr->bbox[3] = originY + scaleY*(arcPtr->bbox[3] - originY);
        !          1123:     ComputeArcBbox(canvasPtr, arcPtr);
        !          1124: }
        !          1125: 
        !          1126: /*
        !          1127:  *--------------------------------------------------------------
        !          1128:  *
        !          1129:  * TranslateArc --
        !          1130:  *
        !          1131:  *     This procedure is called to move an arc by a given amount.
        !          1132:  *
        !          1133:  * Results:
        !          1134:  *     None.
        !          1135:  *
        !          1136:  * Side effects:
        !          1137:  *     The position of the arc is offset by (xDelta, yDelta), and
        !          1138:  *     the bounding box is updated in the generic part of the item
        !          1139:  *     structure.
        !          1140:  *
        !          1141:  *--------------------------------------------------------------
        !          1142:  */
        !          1143: 
        !          1144: static void
        !          1145: TranslateArc(canvasPtr, itemPtr, deltaX, deltaY)
        !          1146:     Tk_Canvas *canvasPtr;              /* Canvas containing item. */
        !          1147:     Tk_Item *itemPtr;                  /* Item that is being moved. */
        !          1148:     double deltaX, deltaY;             /* Amount by which item is to be
        !          1149:                                         * moved. */
        !          1150: {
        !          1151:     register ArcItem *arcPtr = (ArcItem *) itemPtr;
        !          1152: 
        !          1153:     arcPtr->bbox[0] += deltaX;
        !          1154:     arcPtr->bbox[1] += deltaY;
        !          1155:     arcPtr->bbox[2] += deltaX;
        !          1156:     arcPtr->bbox[3] += deltaY;
        !          1157:     ComputeArcBbox(canvasPtr, arcPtr);
        !          1158: }
        !          1159: 
        !          1160: /*
        !          1161:  *--------------------------------------------------------------
        !          1162:  *
        !          1163:  * ComputeArcOutline --
        !          1164:  *
        !          1165:  *     This procedure creates a polygon describing everything in
        !          1166:  *     the outline for an arc except what's in the curved part.
        !          1167:  *     For a "pie slice" arc this is a V-shaped chunk, and for
        !          1168:  *     a "chord" arc this is a linear chunk (with cutaway corners).
        !          1169:  *     For "arc" arcs, this stuff isn't relevant.
        !          1170:  *
        !          1171:  * Results:
        !          1172:  *     None.
        !          1173:  *
        !          1174:  * Side effects:
        !          1175:  *     The information at arcPtr->outlinePtr gets modified, and
        !          1176:  *     storage for arcPtr->outlinePtr may be allocated or freed.
        !          1177:  *
        !          1178:  *--------------------------------------------------------------
        !          1179:  */
        !          1180: 
        !          1181: static void
        !          1182: ComputeArcOutline(arcPtr)
        !          1183:     register ArcItem *arcPtr;
        !          1184: {
        !          1185:     double sin1, cos1, sin2, cos2, angle, halfWidth;
        !          1186:     double boxWidth, boxHeight;
        !          1187:     double vertex[2], corner1[2], corner2[2];
        !          1188:     double *outlinePtr;
        !          1189: 
        !          1190:     /*
        !          1191:      * Make sure that the outlinePtr array is large enough to hold
        !          1192:      * either a chord or pie-slice outline.
        !          1193:      */
        !          1194: 
        !          1195:     if (arcPtr->numOutlinePoints == 0) {
        !          1196:        arcPtr->outlinePtr = (double *) ckalloc((unsigned)
        !          1197:                (26 * sizeof(double)));
        !          1198:        arcPtr->numOutlinePoints = 22;
        !          1199:     }
        !          1200:     outlinePtr = arcPtr->outlinePtr;
        !          1201: 
        !          1202:     /*
        !          1203:      * First compute the two points that lie at the centers of
        !          1204:      * the ends of the curved arc segment, which are marked with
        !          1205:      * X's in the figure below:
        !          1206:      *
        !          1207:      *
        !          1208:      *                           * * *
        !          1209:      *                       *          *
        !          1210:      *                    *      * *      *
        !          1211:      *                  *    *         *    *
        !          1212:      *                 *   *             *   *
        !          1213:      *                  X *               * X
        !          1214:      *
        !          1215:      * The code is tricky because the arc can be ovular in shape.
        !          1216:      * It computes the position for a unit circle, and then
        !          1217:      * scales to fit the shape of the arc's bounding box.
        !          1218:      *
        !          1219:      * Also, watch out because angles go counter-clockwise like you
        !          1220:      * might expect, but the y-coordinate system is inverted.  To
        !          1221:      * handle this, just negate the angles in all the computations.
        !          1222:      */
        !          1223: 
        !          1224:     boxWidth = arcPtr->bbox[2] - arcPtr->bbox[0];
        !          1225:     boxHeight = arcPtr->bbox[3] - arcPtr->bbox[1];
        !          1226:     angle = -arcPtr->start*PI/180.0;
        !          1227:     sin1 = sin(angle);
        !          1228:     cos1 = cos(angle);
        !          1229:     angle -= arcPtr->extent*PI/180.0;
        !          1230:     sin2 = sin(angle);
        !          1231:     cos2 = cos(angle);
        !          1232:     vertex[0] = (arcPtr->bbox[0] + arcPtr->bbox[2])/2.0;
        !          1233:     vertex[1] = (arcPtr->bbox[1] + arcPtr->bbox[3])/2.0;
        !          1234:     arcPtr->center1[0] = vertex[0] + cos1*boxWidth/2.0;
        !          1235:     arcPtr->center1[1] = vertex[1] + sin1*boxHeight/2.0;
        !          1236:     arcPtr->center2[0] = vertex[0] + cos2*boxWidth/2.0;
        !          1237:     arcPtr->center2[1] = vertex[1] + sin2*boxHeight/2.0;
        !          1238: 
        !          1239:     /*
        !          1240:      * Next compute the "outermost corners" of the arc, which are
        !          1241:      * marked with X's in the figure below:
        !          1242:      *
        !          1243:      *                           * * *
        !          1244:      *                       *          *
        !          1245:      *                    *      * *      *
        !          1246:      *                  *    *         *    *
        !          1247:      *                 X   *             *   X
        !          1248:      *                    *               *
        !          1249:      *
        !          1250:      * The code below is tricky because it has to handle eccentricity
        !          1251:      * in the shape of the oval.  The key in the code below is to
        !          1252:      * realize that the slope of the line from arcPtr->center1 to corner1
        !          1253:      * is (boxWidth*sin1)/(boxHeight*cos1), and similarly for arcPtr->center2
        !          1254:      * and corner2.  These formulas can be computed from the formula for
        !          1255:      * the oval.
        !          1256:      */
        !          1257: 
        !          1258:     halfWidth = arcPtr->width/2.0;
        !          1259:     angle = atan2(boxWidth*sin1, boxHeight*cos1);
        !          1260:     corner1[0] = arcPtr->center1[0] + cos(angle)*halfWidth;
        !          1261:     corner1[1] = arcPtr->center1[1] + sin(angle)*halfWidth;
        !          1262:     angle = atan2(boxWidth*sin2, boxHeight*cos2);
        !          1263:     corner2[0] = arcPtr->center2[0] + cos(angle)*halfWidth;
        !          1264:     corner2[1] = arcPtr->center2[1] + sin(angle)*halfWidth;
        !          1265: 
        !          1266:     /*
        !          1267:      * For a chord outline, generate a six-sided polygon with three
        !          1268:      * points for each end of the chord.  The first and third points
        !          1269:      * for each end are butt points generated on either side of the
        !          1270:      * center point.  The second point is the corner point.
        !          1271:      */
        !          1272: 
        !          1273:     if (arcPtr->style == chordUid) {
        !          1274:        outlinePtr[0] = outlinePtr[12] = corner1[0];
        !          1275:        outlinePtr[1] = outlinePtr[13] = corner1[1];
        !          1276:        TkGetButtPoints(arcPtr->center2, arcPtr->center1,
        !          1277:                (double) arcPtr->width, 0, outlinePtr+10, outlinePtr+2);
        !          1278:        outlinePtr[4] = arcPtr->center2[0] + outlinePtr[2]
        !          1279:                - arcPtr->center1[0];
        !          1280:        outlinePtr[5] = arcPtr->center2[1] + outlinePtr[3]
        !          1281:                - arcPtr->center1[1];
        !          1282:        outlinePtr[6] = corner2[0];
        !          1283:        outlinePtr[7] = corner2[1];
        !          1284:        outlinePtr[8] = arcPtr->center2[0] + outlinePtr[10]
        !          1285:                - arcPtr->center1[0];
        !          1286:        outlinePtr[9] = arcPtr->center2[1] + outlinePtr[11]
        !          1287:                - arcPtr->center1[1];
        !          1288:     } else if (arcPtr->style == pieSliceUid) {
        !          1289:        /*
        !          1290:         * For pie slices, generate two polygons, one for each side
        !          1291:         * of the pie slice.  The first arm has a shape like this,
        !          1292:         * where the center of the oval is X, arcPtr->center1 is at Y, and
        !          1293:         * corner1 is at Z:
        !          1294:         *
        !          1295:         *       _____________________
        !          1296:         *      |                     \
        !          1297:         *      |                      \
        !          1298:         *      X                    Y  Z
        !          1299:         *      |                      /
        !          1300:         *      |_____________________/
        !          1301:         *
        !          1302:         */
        !          1303: 
        !          1304:        TkGetButtPoints(arcPtr->center1, vertex, (double) arcPtr->width, 0,
        !          1305:                outlinePtr, outlinePtr+2);
        !          1306:        outlinePtr[4] = arcPtr->center1[0] + outlinePtr[2] - vertex[0];
        !          1307:        outlinePtr[5] = arcPtr->center1[1] + outlinePtr[3] - vertex[1];
        !          1308:        outlinePtr[6] = corner1[0];
        !          1309:        outlinePtr[7] = corner1[1];
        !          1310:        outlinePtr[8] = arcPtr->center1[0] + outlinePtr[0] - vertex[0];
        !          1311:        outlinePtr[9] = arcPtr->center1[1] + outlinePtr[1] - vertex[1];
        !          1312:        outlinePtr[10] = outlinePtr[0];
        !          1313:        outlinePtr[11] = outlinePtr[1];
        !          1314: 
        !          1315:        /*
        !          1316:         * The second arm has a shape like this:
        !          1317:         *
        !          1318:         *
        !          1319:         *         ______________________
        !          1320:         *        /                       \
        !          1321:         *       /                         \
        !          1322:         *      Z  Y                    X  /
        !          1323:         *       \                        /
        !          1324:         *        \______________________/
        !          1325:         *
        !          1326:         * Similar to above X is the center of the oval/circle, Y is
        !          1327:         * arcPtr->center2, and Z is corner2.  The extra jog out to the left
        !          1328:         * of X is needed in or to produce a butted joint with the
        !          1329:         * first arm;  the corner to the right of X is one of the
        !          1330:         * first two points of the first arm, depending on extent.
        !          1331:         */
        !          1332: 
        !          1333:        TkGetButtPoints(arcPtr->center2, vertex, (double) arcPtr->width, 0,
        !          1334:                outlinePtr+12, outlinePtr+16);
        !          1335:        if ((arcPtr->extent > 180) ||
        !          1336:                ((arcPtr->extent < 0) && (arcPtr->extent > -180))) {
        !          1337:            outlinePtr[14] = outlinePtr[0];
        !          1338:            outlinePtr[15] = outlinePtr[1];
        !          1339:        } else {
        !          1340:            outlinePtr[14] = outlinePtr[2];
        !          1341:            outlinePtr[15] = outlinePtr[3];
        !          1342:        }
        !          1343:        outlinePtr[18] = arcPtr->center2[0] + outlinePtr[16] - vertex[0];
        !          1344:        outlinePtr[19] = arcPtr->center2[1] + outlinePtr[17] - vertex[1];
        !          1345:        outlinePtr[20] = corner2[0];
        !          1346:        outlinePtr[21] = corner2[1];
        !          1347:        outlinePtr[22] = arcPtr->center2[0] + outlinePtr[12] - vertex[0];
        !          1348:        outlinePtr[23] = arcPtr->center2[1] + outlinePtr[13] - vertex[1];
        !          1349:        outlinePtr[24] = outlinePtr[12];
        !          1350:        outlinePtr[25] = outlinePtr[13];
        !          1351:     }
        !          1352: }
        !          1353: 
        !          1354: /*
        !          1355:  *--------------------------------------------------------------
        !          1356:  *
        !          1357:  * HorizLineToArc --
        !          1358:  *
        !          1359:  *     Determines whether a horizontal line segment intersects
        !          1360:  *     a given arc.
        !          1361:  *
        !          1362:  * Results:
        !          1363:  *     The return value is 1 if the given line intersects the
        !          1364:  *     infinitely-thin arc section defined by rx, ry, start,
        !          1365:  *     and extent, and 0 otherwise.  Only the perimeter of the
        !          1366:  *     arc is checked: interior areas (e.g. pie-slice or chord)
        !          1367:  *     are not checked.
        !          1368:  *
        !          1369:  * Side effects:
        !          1370:  *     None.
        !          1371:  *
        !          1372:  *--------------------------------------------------------------
        !          1373:  */
        !          1374: 
        !          1375: static int
        !          1376: HorizLineToArc(x1, x2, y, rx, ry, start, extent)
        !          1377:     double x1, x2;             /* X-coords of endpoints of line segment. 
        !          1378:                                 * X1 must be <= x2. */
        !          1379:     double y;                  /* Y-coordinate of line segment. */
        !          1380:     double rx, ry;             /* These x- and y-radii define an oval
        !          1381:                                 * centered at the origin. */
        !          1382:     double start, extent;      /* Angles that define extent of arc, in
        !          1383:                                 * the standard fashion for this module. */
        !          1384: {
        !          1385:     double tmp;
        !          1386:     double tx, ty;             /* Coordinates of intersection point in
        !          1387:                                 * transformed coordinate system. */
        !          1388:     double x;
        !          1389: 
        !          1390:     /*
        !          1391:      * Compute the x-coordinate of one possible intersection point
        !          1392:      * between the arc and the line.  Use a transformed coordinate
        !          1393:      * system where the oval is a unit circle centered at the origin.
        !          1394:      * Then scale back to get actual x-coordinate.
        !          1395:      */
        !          1396: 
        !          1397:     ty = y/ry;
        !          1398:     tmp = 1 - ty*ty;
        !          1399:     if (tmp < 0) {
        !          1400:        return 0;
        !          1401:     }
        !          1402:     tx = sqrt(tmp);
        !          1403:     x = tx*rx;
        !          1404: 
        !          1405:     /*
        !          1406:      * Test both intersection points.
        !          1407:      */
        !          1408: 
        !          1409:     if ((x >= x1) && (x <= x2) && AngleInRange(tx, ty, start, extent)) {
        !          1410:        return 1;
        !          1411:     }
        !          1412:     if ((-x >= x1) && (-x <= x2) && AngleInRange(-tx, ty, start, extent)) {
        !          1413:        return 1;
        !          1414:     }
        !          1415:     return 0;
        !          1416: }
        !          1417: 
        !          1418: /*
        !          1419:  *--------------------------------------------------------------
        !          1420:  *
        !          1421:  * VertLineToArc --
        !          1422:  *
        !          1423:  *     Determines whether a vertical line segment intersects
        !          1424:  *     a given arc.
        !          1425:  *
        !          1426:  * Results:
        !          1427:  *     The return value is 1 if the given line intersects the
        !          1428:  *     infinitely-thin arc section defined by rx, ry, start,
        !          1429:  *     and extent, and 0 otherwise.  Only the perimeter of the
        !          1430:  *     arc is checked: interior areas (e.g. pie-slice or chord)
        !          1431:  *     are not checked.
        !          1432:  *
        !          1433:  * Side effects:
        !          1434:  *     None.
        !          1435:  *
        !          1436:  *--------------------------------------------------------------
        !          1437:  */
        !          1438: 
        !          1439: static int
        !          1440: VertLineToArc(x, y1, y2, rx, ry, start, extent)
        !          1441:     double x;                  /* X-coordinate of line segment. */
        !          1442:     double y1, y2;             /* Y-coords of endpoints of line segment. 
        !          1443:                                 * Y1 must be <= y2. */
        !          1444:     double rx, ry;             /* These x- and y-radii define an oval
        !          1445:                                 * centered at the origin. */
        !          1446:     double start, extent;      /* Angles that define extent of arc, in
        !          1447:                                 * the standard fashion for this module. */
        !          1448: {
        !          1449:     double tmp;
        !          1450:     double tx, ty;             /* Coordinates of intersection point in
        !          1451:                                 * transformed coordinate system. */
        !          1452:     double y;
        !          1453: 
        !          1454:     /*
        !          1455:      * Compute the y-coordinate of one possible intersection point
        !          1456:      * between the arc and the line.  Use a transformed coordinate
        !          1457:      * system where the oval is a unit circle centered at the origin.
        !          1458:      * Then scale back to get actual y-coordinate.
        !          1459:      */
        !          1460: 
        !          1461:     tx = x/rx;
        !          1462:     tmp = 1 - tx*tx;
        !          1463:     if (tmp < 0) {
        !          1464:        return 0;
        !          1465:     }
        !          1466:     ty = sqrt(tmp);
        !          1467:     y = ty*ry;
        !          1468: 
        !          1469:     /*
        !          1470:      * Test both intersection points.
        !          1471:      */
        !          1472: 
        !          1473:     if ((y > y1) && (y < y2) && AngleInRange(tx, ty, start, extent)) {
        !          1474:        return 1;
        !          1475:     }
        !          1476:     if ((-y > y1) && (-y < y2) && AngleInRange(tx, -ty, start, extent)) {
        !          1477:        return 1;
        !          1478:     }
        !          1479:     return 0;
        !          1480: }
        !          1481: 
        !          1482: /*
        !          1483:  *--------------------------------------------------------------
        !          1484:  *
        !          1485:  * AngleInRange --
        !          1486:  *
        !          1487:  *     Determine whether the angle from the origin to a given
        !          1488:  *     point is within a given range.
        !          1489:  *
        !          1490:  * Results:
        !          1491:  *     The return value is 1 if the angle from (0,0) to (x,y)
        !          1492:  *     is in the range given by start and extent, where angles
        !          1493:  *     are interpreted in the standard way for ovals (meaning
        !          1494:  *     backwards from normal interpretation).  Otherwise the
        !          1495:  *     return value is 0.
        !          1496:  *
        !          1497:  * Side effects:
        !          1498:  *     None.
        !          1499:  *
        !          1500:  *--------------------------------------------------------------
        !          1501:  */
        !          1502: 
        !          1503: static int
        !          1504: AngleInRange(x, y, start, extent)
        !          1505:     double x, y;               /* Coordinate of point;  angle measured
        !          1506:                                 * from origin to here, relative to x-axis. */
        !          1507:     double start;              /* First angle, degrees, >=0, <=360. */
        !          1508:     double extent;             /* Size of arc in degrees >=-360, <=360. */
        !          1509: {
        !          1510:     double diff;
        !          1511: 
        !          1512:     diff = -atan2(y, x);
        !          1513:     diff = diff*(180.0/PI) - start;
        !          1514:     while (diff > 360.0) {
        !          1515:        diff -= 360.0;
        !          1516:     }
        !          1517:     while (diff < 0.0) {
        !          1518:        diff += 360.0;
        !          1519:     }
        !          1520:     if (extent >= 0) {
        !          1521:        return diff <= extent;
        !          1522:     }
        !          1523:     return (diff-360.0) >= extent;
        !          1524: }

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