![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkrectov.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tk|
Return to tkrectov.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkRectOval.c -- ! 3: * ! 4: * This file implements rectangle and oval items for canvas ! 5: * widgets. ! 6: * ! 7: * Copyright 1991-1992 Regents of the University of California. ! 8: * Permission to use, copy, modify, and distribute this ! 9: * software and its documentation for any purpose and without ! 10: * fee is hereby granted, provided that the above copyright ! 11: * notice appear in all copies. The University of California ! 12: * makes no representations about the suitability of this ! 13: * software for any purpose. It is provided "as is" without ! 14: * express or implied warranty. ! 15: */ ! 16: ! 17: #ifndef lint ! 18: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkRectOval.c,v 1.15 92/08/24 09:23:58 ouster Exp $ SPRITE (Berkeley)"; ! 19: #endif ! 20: ! 21: #include <stdio.h> ! 22: #include <math.h> ! 23: #include "tkconfig.h" ! 24: #include "tkint.h" ! 25: #include "tkcanvas.h" ! 26: ! 27: /* ! 28: * The structure below defines the record for each rectangle/oval item. ! 29: */ ! 30: ! 31: typedef struct RectOvalItem { ! 32: Tk_Item header; /* Generic stuff that's the same for all ! 33: * types. MUST BE FIRST IN STRUCTURE. */ ! 34: double bbox[4]; /* Coordinates of bounding box for rectangle ! 35: * or oval (x1, y1, x2, y2). Item includes ! 36: * x1 and x2 but not y1 and y2. */ ! 37: int width; /* Width of outline. */ ! 38: XColor *outlineColor; /* Color for outline. */ ! 39: XColor *fillColor; /* Color for filling rectangle/oval. */ ! 40: Pixmap fillStipple; /* Stipple bitmap for filling item. */ ! 41: GC outlineGC; /* Graphics context for outline. */ ! 42: GC fillGC; /* Graphics context for filling item. */ ! 43: } RectOvalItem; ! 44: ! 45: /* ! 46: * Information used for parsing configuration specs: ! 47: */ ! 48: ! 49: static Tk_ConfigSpec configSpecs[] = { ! 50: {TK_CONFIG_COLOR, "-fill", (char *) NULL, (char *) NULL, ! 51: (char *) NULL, Tk_Offset(RectOvalItem, fillColor), TK_CONFIG_NULL_OK}, ! 52: {TK_CONFIG_COLOR, "-outline", (char *) NULL, (char *) NULL, ! 53: "black", Tk_Offset(RectOvalItem, outlineColor), TK_CONFIG_NULL_OK}, ! 54: {TK_CONFIG_BITMAP, "-stipple", (char *) NULL, (char *) NULL, ! 55: (char *) NULL, Tk_Offset(RectOvalItem, fillStipple), TK_CONFIG_NULL_OK}, ! 56: {TK_CONFIG_CUSTOM, "-tags", (char *) NULL, (char *) NULL, ! 57: (char *) NULL, 0, TK_CONFIG_NULL_OK, &tkCanvasTagsOption}, ! 58: {TK_CONFIG_PIXELS, "-width", (char *) NULL, (char *) NULL, ! 59: "1", Tk_Offset(RectOvalItem, width), TK_CONFIG_DONT_SET_DEFAULT}, ! 60: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL, ! 61: (char *) NULL, 0, 0} ! 62: }; ! 63: ! 64: /* ! 65: * Prototypes for procedures defined in this file: ! 66: */ ! 67: ! 68: static void ComputeRectOvalBbox _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 69: RectOvalItem *rectOvalPtr)); ! 70: static int ConfigureRectOval _ANSI_ARGS_(( ! 71: Tk_Canvas *canvasPtr, Tk_Item *itemPtr, int argc, ! 72: char **argv, int flags)); ! 73: static int CreateRectOval _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 74: struct Tk_Item *itemPtr, int argc, char **argv)); ! 75: static void DeleteRectOval _ANSI_ARGS_((Tk_Item *itemPtr)); ! 76: static void DisplayRectOval _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 77: Tk_Item *itemPtr, Drawable dst)); ! 78: static int OvalToArea _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 79: Tk_Item *itemPtr, double *areaPtr)); ! 80: static double OvalToPoint _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 81: Tk_Item *itemPtr, double *pointPtr)); ! 82: static int RectOvalCoords _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 83: Tk_Item *itemPtr, int argc, char **argv)); ! 84: static int RectToArea _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 85: Tk_Item *itemPtr, double *areaPtr)); ! 86: static double RectToPoint _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 87: Tk_Item *itemPtr, double *pointPtr)); ! 88: static void ScaleRectOval _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 89: Tk_Item *itemPtr, double originX, double originY, ! 90: double scaleX, double scaleY)); ! 91: static void TranslateRectOval _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 92: Tk_Item *itemPtr, double deltaX, double deltaY)); ! 93: ! 94: /* ! 95: * The structures below defines the rectangle and oval item types ! 96: * by means of procedures that can be invoked by generic item code. ! 97: */ ! 98: ! 99: Tk_ItemType TkRectangleType = { ! 100: "rectangle", /* name */ ! 101: sizeof(RectOvalItem), /* itemSize */ ! 102: CreateRectOval, /* createProc */ ! 103: configSpecs, /* configSpecs */ ! 104: ConfigureRectOval, /* configureProc */ ! 105: RectOvalCoords, /* coordProc */ ! 106: DeleteRectOval, /* deleteProc */ ! 107: DisplayRectOval, /* displayProc */ ! 108: 0, /* alwaysRedraw */ ! 109: RectToPoint, /* pointProc */ ! 110: RectToArea, /* areaProc */ ! 111: (Tk_ItemPostscriptProc *) NULL, /* postscriptProc */ ! 112: ScaleRectOval, /* scaleProc */ ! 113: TranslateRectOval, /* translateProc */ ! 114: (Tk_ItemIndexProc *) NULL, /* indexProc */ ! 115: (Tk_ItemCursorProc *) NULL, /* cursorProc */ ! 116: (Tk_ItemSelectionProc *) NULL, /* selectionProc */ ! 117: (Tk_ItemInsertProc *) NULL, /* insertProc */ ! 118: (Tk_ItemDCharsProc *) NULL, /* dTextProc */ ! 119: (Tk_ItemType *) NULL /* nextPtr */ ! 120: }; ! 121: ! 122: Tk_ItemType TkOvalType = { ! 123: "oval", /* name */ ! 124: sizeof(RectOvalItem), /* itemSize */ ! 125: CreateRectOval, /* createProc */ ! 126: configSpecs, /* configSpecs */ ! 127: ConfigureRectOval, /* configureProc */ ! 128: RectOvalCoords, /* coordProc */ ! 129: DeleteRectOval, /* deleteProc */ ! 130: DisplayRectOval, /* displayProc */ ! 131: 0, /* alwaysRedraw */ ! 132: OvalToPoint, /* pointProc */ ! 133: OvalToArea, /* areaProc */ ! 134: (Tk_ItemPostscriptProc *) NULL, /* postscriptProc */ ! 135: ScaleRectOval, /* scaleProc */ ! 136: TranslateRectOval, /* translateProc */ ! 137: (Tk_ItemIndexProc *) NULL, /* indexProc */ ! 138: (Tk_ItemCursorProc *) NULL, /* cursorProc */ ! 139: (Tk_ItemSelectionProc *) NULL, /* selectionProc */ ! 140: (Tk_ItemInsertProc *) NULL, /* insertProc */ ! 141: (Tk_ItemDCharsProc *) NULL, /* dTextProc */ ! 142: (Tk_ItemType *) NULL /* nextPtr */ ! 143: }; ! 144: ! 145: /* ! 146: *-------------------------------------------------------------- ! 147: * ! 148: * CreateRectOval -- ! 149: * ! 150: * This procedure is invoked to create a new rectangle ! 151: * or oval item in a canvas. ! 152: * ! 153: * Results: ! 154: * A standard Tcl return value. If an error occurred in ! 155: * creating the item, then an error message is left in ! 156: * canvasPtr->interp->result; in this case itemPtr is ! 157: * left uninitialized, so it can be safely freed by the ! 158: * caller. ! 159: * ! 160: * Side effects: ! 161: * A new rectangle or oval item is created. ! 162: * ! 163: *-------------------------------------------------------------- ! 164: */ ! 165: ! 166: static int ! 167: CreateRectOval(canvasPtr, itemPtr, argc, argv) ! 168: register Tk_Canvas *canvasPtr; /* Canvas to hold new item. */ ! 169: Tk_Item *itemPtr; /* Record to hold new item; header ! 170: * has been initialized by caller. */ ! 171: int argc; /* Number of arguments in argv. */ ! 172: char **argv; /* Arguments describing rectangle. */ ! 173: { ! 174: register RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr; ! 175: ! 176: if (argc < 4) { ! 177: Tcl_AppendResult(canvasPtr->interp, "wrong # args: should be \"", ! 178: Tk_PathName(canvasPtr->tkwin), "\" create ", ! 179: itemPtr->typePtr->name, " x1 y1 x2 y2 ?options?", ! 180: (char *) NULL); ! 181: return TCL_ERROR; ! 182: } ! 183: ! 184: /* ! 185: * Carry out initialization that is needed in order to clean ! 186: * up after errors during the the remainder of this procedure. ! 187: */ ! 188: ! 189: rectOvalPtr->width = 1; ! 190: rectOvalPtr->outlineColor = NULL; ! 191: rectOvalPtr->fillColor = NULL; ! 192: rectOvalPtr->fillStipple = None; ! 193: rectOvalPtr->outlineGC = None; ! 194: rectOvalPtr->fillGC = None; ! 195: ! 196: /* ! 197: * Process the arguments to fill in the item record. ! 198: */ ! 199: ! 200: if ((TkGetCanvasCoord(canvasPtr, argv[0], &rectOvalPtr->bbox[0]) != TCL_OK) ! 201: || (TkGetCanvasCoord(canvasPtr, argv[1], ! 202: &rectOvalPtr->bbox[1]) != TCL_OK) ! 203: || (TkGetCanvasCoord(canvasPtr, argv[2], ! 204: &rectOvalPtr->bbox[2]) != TCL_OK) ! 205: || (TkGetCanvasCoord(canvasPtr, argv[3], ! 206: &rectOvalPtr->bbox[3]) != TCL_OK)) { ! 207: return TCL_ERROR; ! 208: } ! 209: ! 210: if (ConfigureRectOval(canvasPtr, itemPtr, argc-4, argv+4, 0) != TCL_OK) { ! 211: DeleteRectOval(itemPtr); ! 212: return TCL_ERROR; ! 213: } ! 214: return TCL_OK; ! 215: } ! 216: ! 217: /* ! 218: *-------------------------------------------------------------- ! 219: * ! 220: * RectOvalCoords -- ! 221: * ! 222: * This procedure is invoked to process the "coords" widget ! 223: * command on rectangles and ovals. See the user documentation ! 224: * for details on what it does. ! 225: * ! 226: * Results: ! 227: * Returns TCL_OK or TCL_ERROR, and sets canvasPtr->interp->result. ! 228: * ! 229: * Side effects: ! 230: * The coordinates for the given item may be changed. ! 231: * ! 232: *-------------------------------------------------------------- ! 233: */ ! 234: ! 235: static int ! 236: RectOvalCoords(canvasPtr, itemPtr, argc, argv) ! 237: register Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 238: Tk_Item *itemPtr; /* Item whose coordinates are to be ! 239: * read or modified. */ ! 240: int argc; /* Number of coordinates supplied in ! 241: * argv. */ ! 242: char **argv; /* Array of coordinates: x1, y1, ! 243: * x2, y2, ... */ ! 244: { ! 245: register RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr; ! 246: char buffer[500]; ! 247: ! 248: if (argc == 0) { ! 249: sprintf(buffer, "%g %g %g %g", rectOvalPtr->bbox[0], ! 250: rectOvalPtr->bbox[1], rectOvalPtr->bbox[2], ! 251: rectOvalPtr->bbox[3]); ! 252: Tcl_SetResult(canvasPtr->interp, buffer, TCL_VOLATILE); ! 253: } else if (argc == 4) { ! 254: if ((TkGetCanvasCoord(canvasPtr, argv[0], ! 255: &rectOvalPtr->bbox[0]) != TCL_OK) ! 256: || (TkGetCanvasCoord(canvasPtr, argv[1], ! 257: &rectOvalPtr->bbox[1]) != TCL_OK) ! 258: || (TkGetCanvasCoord(canvasPtr, argv[2], ! 259: &rectOvalPtr->bbox[2]) != TCL_OK) ! 260: || (TkGetCanvasCoord(canvasPtr, argv[3], ! 261: &rectOvalPtr->bbox[3]) != TCL_OK)) { ! 262: return TCL_ERROR; ! 263: } ! 264: ComputeRectOvalBbox(canvasPtr, rectOvalPtr); ! 265: } else { ! 266: sprintf(canvasPtr->interp->result, ! 267: "wrong # coordinates: expected 0 or 4, got %d", ! 268: argc); ! 269: return TCL_ERROR; ! 270: } ! 271: return TCL_OK; ! 272: } ! 273: ! 274: /* ! 275: *-------------------------------------------------------------- ! 276: * ! 277: * ConfigureRectOval -- ! 278: * ! 279: * This procedure is invoked to configure various aspects ! 280: * of a rectangle or oval item, such as its border and ! 281: * background colors. ! 282: * ! 283: * Results: ! 284: * A standard Tcl result code. If an error occurs, then ! 285: * an error message is left in canvasPtr->interp->result. ! 286: * ! 287: * Side effects: ! 288: * Configuration information, such as colors and stipple ! 289: * patterns, may be set for itemPtr. ! 290: * ! 291: *-------------------------------------------------------------- ! 292: */ ! 293: ! 294: static int ! 295: ConfigureRectOval(canvasPtr, itemPtr, argc, argv, flags) ! 296: Tk_Canvas *canvasPtr; /* Canvas containing itemPtr. */ ! 297: Tk_Item *itemPtr; /* Rectangle item to reconfigure. */ ! 298: int argc; /* Number of elements in argv. */ ! 299: char **argv; /* Arguments describing things to configure. */ ! 300: int flags; /* Flags to pass to Tk_ConfigureWidget. */ ! 301: { ! 302: register RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr; ! 303: XGCValues gcValues; ! 304: GC newGC; ! 305: unsigned long mask; ! 306: ! 307: if (Tk_ConfigureWidget(canvasPtr->interp, canvasPtr->tkwin, ! 308: configSpecs, argc, argv, (char *) rectOvalPtr, flags) != TCL_OK) { ! 309: return TCL_ERROR; ! 310: } ! 311: ! 312: /* ! 313: * A few of the options require additional processing, such as ! 314: * graphics contexts. ! 315: */ ! 316: ! 317: if (rectOvalPtr->outlineColor == NULL) { ! 318: newGC = None; ! 319: } else { ! 320: gcValues.foreground = rectOvalPtr->outlineColor->pixel; ! 321: gcValues.cap_style = CapProjecting; ! 322: if (rectOvalPtr->width < 0) { ! 323: rectOvalPtr->width = 1; ! 324: } ! 325: gcValues.line_width = rectOvalPtr->width; ! 326: mask = GCForeground|GCCapStyle|GCLineWidth; ! 327: newGC = Tk_GetGC(canvasPtr->tkwin, mask, &gcValues); ! 328: } ! 329: if (rectOvalPtr->outlineGC != None) { ! 330: Tk_FreeGC(rectOvalPtr->outlineGC); ! 331: } ! 332: rectOvalPtr->outlineGC = newGC; ! 333: ! 334: if (rectOvalPtr->fillColor == NULL) { ! 335: newGC = None; ! 336: } else { ! 337: gcValues.foreground = rectOvalPtr->fillColor->pixel; ! 338: if (rectOvalPtr->fillStipple != None) { ! 339: gcValues.stipple = rectOvalPtr->fillStipple; ! 340: gcValues.fill_style = FillStippled; ! 341: mask = GCForeground|GCStipple|GCFillStyle; ! 342: } else { ! 343: mask = GCForeground; ! 344: } ! 345: newGC = Tk_GetGC(canvasPtr->tkwin, mask, &gcValues); ! 346: } ! 347: if (rectOvalPtr->fillGC != None) { ! 348: Tk_FreeGC(rectOvalPtr->fillGC); ! 349: } ! 350: rectOvalPtr->fillGC = newGC; ! 351: ComputeRectOvalBbox(canvasPtr, rectOvalPtr); ! 352: ! 353: return TCL_OK; ! 354: } ! 355: ! 356: /* ! 357: *-------------------------------------------------------------- ! 358: * ! 359: * DeleteRectOval -- ! 360: * ! 361: * This procedure is called to clean up the data structure ! 362: * associated with a rectangle or oval item. ! 363: * ! 364: * Results: ! 365: * None. ! 366: * ! 367: * Side effects: ! 368: * Resources associated with itemPtr are released. ! 369: * ! 370: *-------------------------------------------------------------- ! 371: */ ! 372: ! 373: static void ! 374: DeleteRectOval(itemPtr) ! 375: Tk_Item *itemPtr; /* Item that is being deleted. */ ! 376: { ! 377: register RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr; ! 378: ! 379: if (rectOvalPtr->outlineColor != NULL) { ! 380: Tk_FreeColor(rectOvalPtr->outlineColor); ! 381: } ! 382: if (rectOvalPtr->fillColor != NULL) { ! 383: Tk_FreeColor(rectOvalPtr->fillColor); ! 384: } ! 385: if (rectOvalPtr->fillStipple != None) { ! 386: Tk_FreeBitmap(rectOvalPtr->fillStipple); ! 387: } ! 388: if (rectOvalPtr->outlineGC != None) { ! 389: Tk_FreeGC(rectOvalPtr->outlineGC); ! 390: } ! 391: if (rectOvalPtr->fillGC != None) { ! 392: Tk_FreeGC(rectOvalPtr->fillGC); ! 393: } ! 394: } ! 395: ! 396: /* ! 397: *-------------------------------------------------------------- ! 398: * ! 399: * ComputeRectOvalBbox -- ! 400: * ! 401: * This procedure is invoked to compute the bounding box of ! 402: * all the pixels that may be drawn as part of a rectangle ! 403: * or oval. ! 404: * ! 405: * Results: ! 406: * None. ! 407: * ! 408: * Side effects: ! 409: * The fields x1, y1, x2, and y2 are updated in the header ! 410: * for itemPtr. ! 411: * ! 412: *-------------------------------------------------------------- ! 413: */ ! 414: ! 415: /* ARGSUSED */ ! 416: static void ! 417: ComputeRectOvalBbox(canvasPtr, rectOvalPtr) ! 418: Tk_Canvas *canvasPtr; /* Canvas that contains item. */ ! 419: register RectOvalItem *rectOvalPtr; /* Item whose bbox is to be ! 420: * recomputed. */ ! 421: { ! 422: int bloat; ! 423: ! 424: /* ! 425: * Make sure that the first coordinates are the lowest ones. ! 426: */ ! 427: ! 428: if (rectOvalPtr->bbox[1] > rectOvalPtr->bbox[3]) { ! 429: double tmp; ! 430: tmp = rectOvalPtr->bbox[3]; ! 431: rectOvalPtr->bbox[3] = rectOvalPtr->bbox[1]; ! 432: rectOvalPtr->bbox[1] = tmp; ! 433: } ! 434: if (rectOvalPtr->bbox[0] > rectOvalPtr->bbox[2]) { ! 435: double tmp; ! 436: tmp = rectOvalPtr->bbox[2]; ! 437: rectOvalPtr->bbox[2] = rectOvalPtr->bbox[0]; ! 438: rectOvalPtr->bbox[0] = tmp; ! 439: } ! 440: ! 441: bloat = (rectOvalPtr->width+1)/2 + 1; ! 442: rectOvalPtr->header.x1 = rectOvalPtr->bbox[0] - bloat; ! 443: rectOvalPtr->header.y1 = rectOvalPtr->bbox[1] - bloat; ! 444: rectOvalPtr->header.x2 = rectOvalPtr->bbox[2] + bloat; ! 445: rectOvalPtr->header.y2 = rectOvalPtr->bbox[3] + bloat; ! 446: } ! 447: ! 448: /* ! 449: *-------------------------------------------------------------- ! 450: * ! 451: * DisplayRectOval -- ! 452: * ! 453: * This procedure is invoked to draw a rectangle or oval ! 454: * item in a given drawable. ! 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: static void ! 467: DisplayRectOval(canvasPtr, itemPtr, drawable) ! 468: register Tk_Canvas *canvasPtr; /* Canvas that contains item. */ ! 469: Tk_Item *itemPtr; /* Item to be displayed. */ ! 470: Drawable drawable; /* Pixmap or window in which to draw ! 471: * item. */ ! 472: { ! 473: register RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr; ! 474: Display *display = Tk_Display(canvasPtr->tkwin); ! 475: int x1, y1, x2, y2; ! 476: ! 477: /* ! 478: * Compute the screen coordinates of the bounding box for the item. ! 479: * Make sure that the bbox is at least one pixel large, since some ! 480: * X servers will die if it isn't. ! 481: */ ! 482: ! 483: x1 = SCREEN_X(canvasPtr, rectOvalPtr->bbox[0]); ! 484: y1 = SCREEN_Y(canvasPtr, rectOvalPtr->bbox[1]); ! 485: x2 = SCREEN_X(canvasPtr, rectOvalPtr->bbox[2]); ! 486: y2 = SCREEN_Y(canvasPtr, rectOvalPtr->bbox[3]); ! 487: if (x2 <= x1) { ! 488: x2 = x1+1; ! 489: } ! 490: if (y2 <= y1) { ! 491: y2 = y1+1; ! 492: } ! 493: ! 494: /* ! 495: * Display filled box first (if wanted), then outline. ! 496: */ ! 497: ! 498: if (rectOvalPtr->fillGC != None) { ! 499: if (rectOvalPtr->header.typePtr == &TkRectangleType) { ! 500: XFillRectangle(display, drawable, rectOvalPtr->fillGC, ! 501: x1, y1, (unsigned int) (x2-x1), (unsigned int) (y2-y1)); ! 502: } else { ! 503: XFillArc(display, drawable, rectOvalPtr->fillGC, ! 504: x1, y1, (x2-x1), (y2-y1), 0, 360*64); ! 505: } ! 506: } ! 507: if (rectOvalPtr->outlineGC != None) { ! 508: if (rectOvalPtr->header.typePtr == &TkRectangleType) { ! 509: XDrawRectangle(display, drawable, rectOvalPtr->outlineGC, ! 510: x1, y1, (x2-x1-1), (y2-y1-1)); ! 511: } else { ! 512: XDrawArc(display, drawable, rectOvalPtr->outlineGC, ! 513: x1, y1, (x2-x1-1), (y2-y1-1), 0, 360*64); ! 514: } ! 515: } ! 516: } ! 517: ! 518: /* ! 519: *-------------------------------------------------------------- ! 520: * ! 521: * RectToPoint -- ! 522: * ! 523: * Computes the distance from a given point to a given ! 524: * rectangle, in canvas units. ! 525: * ! 526: * Results: ! 527: * The return value is 0 if the point whose x and y coordinates ! 528: * are coordPtr[0] and coordPtr[1] is inside the rectangle. If the ! 529: * point isn't inside the rectangle then the return value is the ! 530: * distance from the point to the rectangle. If itemPtr is filled, ! 531: * then anywhere in the interior is considered "inside"; if ! 532: * itemPtr isn't filled, then "inside" means only the area ! 533: * occupied by the outline. ! 534: * ! 535: * Side effects: ! 536: * None. ! 537: * ! 538: *-------------------------------------------------------------- ! 539: */ ! 540: ! 541: /* ARGSUSED */ ! 542: static double ! 543: RectToPoint(canvasPtr, itemPtr, pointPtr) ! 544: Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 545: Tk_Item *itemPtr; /* Item to check against point. */ ! 546: double *pointPtr; /* Pointer to x and y coordinates. */ ! 547: { ! 548: register RectOvalItem *rectPtr = (RectOvalItem *) itemPtr; ! 549: double xDiff, yDiff, x1, y1, x2, y2, inc, tmp; ! 550: ! 551: /* ! 552: * Generate a new larger rectangle that includes the border ! 553: * width, if there is one. ! 554: */ ! 555: ! 556: x1 = rectPtr->bbox[0]; ! 557: y1 = rectPtr->bbox[1]; ! 558: x2 = rectPtr->bbox[2]; ! 559: y2 = rectPtr->bbox[3]; ! 560: if (rectPtr->outlineGC != None) { ! 561: inc = rectPtr->width/2.0; ! 562: x1 -= inc; ! 563: y1 -= inc; ! 564: x2 += inc; ! 565: y2 += inc; ! 566: } ! 567: ! 568: /* ! 569: * If the point is inside the rectangle, handle specially: ! 570: * distance is 0 if rectangle is filled, otherwise compute ! 571: * distance to nearest edge of rectangle and subtract width ! 572: * of edge. ! 573: */ ! 574: ! 575: if ((pointPtr[0] >= x1) && (pointPtr[0] < x2) ! 576: && (pointPtr[1] >= y1) && (pointPtr[1] < y2)) { ! 577: if ((rectPtr->fillGC != None) || (rectPtr->outlineGC == None)) { ! 578: return 0.0; ! 579: } ! 580: xDiff = pointPtr[0] - x1; ! 581: tmp = x2 - pointPtr[0]; ! 582: if (tmp < xDiff) { ! 583: xDiff = tmp; ! 584: } ! 585: yDiff = pointPtr[1] - y1; ! 586: tmp = y2 - pointPtr[1]; ! 587: if (tmp < yDiff) { ! 588: yDiff = tmp; ! 589: } ! 590: if (yDiff < xDiff) { ! 591: xDiff = yDiff; ! 592: } ! 593: xDiff -= rectPtr->width; ! 594: if (xDiff < 0.0) { ! 595: return 0.0; ! 596: } ! 597: return xDiff; ! 598: } ! 599: ! 600: /* ! 601: * Point is outside rectangle. ! 602: */ ! 603: ! 604: if (pointPtr[0] < x1) { ! 605: xDiff = x1 - pointPtr[0]; ! 606: } else if (pointPtr[0] > x2) { ! 607: xDiff = pointPtr[0] - x2; ! 608: } else { ! 609: xDiff = 0; ! 610: } ! 611: ! 612: if (pointPtr[1] < y1) { ! 613: yDiff = y1 - pointPtr[1]; ! 614: } else if (pointPtr[1] > y2) { ! 615: yDiff = pointPtr[1] - y2; ! 616: } else { ! 617: yDiff = 0; ! 618: } ! 619: ! 620: return hypot(xDiff, yDiff); ! 621: } ! 622: ! 623: /* ! 624: *-------------------------------------------------------------- ! 625: * ! 626: * OvalToPoint -- ! 627: * ! 628: * Computes the distance from a given point to a given ! 629: * oval, in canvas units. ! 630: * ! 631: * Results: ! 632: * The return value is 0 if the point whose x and y coordinates ! 633: * are coordPtr[0] and coordPtr[1] is inside the oval. If the ! 634: * point isn't inside the oval then the return value is the ! 635: * distance from the point to the oval. If itemPtr is filled, ! 636: * then anywhere in the interior is considered "inside"; if ! 637: * itemPtr isn't filled, then "inside" means only the area ! 638: * occupied by the outline. ! 639: * ! 640: * Side effects: ! 641: * None. ! 642: * ! 643: *-------------------------------------------------------------- ! 644: */ ! 645: ! 646: /* ARGSUSED */ ! 647: static double ! 648: OvalToPoint(canvasPtr, itemPtr, pointPtr) ! 649: Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 650: Tk_Item *itemPtr; /* Item to check against point. */ ! 651: double *pointPtr; /* Pointer to x and y coordinates. */ ! 652: { ! 653: register RectOvalItem *ovalPtr = (RectOvalItem *) itemPtr; ! 654: double width; ! 655: int filled; ! 656: ! 657: width = ovalPtr->width; ! 658: filled = ovalPtr->fillGC != None; ! 659: if (ovalPtr->outlineGC == None) { ! 660: width = 0.0; ! 661: filled = 1; ! 662: } ! 663: return TkOvalToPoint(ovalPtr->bbox, width, filled, pointPtr); ! 664: } ! 665: ! 666: /* ! 667: *-------------------------------------------------------------- ! 668: * ! 669: * RectToArea -- ! 670: * ! 671: * This procedure is called to determine whether an item ! 672: * lies entirely inside, entirely outside, or overlapping ! 673: * a given rectangle. ! 674: * ! 675: * Results: ! 676: * -1 is returned if the item is entirely outside the area ! 677: * given by rectPtr, 0 if it overlaps, and 1 if it is entirely ! 678: * inside the given area. ! 679: * ! 680: * Side effects: ! 681: * None. ! 682: * ! 683: *-------------------------------------------------------------- ! 684: */ ! 685: ! 686: /* ARGSUSED */ ! 687: static int ! 688: RectToArea(canvasPtr, itemPtr, areaPtr) ! 689: Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 690: Tk_Item *itemPtr; /* Item to check against rectangle. */ ! 691: double *areaPtr; /* Pointer to array of four coordinates ! 692: * (x1, y1, x2, y2) describing rectangular ! 693: * area. */ ! 694: { ! 695: register RectOvalItem *rectPtr = (RectOvalItem *) itemPtr; ! 696: double halfWidth; ! 697: ! 698: halfWidth = rectPtr->width/2.0; ! 699: if (rectPtr->outlineGC == None) { ! 700: halfWidth = 0.0; ! 701: } ! 702: ! 703: if ((areaPtr[2] <= (rectPtr->bbox[0] - halfWidth)) ! 704: || (areaPtr[0] >= (rectPtr->bbox[2] + halfWidth)) ! 705: || (areaPtr[3] <= (rectPtr->bbox[1] - halfWidth)) ! 706: || (areaPtr[1] >= (rectPtr->bbox[3] + halfWidth))) { ! 707: return -1; ! 708: } ! 709: if ((rectPtr->fillGC == None) && (rectPtr->outlineGC != None) ! 710: && (areaPtr[0] >= (rectPtr->bbox[0] + halfWidth)) ! 711: && (areaPtr[1] >= (rectPtr->bbox[1] + halfWidth)) ! 712: && (areaPtr[2] <= (rectPtr->bbox[2] - halfWidth)) ! 713: && (areaPtr[3] <= (rectPtr->bbox[3] - halfWidth))) { ! 714: return -1; ! 715: } ! 716: if ((areaPtr[0] <= (rectPtr->bbox[0] - halfWidth)) ! 717: && (areaPtr[1] <= (rectPtr->bbox[1] - halfWidth)) ! 718: && (areaPtr[2] >= (rectPtr->bbox[2] + halfWidth)) ! 719: && (areaPtr[3] >= (rectPtr->bbox[3] + halfWidth))) { ! 720: return 1; ! 721: } ! 722: return 0; ! 723: } ! 724: ! 725: /* ! 726: *-------------------------------------------------------------- ! 727: * ! 728: * OvalToArea -- ! 729: * ! 730: * This procedure is called to determine whether an item ! 731: * lies entirely inside, entirely outside, or overlapping ! 732: * a given rectangular area. ! 733: * ! 734: * Results: ! 735: * -1 is returned if the item is entirely outside the area ! 736: * given by rectPtr, 0 if it overlaps, and 1 if it is entirely ! 737: * inside the given area. ! 738: * ! 739: * Side effects: ! 740: * None. ! 741: * ! 742: *-------------------------------------------------------------- ! 743: */ ! 744: ! 745: /* ARGSUSED */ ! 746: static int ! 747: OvalToArea(canvasPtr, itemPtr, areaPtr) ! 748: Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 749: Tk_Item *itemPtr; /* Item to check against oval. */ ! 750: double *areaPtr; /* Pointer to array of four coordinates ! 751: * (x1, y1, x2, y2) describing rectangular ! 752: * area. */ ! 753: { ! 754: register RectOvalItem *ovalPtr = (RectOvalItem *) itemPtr; ! 755: double oval[4], halfWidth; ! 756: int result; ! 757: ! 758: /* ! 759: * Expand the oval to include the width of the outline, if any. ! 760: */ ! 761: ! 762: halfWidth = ovalPtr->width/2.0; ! 763: if (ovalPtr->outlineGC == None) { ! 764: halfWidth = 0.0; ! 765: } ! 766: oval[0] = ovalPtr->bbox[0] - halfWidth; ! 767: oval[1] = ovalPtr->bbox[1] - halfWidth; ! 768: oval[2] = ovalPtr->bbox[2] + halfWidth; ! 769: oval[3] = ovalPtr->bbox[3] + halfWidth; ! 770: ! 771: result = TkOvalToArea(oval, areaPtr); ! 772: ! 773: /* ! 774: * If the rectangle appears to overlap the oval and the oval ! 775: * isn't filled, do one more check to see if perhaps all four ! 776: * of the rectangle's corners are totally inside the oval's ! 777: * unfilled center, in which case we should return "outside". ! 778: */ ! 779: ! 780: if ((result == 0) && (ovalPtr->outlineGC != NULL) ! 781: && (ovalPtr->fillGC == NULL)) { ! 782: double centerX, centerY, width, height; ! 783: double xDelta1, yDelta1, xDelta2, yDelta2; ! 784: ! 785: centerX = (ovalPtr->bbox[0] + ovalPtr->bbox[2])/2.0; ! 786: centerY = (ovalPtr->bbox[1] + ovalPtr->bbox[3])/2.0; ! 787: width = (ovalPtr->bbox[2] - ovalPtr->bbox[0])/2.0 - halfWidth; ! 788: height = (ovalPtr->bbox[3] - ovalPtr->bbox[1])/2.0 - halfWidth; ! 789: xDelta1 = (areaPtr[0] - centerX)/width; ! 790: xDelta1 *= xDelta1; ! 791: yDelta1 = (areaPtr[1] - centerY)/height; ! 792: yDelta1 *= yDelta1; ! 793: xDelta2 = (areaPtr[2] - centerX)/width; ! 794: xDelta2 *= xDelta2; ! 795: yDelta2 = (areaPtr[3] - centerY)/height; ! 796: yDelta2 *= yDelta2; ! 797: if (((xDelta1 + yDelta1) < 1.0) ! 798: && ((xDelta1 + yDelta2) < 1.0) ! 799: && ((xDelta2 + yDelta1) < 1.0) ! 800: && ((xDelta2 + yDelta2) < 1.0)) { ! 801: return -1; ! 802: } ! 803: } ! 804: return result; ! 805: } ! 806: ! 807: /* ! 808: *-------------------------------------------------------------- ! 809: * ! 810: * ScaleRectOval -- ! 811: * ! 812: * This procedure is invoked to rescale a rectangle or oval ! 813: * item. ! 814: * ! 815: * Results: ! 816: * None. ! 817: * ! 818: * Side effects: ! 819: * The rectangle or oval referred to by itemPtr is rescaled ! 820: * so that the following transformation is applied to all ! 821: * point coordinates: ! 822: * x' = originX + scaleX*(x-originX) ! 823: * y' = originY + scaleY*(y-originY) ! 824: * ! 825: *-------------------------------------------------------------- ! 826: */ ! 827: ! 828: static void ! 829: ScaleRectOval(canvasPtr, itemPtr, originX, originY, scaleX, scaleY) ! 830: Tk_Canvas *canvasPtr; /* Canvas containing rectangle. */ ! 831: Tk_Item *itemPtr; /* Rectangle to be scaled. */ ! 832: double originX, originY; /* Origin about which to scale rect. */ ! 833: double scaleX; /* Amount to scale in X direction. */ ! 834: double scaleY; /* Amount to scale in Y direction. */ ! 835: { ! 836: register RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr; ! 837: ! 838: rectOvalPtr->bbox[0] = originX + scaleX*(rectOvalPtr->bbox[0] - originX); ! 839: rectOvalPtr->bbox[1] = originY + scaleY*(rectOvalPtr->bbox[1] - originY); ! 840: rectOvalPtr->bbox[2] = originX + scaleX*(rectOvalPtr->bbox[2] - originX); ! 841: rectOvalPtr->bbox[3] = originY + scaleY*(rectOvalPtr->bbox[3] - originY); ! 842: ComputeRectOvalBbox(canvasPtr, rectOvalPtr); ! 843: } ! 844: ! 845: /* ! 846: *-------------------------------------------------------------- ! 847: * ! 848: * TranslateRectOval -- ! 849: * ! 850: * This procedure is called to move a rectangle or oval by a ! 851: * given amount. ! 852: * ! 853: * Results: ! 854: * None. ! 855: * ! 856: * Side effects: ! 857: * The position of the rectangle or oval is offset by ! 858: * (xDelta, yDelta), and the bounding box is updated in the ! 859: * generic part of the item structure. ! 860: * ! 861: *-------------------------------------------------------------- ! 862: */ ! 863: ! 864: static void ! 865: TranslateRectOval(canvasPtr, itemPtr, deltaX, deltaY) ! 866: Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 867: Tk_Item *itemPtr; /* Item that is being moved. */ ! 868: double deltaX, deltaY; /* Amount by which item is to be ! 869: * moved. */ ! 870: { ! 871: register RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr; ! 872: ! 873: rectOvalPtr->bbox[0] += deltaX; ! 874: rectOvalPtr->bbox[1] += deltaY; ! 875: rectOvalPtr->bbox[2] += deltaX; ! 876: rectOvalPtr->bbox[3] += deltaY; ! 877: ComputeRectOvalBbox(canvasPtr, rectOvalPtr); ! 878: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.