![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tk3d.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 tk3d.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tk3D.c -- ! 3: * ! 4: * This module provides procedures to draw borders in ! 5: * the three-dimensional Motif style. ! 6: * ! 7: * Copyright 1990 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/tk3d.c,v 1.30 92/06/15 14:28:18 ouster Exp $ SPRITE (Berkeley)"; ! 19: #endif ! 20: ! 21: #include "tkconfig.h" ! 22: #include "tk.h" ! 23: ! 24: /* ! 25: * One of the following data structures is allocated for ! 26: * each 3-D border currently in use. Structures of this ! 27: * type are indexed by borderTable, so that a single ! 28: * structure can be shared for several uses. ! 29: */ ! 30: ! 31: typedef struct { ! 32: Display *display; /* Display for which the resources ! 33: * below are allocated. */ ! 34: int refCount; /* Number of different users of ! 35: * this border. */ ! 36: XColor *bgColorPtr; /* Background color (intensity ! 37: * between lightColorPtr and ! 38: * darkColorPtr). */ ! 39: XColor *lightColorPtr; /* Color used for lighter areas of ! 40: * border (must free this when ! 41: * deleting structure). */ ! 42: XColor *darkColorPtr; /* Color for darker areas (must ! 43: * free when deleting structure). */ ! 44: Pixmap shadow; /* Stipple pattern to use for drawing ! 45: * lighter-shadow-ed areas. Only used on ! 46: * monochrome displays; on color displays ! 47: * this is None. */ ! 48: GC lightGC; /* Used to draw lighter parts of ! 49: * the border. */ ! 50: GC darkGC; /* Used to draw darker parts of the ! 51: * border. */ ! 52: GC bgGC; /* Used (if necessary) to draw areas in ! 53: * the background color. */ ! 54: Tcl_HashEntry *hashPtr; /* Entry in borderTable (needed in ! 55: * order to delete structure). */ ! 56: } Border; ! 57: ! 58: /* ! 59: * Hash table to map from a border's values (color, etc.) to a ! 60: * Border structure for those values. ! 61: */ ! 62: ! 63: static Tcl_HashTable borderTable; ! 64: typedef struct { ! 65: Tk_Uid colorName; /* Color for border. */ ! 66: Colormap colormap; /* Colormap used for allocating border ! 67: * colors. */ ! 68: Screen *screen; /* Screen on which border will be drawn. */ ! 69: } BorderKey; ! 70: ! 71: /* ! 72: * Maximum intensity for a color: ! 73: */ ! 74: ! 75: #define MAX_INTENSITY 65535 ! 76: ! 77: ! 78: static int initialized = 0; /* 0 means static structures haven't ! 79: * been initialized yet. */ ! 80: ! 81: /* ! 82: * Forward declarations for procedures defined in this file: ! 83: */ ! 84: ! 85: static void BorderInit _ANSI_ARGS_((void)); ! 86: static int Intersect _ANSI_ARGS_((XPoint *a1Ptr, XPoint *a2Ptr, ! 87: XPoint *b1Ptr, XPoint *b2Ptr, XPoint *iPtr)); ! 88: static void ShiftLine _ANSI_ARGS_((XPoint *p1Ptr, XPoint *p2Ptr, ! 89: int distance, XPoint *p3Ptr)); ! 90: ! 91: /* ! 92: *-------------------------------------------------------------- ! 93: * ! 94: * Tk_Get3DBorder -- ! 95: * ! 96: * Create a data structure for displaying a 3-D border. ! 97: * ! 98: * Results: ! 99: * The return value is a token for a data structure ! 100: * describing a 3-D border. This token may be passed ! 101: * to Tk_Draw3DRectangle and Tk_Free3DBorder. If an ! 102: * error prevented the border from being created then ! 103: * NULL is returned and an error message will be left ! 104: * in interp->result. ! 105: * ! 106: * Side effects: ! 107: * Data structures, graphics contexts, etc. are allocated. ! 108: * It is the caller's responsibility to eventually call ! 109: * Tk_Free3DBorder to release the resources. ! 110: * ! 111: *-------------------------------------------------------------- ! 112: */ ! 113: ! 114: Tk_3DBorder ! 115: Tk_Get3DBorder(interp, tkwin, colormap, colorName) ! 116: Tcl_Interp *interp; /* Place to store an error message. */ ! 117: Tk_Window tkwin; /* Token for window in which ! 118: * border will be drawn. */ ! 119: Colormap colormap; /* Colormap to use for allocating border ! 120: * colors. None means use default colormap ! 121: * for screen. */ ! 122: Tk_Uid colorName; /* String giving name of color ! 123: * for window background. */ ! 124: { ! 125: BorderKey key; ! 126: Tcl_HashEntry *hashPtr; ! 127: register Border *borderPtr; ! 128: int new; ! 129: unsigned long light, dark; ! 130: XGCValues gcValues; ! 131: unsigned long mask; ! 132: ! 133: if (!initialized) { ! 134: BorderInit(); ! 135: } ! 136: ! 137: /* ! 138: * First, check to see if there's already a border that will work ! 139: * for this request. ! 140: */ ! 141: ! 142: key.colorName = colorName; ! 143: if (colormap == None) { ! 144: colormap = Tk_DefaultColormap(Tk_Screen(tkwin)); ! 145: } ! 146: key.colormap = colormap; ! 147: key.screen = Tk_Screen(tkwin); ! 148: ! 149: hashPtr = Tcl_CreateHashEntry(&borderTable, (char *) &key, &new); ! 150: if (!new) { ! 151: borderPtr = (Border *) Tcl_GetHashValue(hashPtr); ! 152: borderPtr->refCount++; ! 153: } else { ! 154: ! 155: /* ! 156: * No satisfactory border exists yet. Initialize a new one. ! 157: */ ! 158: ! 159: borderPtr = (Border *) ckalloc(sizeof(Border)); ! 160: borderPtr->display = Tk_Display(tkwin); ! 161: borderPtr->refCount = 1; ! 162: borderPtr->bgColorPtr = NULL; ! 163: borderPtr->lightColorPtr = NULL; ! 164: borderPtr->darkColorPtr = NULL; ! 165: borderPtr->shadow = None; ! 166: borderPtr->lightGC = None; ! 167: borderPtr->darkGC = None; ! 168: borderPtr->bgGC = None; ! 169: borderPtr->hashPtr = hashPtr; ! 170: Tcl_SetHashValue(hashPtr, borderPtr); ! 171: ! 172: /* ! 173: * Figure out what colors and GC's to use for the light ! 174: * and dark areas and set up the graphics contexts. ! 175: * Monochrome displays get handled differently than ! 176: * color displays. ! 177: */ ! 178: ! 179: borderPtr->bgColorPtr = Tk_GetColor(interp, tkwin, ! 180: key.colormap, colorName); ! 181: if (borderPtr->bgColorPtr == NULL) { ! 182: goto error; ! 183: } ! 184: if (Tk_DefaultDepth(Tk_Screen(tkwin)) == 1) { ! 185: /* ! 186: * Monochrome display. ! 187: */ ! 188: ! 189: light = borderPtr->bgColorPtr->pixel; ! 190: if (light == WhitePixelOfScreen(Tk_Screen(tkwin))) { ! 191: dark = BlackPixelOfScreen(Tk_Screen(tkwin)); ! 192: } else { ! 193: dark = WhitePixelOfScreen(Tk_Screen(tkwin)); ! 194: } ! 195: borderPtr->shadow = Tk_GetBitmap(interp, tkwin, ! 196: Tk_GetUid("gray50")); ! 197: if (borderPtr->shadow == None) { ! 198: goto error; ! 199: } ! 200: } else { ! 201: XColor lightColor, darkColor; ! 202: int tmp; ! 203: ! 204: /* ! 205: * Color display. Compute the colors for the illuminated ! 206: * and shaded portions of the border. ! 207: */ ! 208: ! 209: tmp = (14*(int)borderPtr->bgColorPtr->red)/10; ! 210: if (tmp > MAX_INTENSITY) { ! 211: tmp = MAX_INTENSITY; ! 212: } ! 213: lightColor.red = tmp; ! 214: tmp = (14*(int)borderPtr->bgColorPtr->green)/10; ! 215: if (tmp > MAX_INTENSITY) { ! 216: tmp = MAX_INTENSITY; ! 217: } ! 218: lightColor.green = tmp; ! 219: tmp = (14*(int)borderPtr->bgColorPtr->blue)/10; ! 220: if (tmp > MAX_INTENSITY) { ! 221: tmp = MAX_INTENSITY; ! 222: } ! 223: lightColor.blue = tmp; ! 224: darkColor.red = (60*(int)borderPtr->bgColorPtr->red)/100; ! 225: darkColor.green = (60*(int)borderPtr->bgColorPtr->green)/100; ! 226: darkColor.blue = (60*(int)borderPtr->bgColorPtr->blue)/100; ! 227: borderPtr->lightColorPtr = Tk_GetColorByValue(interp, tkwin, ! 228: key.colormap, &lightColor); ! 229: if (borderPtr->lightColorPtr == NULL) { ! 230: goto error; ! 231: } ! 232: borderPtr->darkColorPtr = Tk_GetColorByValue(interp, tkwin, ! 233: key.colormap, &darkColor); ! 234: if (borderPtr->darkColorPtr == NULL) { ! 235: goto error; ! 236: } ! 237: light = borderPtr->lightColorPtr->pixel; ! 238: dark = borderPtr->darkColorPtr->pixel; ! 239: } ! 240: gcValues.foreground = light; ! 241: gcValues.background = dark; ! 242: mask = GCForeground|GCBackground; ! 243: if (borderPtr->shadow != None) { ! 244: gcValues.stipple = borderPtr->shadow; ! 245: gcValues.fill_style = FillOpaqueStippled; ! 246: mask |= GCStipple|GCFillStyle; ! 247: } ! 248: borderPtr->lightGC = Tk_GetGC(tkwin, mask, &gcValues); ! 249: gcValues.foreground = dark; ! 250: gcValues.background = light; ! 251: borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground|GCBackground, ! 252: &gcValues); ! 253: gcValues.foreground = borderPtr->bgColorPtr->pixel; ! 254: borderPtr->bgGC = Tk_GetGC(tkwin, GCForeground, &gcValues); ! 255: } ! 256: return (Tk_3DBorder) borderPtr; ! 257: ! 258: error: ! 259: Tk_Free3DBorder((Tk_3DBorder) borderPtr); ! 260: return NULL; ! 261: } ! 262: ! 263: /* ! 264: *-------------------------------------------------------------- ! 265: * ! 266: * Tk_Draw3DRectangle -- ! 267: * ! 268: * Draw a 3-D border at a given place in a given window. ! 269: * ! 270: * Results: ! 271: * None. ! 272: * ! 273: * Side effects: ! 274: * A 3-D border will be drawn in the indicated drawable. ! 275: * The outside edges of the border will be determined by x, ! 276: * y, width, and height. The inside edges of the border ! 277: * will be determined by the borderWidth argument. ! 278: * ! 279: *-------------------------------------------------------------- ! 280: */ ! 281: ! 282: void ! 283: Tk_Draw3DRectangle(display, drawable, border, x, y, width, height, ! 284: borderWidth, relief) ! 285: Display *display; /* X display in which to draw. */ ! 286: Drawable drawable; /* X window or pixmap in which to draw. */ ! 287: Tk_3DBorder border; /* Token for border to draw. */ ! 288: int x, y, width, height; /* Outside area of region in ! 289: * which border will be drawn. */ ! 290: int borderWidth; /* Desired width for border, in ! 291: * pixels. */ ! 292: int relief; /* Should be either TK_RELIEF_RAISED ! 293: * or TK_RELIEF_SUNKEN; indicates ! 294: * position of interior of window relative ! 295: * to exterior. */ ! 296: { ! 297: register Border *borderPtr = (Border *) border; ! 298: GC top, bottom; ! 299: XPoint points[7]; ! 300: ! 301: if ((width < 2*borderWidth) || (height < 2*borderWidth)) { ! 302: return; ! 303: } ! 304: ! 305: if (relief == TK_RELIEF_RAISED) { ! 306: top = borderPtr->lightGC; ! 307: bottom = borderPtr->darkGC; ! 308: } else if (relief == TK_RELIEF_SUNKEN) { ! 309: top = borderPtr->darkGC; ! 310: bottom = borderPtr->lightGC; ! 311: } else { ! 312: top = bottom = borderPtr->bgGC; ! 313: } ! 314: XFillRectangle(display, drawable, bottom, x, y+height-borderWidth, ! 315: ! 316: (unsigned int) width, (unsigned int) borderWidth); ! 317: XFillRectangle(display, drawable, bottom, x+width-borderWidth, y, ! 318: (unsigned int) borderWidth, (unsigned int) height); ! 319: points[0].x = points[1].x = points[6].x = x; ! 320: points[0].y = points[6].y = y + height; ! 321: points[1].y = points[2].y = y; ! 322: points[2].x = x + width; ! 323: points[3].x = x + width - borderWidth; ! 324: points[3].y = points[4].y = y + borderWidth; ! 325: points[4].x = points[5].x = x + borderWidth; ! 326: points[5].y = y + height - borderWidth; ! 327: XFillPolygon(display, drawable, top, points, 7, Nonconvex, ! 328: CoordModeOrigin); ! 329: } ! 330: ! 331: /* ! 332: *-------------------------------------------------------------- ! 333: * ! 334: * Tk_NameOf3DBorder -- ! 335: * ! 336: * Given a border, return a textual string identifying the ! 337: * border's color. ! 338: * ! 339: * Results: ! 340: * The return value is the string that was used to create ! 341: * the border. ! 342: * ! 343: * Side effects: ! 344: * None. ! 345: * ! 346: *-------------------------------------------------------------- ! 347: */ ! 348: ! 349: char * ! 350: Tk_NameOf3DBorder(border) ! 351: Tk_3DBorder border; /* Token for border. */ ! 352: { ! 353: Border *borderPtr = (Border *) border; ! 354: ! 355: return ((BorderKey *) borderPtr->hashPtr->key.words)->colorName; ! 356: } ! 357: ! 358: /* ! 359: *-------------------------------------------------------------------- ! 360: * ! 361: * Tk_3DBorderColor -- ! 362: * ! 363: * Given a 3D border, return the X color used for the "flat" ! 364: * surfaces. ! 365: * ! 366: * Results: ! 367: * Returns the color used drawing flat surfaces with the border. ! 368: * ! 369: * Side effects: ! 370: * None. ! 371: * ! 372: *-------------------------------------------------------------------- ! 373: */ ! 374: XColor * ! 375: Tk_3DBorderColor(border) ! 376: Tk_3DBorder border; ! 377: { ! 378: return(((Border *) border)->bgColorPtr); ! 379: } ! 380: ! 381: /* ! 382: *-------------------------------------------------------------- ! 383: * ! 384: * Tk_Free3DBorder -- ! 385: * ! 386: * This procedure is called when a 3D border is no longer ! 387: * needed. It frees the resources associated with the ! 388: * border. After this call, the caller should never again ! 389: * use the "border" token. ! 390: * ! 391: * Results: ! 392: * None. ! 393: * ! 394: * Side effects: ! 395: * Resources are freed. ! 396: * ! 397: *-------------------------------------------------------------- ! 398: */ ! 399: ! 400: void ! 401: Tk_Free3DBorder(border) ! 402: Tk_3DBorder border; /* Token for border to be released. */ ! 403: { ! 404: register Border *borderPtr = (Border *) border; ! 405: ! 406: borderPtr->refCount--; ! 407: if (borderPtr->refCount == 0) { ! 408: if (borderPtr->bgColorPtr != NULL) { ! 409: Tk_FreeColor(borderPtr->bgColorPtr); ! 410: } ! 411: if (borderPtr->lightColorPtr != NULL) { ! 412: Tk_FreeColor(borderPtr->lightColorPtr); ! 413: } ! 414: if (borderPtr->darkColorPtr != NULL) { ! 415: Tk_FreeColor(borderPtr->darkColorPtr); ! 416: } ! 417: if (borderPtr->shadow != None) { ! 418: Tk_FreeBitmap(borderPtr->shadow); ! 419: } ! 420: if (borderPtr->lightGC != None) { ! 421: Tk_FreeGC(borderPtr->lightGC); ! 422: } ! 423: if (borderPtr->darkGC != None) { ! 424: Tk_FreeGC(borderPtr->darkGC); ! 425: } ! 426: if (borderPtr->bgGC != None) { ! 427: Tk_FreeGC(borderPtr->bgGC); ! 428: } ! 429: Tcl_DeleteHashEntry(borderPtr->hashPtr); ! 430: ckfree((char *) borderPtr); ! 431: } ! 432: } ! 433: ! 434: /* ! 435: *---------------------------------------------------------------------- ! 436: * ! 437: * Tk_SetBackgroundFromBorder -- ! 438: * ! 439: * Change the background of a window to one appropriate for a given ! 440: * 3-D border. ! 441: * ! 442: * Results: ! 443: * None. ! 444: * ! 445: * Side effects: ! 446: * Tkwin's background gets modified. ! 447: * ! 448: *---------------------------------------------------------------------- ! 449: */ ! 450: ! 451: void ! 452: Tk_SetBackgroundFromBorder(tkwin, border) ! 453: Tk_Window tkwin; /* Window whose background is to be set. */ ! 454: Tk_3DBorder border; /* Token for border. */ ! 455: { ! 456: register Border *borderPtr = (Border *) border; ! 457: ! 458: Tk_SetWindowBackground(tkwin, borderPtr->bgColorPtr->pixel); ! 459: } ! 460: ! 461: /* ! 462: *---------------------------------------------------------------------- ! 463: * ! 464: * Tk_GetRelief -- ! 465: * ! 466: * Parse a relief description and return the corresponding ! 467: * relief value, or an error. ! 468: * ! 469: * Results: ! 470: * A standard Tcl return value. If all goes well then ! 471: * *reliefPtr is filled in with one of the values ! 472: * TK_RELIEF_RAISED, TK_RELIEF_FLAT, or TK_RELIEF_SUNKEN. ! 473: * ! 474: * Side effects: ! 475: * None. ! 476: * ! 477: *---------------------------------------------------------------------- ! 478: */ ! 479: ! 480: int ! 481: Tk_GetRelief(interp, name, reliefPtr) ! 482: Tcl_Interp *interp; /* For error messages. */ ! 483: char *name; /* Name of a relief type. */ ! 484: int *reliefPtr; /* Where to store converted relief. */ ! 485: { ! 486: char c; ! 487: int length; ! 488: ! 489: c = name[0]; ! 490: length = strlen(name); ! 491: if ((c == 'f') && (strncmp(name, "flat", length) == 0)) { ! 492: *reliefPtr = TK_RELIEF_FLAT; ! 493: } else if ((c == 'r') && (strncmp(name, "raised", length) == 0)) { ! 494: *reliefPtr = TK_RELIEF_RAISED; ! 495: } else if ((c == 's') && (strncmp(name, "sunken", length) == 0)) { ! 496: *reliefPtr = TK_RELIEF_SUNKEN; ! 497: } else { ! 498: sprintf(interp->result, "bad relief type \"%.50s\": must be %s", ! 499: name, "flat, raised, or sunken"); ! 500: return TCL_ERROR; ! 501: } ! 502: return TCL_OK; ! 503: } ! 504: ! 505: /* ! 506: *-------------------------------------------------------------- ! 507: * ! 508: * Tk_NameOfRelief -- ! 509: * ! 510: * Given a relief value, produce a string describing that ! 511: * relief value. ! 512: * ! 513: * Results: ! 514: * The return value is a static string that is equivalent ! 515: * to relief. ! 516: * ! 517: * Side effects: ! 518: * None. ! 519: * ! 520: *-------------------------------------------------------------- ! 521: */ ! 522: ! 523: char * ! 524: Tk_NameOfRelief(relief) ! 525: int relief; /* One of TK_RELIEF_FLAT, TK_RELIEF_RAISED, ! 526: * or TK_RELIEF_SUNKEN. */ ! 527: { ! 528: if (relief == TK_RELIEF_FLAT) { ! 529: return "flat"; ! 530: } else if (relief == TK_RELIEF_SUNKEN) { ! 531: return "sunken"; ! 532: } else if (relief == TK_RELIEF_RAISED) { ! 533: return "raised"; ! 534: } else { ! 535: return "unknown relief"; ! 536: } ! 537: } ! 538: ! 539: /* ! 540: *-------------------------------------------------------------- ! 541: * ! 542: * Tk_Draw3DPolygon -- ! 543: * ! 544: * Draw a border with 3-D appearance around the edge of a ! 545: * given polygon. ! 546: * ! 547: * Results: ! 548: * None. ! 549: * ! 550: * Side effects: ! 551: * Information is drawn in "drawable" in the form of a ! 552: * 3-D border borderWidth units width wide on the left ! 553: * of the trajectory given by pointPtr and numPoints (or ! 554: * -borderWidth units wide on the right side, if borderWidth ! 555: * is negative. ! 556: * ! 557: *-------------------------------------------------------------- ! 558: */ ! 559: ! 560: void ! 561: Tk_Draw3DPolygon(display, drawable, border, pointPtr, numPoints, ! 562: borderWidth, leftRelief) ! 563: Display *display; /* X display in which to draw polygon. */ ! 564: Drawable drawable; /* X window or pixmap in which to draw. */ ! 565: Tk_3DBorder border; /* Token for border to draw. */ ! 566: XPoint *pointPtr; /* Array of points describing ! 567: * polygon. All points must be ! 568: * absolute (CoordModeOrigin). */ ! 569: int numPoints; /* Number of points at *pointPtr. */ ! 570: int borderWidth; /* Width of border, measured in ! 571: * pixels to the left of the polygon's ! 572: * trajectory. May be negative. */ ! 573: int leftRelief; /* TK_RELIEF_RAISED or ! 574: * TK_RELIEF_SUNKEN: indicates how ! 575: * stuff to left of trajectory looks ! 576: * relative to stuff on right. */ ! 577: { ! 578: XPoint poly[4], b1, b2, newB1, newB2; ! 579: XPoint perp, c, shift1, shift2; /* Used for handling parallel lines. */ ! 580: register XPoint *p1Ptr, *p2Ptr; ! 581: Border *borderPtr = (Border *) border; ! 582: GC gc; ! 583: int i, lightOnLeft, dx, dy, parallel, pointsSeen; ! 584: ! 585: /* ! 586: * If the polygon is already closed, drop the last point from it ! 587: * (we'll close it automatically). ! 588: */ ! 589: ! 590: p1Ptr = &pointPtr[numPoints-1]; ! 591: p2Ptr = &pointPtr[0]; ! 592: if ((p1Ptr->x == p2Ptr->x) && (p1Ptr->y == p2Ptr->y)) { ! 593: numPoints--; ! 594: } ! 595: ! 596: /* ! 597: * The loop below is executed once for each vertex in the polgon. ! 598: * At the beginning of each iteration things look like this: ! 599: * ! 600: * poly[1] / ! 601: * * / ! 602: * | / ! 603: * b1 * poly[0] (pointPtr[i-1]) ! 604: * | | ! 605: * | | ! 606: * | | ! 607: * | | ! 608: * | | ! 609: * | | *p1Ptr *p2Ptr ! 610: * b2 *--------------------* ! 611: * | ! 612: * | ! 613: * x------------------------- ! 614: * ! 615: * The job of this iteration is to do the following: ! 616: * (a) Compute x (the border corner corresponding to ! 617: * pointPtr[i]) and put it in poly[2]. As part of ! 618: * this, compute a new b1 and b2 value for the next ! 619: * side of the polygon. ! 620: * (b) Put pointPtr[i] into poly[3]. ! 621: * (c) Draw the polygon given by poly[0..3]. ! 622: * (d) Advance poly[0], poly[1], b1, and b2 for the ! 623: * next side of the polygon. ! 624: */ ! 625: ! 626: /* ! 627: * The above situation doesn't first come into existence until ! 628: * two points have been processed; the first two points are ! 629: * used to "prime the pump", so some parts of the processing ! 630: * are ommitted for these points. The variable "pointsSeen" ! 631: * keeps track of the priming process; it has to be separate ! 632: * from i in order to be able to ignore duplicate points in the ! 633: * polygon. ! 634: */ ! 635: ! 636: pointsSeen = 0; ! 637: for (i = -2, p1Ptr = &pointPtr[numPoints-2], p2Ptr = p1Ptr+1; ! 638: i < numPoints; i++, p1Ptr = p2Ptr, p2Ptr++) { ! 639: if ((i == -1) || (i == numPoints-1)) { ! 640: p2Ptr = pointPtr; ! 641: } ! 642: if ((p2Ptr->x == p1Ptr->x) && (p2Ptr->y == p1Ptr->y)) { ! 643: /* ! 644: * Ignore duplicate points (they'd cause core dumps in ! 645: * ShiftLine calls below). ! 646: */ ! 647: continue; ! 648: } ! 649: ShiftLine(p1Ptr, p2Ptr, borderWidth, &newB1); ! 650: newB2.x = newB1.x + (p2Ptr->x - p1Ptr->x); ! 651: newB2.y = newB1.y + (p2Ptr->y - p1Ptr->y); ! 652: poly[3] = *p1Ptr; ! 653: parallel = 0; ! 654: if (pointsSeen >= 1) { ! 655: parallel = Intersect(&newB1, &newB2, &b1, &b2, &poly[2]); ! 656: ! 657: /* ! 658: * If two consecutive segments of the polygon are parallel, ! 659: * then things get more complex. Consider the following ! 660: * diagram: ! 661: * ! 662: * poly[1] ! 663: * *----b1-----------b2------a ! 664: * \ ! 665: * \ ! 666: * *---------*----------* b ! 667: * poly[0] *p2Ptr *p1Ptr / ! 668: * / ! 669: * --*--------*----c ! 670: * newB1 newB2 ! 671: * ! 672: * Instead of using x and *p1Ptr for poly[2] and poly[3], as ! 673: * in the original diagram, use a and b as above. Then instead ! 674: * of using x and *p1Ptr for the new poly[0] and poly[1], use ! 675: * b and c as above. ! 676: * ! 677: * Do the computation in three stages: ! 678: * 1. Compute a point "perp" such that the line p1Ptr-perp ! 679: * is perpendicular to p1Ptr-p2Ptr. ! 680: * 2. Compute the points a and c by intersecting the lines ! 681: * b1-b2 and newB1-newB2 with p1Ptr-perp. ! 682: * 3. Compute b by shifting p1Ptr-perp to the right and ! 683: * intersecting it with p1Ptr-p2Ptr. ! 684: */ ! 685: ! 686: if (parallel) { ! 687: perp.x = p1Ptr->x + (p2Ptr->y - p1Ptr->y); ! 688: perp.y = p1Ptr->y - (p2Ptr->x - p1Ptr->x); ! 689: (void) Intersect(p1Ptr, &perp, &b1, &b2, &poly[2]); ! 690: (void) Intersect(p1Ptr, &perp, &newB1, &newB2, &c); ! 691: ShiftLine(p1Ptr, &perp, borderWidth, &shift1); ! 692: shift2.x = shift1.x + (perp.x - p1Ptr->x); ! 693: shift2.y = shift1.y + (perp.y - p1Ptr->y); ! 694: (void) Intersect(p1Ptr, p2Ptr, &shift1, &shift2, &poly[3]); ! 695: } ! 696: } ! 697: if (pointsSeen >= 2) { ! 698: dx = poly[3].x - poly[0].x; ! 699: dy = poly[3].y - poly[0].y; ! 700: if (dx > 0) { ! 701: lightOnLeft = (dy <= dx); ! 702: } else { ! 703: lightOnLeft = (dy < dx); ! 704: } ! 705: if (lightOnLeft ^ (leftRelief == TK_RELIEF_RAISED)) { ! 706: gc = borderPtr->lightGC; ! 707: } else { ! 708: gc = borderPtr->darkGC; ! 709: } ! 710: XFillPolygon(display, drawable, gc, poly, 4, Convex, ! 711: CoordModeOrigin); ! 712: } ! 713: b1.x = newB1.x; ! 714: b1.y = newB1.y; ! 715: b2.x = newB2.x; ! 716: b2.y = newB2.y; ! 717: poly[0].x = poly[3].x; ! 718: poly[0].y = poly[3].y; ! 719: if (parallel) { ! 720: poly[1].x = c.x; ! 721: poly[1].y = c.y; ! 722: } else if (pointsSeen >= 1) { ! 723: poly[1].x = poly[2].x; ! 724: poly[1].y = poly[2].y; ! 725: } ! 726: pointsSeen++; ! 727: } ! 728: } ! 729: ! 730: /* ! 731: *---------------------------------------------------------------------- ! 732: * ! 733: * Tk_Fill3DRectangle -- ! 734: * ! 735: * Fill a rectangular area, supplying a 3D border if desired. ! 736: * ! 737: * Results: ! 738: * None. ! 739: * ! 740: * Side effects: ! 741: * Information gets drawn on the screen. ! 742: * ! 743: *---------------------------------------------------------------------- ! 744: */ ! 745: ! 746: void ! 747: Tk_Fill3DRectangle(display, drawable, border, x, y, width, ! 748: height, borderWidth, relief) ! 749: Display *display; /* X display in which to draw rectangle. */ ! 750: Drawable drawable; /* X window or pixmap in which to draw. */ ! 751: Tk_3DBorder border; /* Token for border to draw. */ ! 752: int x, y, width, height; /* Outside area of rectangular region. */ ! 753: int borderWidth; /* Desired width for border, in ! 754: * pixels. Border will be *inside* region. */ ! 755: int relief; /* Indicates 3D effect: TK_RELIEF_FLAT, ! 756: * TK_RELIEF_RAISED, or TK_RELIEF_SUNKEN. */ ! 757: { ! 758: register Border *borderPtr = (Border *) border; ! 759: ! 760: XFillRectangle(display, drawable, borderPtr->bgGC, ! 761: x, y, (unsigned int) width, (unsigned int) height); ! 762: if (relief != TK_RELIEF_FLAT) { ! 763: Tk_Draw3DRectangle(display, drawable, border, x, y, width, ! 764: height, borderWidth, relief); ! 765: } ! 766: } ! 767: ! 768: /* ! 769: *---------------------------------------------------------------------- ! 770: * ! 771: * Tk_Fill3DPolygon -- ! 772: * ! 773: * Fill a polygonal area, supplying a 3D border if desired. ! 774: * ! 775: * Results: ! 776: * None. ! 777: * ! 778: * Side effects: ! 779: * Information gets drawn on the screen. ! 780: * ! 781: *---------------------------------------------------------------------- ! 782: */ ! 783: ! 784: void ! 785: Tk_Fill3DPolygon(display, drawable, border, pointPtr, numPoints, ! 786: borderWidth, leftRelief) ! 787: Display *display; /* X display in which to draw polygon. */ ! 788: Drawable drawable; /* X window or pixmap in which to draw. */ ! 789: Tk_3DBorder border; /* Token for border to draw. */ ! 790: XPoint *pointPtr; /* Array of points describing ! 791: * polygon. All points must be ! 792: * absolute (CoordModeOrigin). */ ! 793: int numPoints; /* Number of points at *pointPtr. */ ! 794: int borderWidth; /* Width of border, measured in ! 795: * pixels to the left of the polygon's ! 796: * trajectory. May be negative. */ ! 797: int leftRelief; /* Indicates 3D effect of left side of ! 798: * trajectory relative to right: ! 799: * TK_RELIEF_FLAT, TK_RELIEF_RAISED, ! 800: * or TK_RELIEF_SUNKEN. */ ! 801: { ! 802: register Border *borderPtr = (Border *) border; ! 803: ! 804: XFillPolygon(display, drawable, borderPtr->bgGC, ! 805: pointPtr, numPoints, Complex, CoordModeOrigin); ! 806: if (leftRelief != TK_RELIEF_FLAT) { ! 807: Tk_Draw3DPolygon(display, drawable, border, pointPtr, numPoints, ! 808: borderWidth, leftRelief); ! 809: } ! 810: } ! 811: ! 812: /* ! 813: *-------------------------------------------------------------- ! 814: * ! 815: * BorderInit -- ! 816: * ! 817: * Initialize the structures used for border management. ! 818: * ! 819: * Results: ! 820: * None. ! 821: * ! 822: * Side effects: ! 823: * Read the code. ! 824: * ! 825: *------------------------------------------------------------- ! 826: */ ! 827: ! 828: static void ! 829: BorderInit() ! 830: { ! 831: initialized = 1; ! 832: Tcl_InitHashTable(&borderTable, sizeof(BorderKey)/sizeof(int)); ! 833: } ! 834: ! 835: /* ! 836: *-------------------------------------------------------------- ! 837: * ! 838: * ShiftLine -- ! 839: * ! 840: * Given two points on a line, compute a point on a ! 841: * new line that is parallel to the given line and ! 842: * a given distance away from it. ! 843: * ! 844: * Results: ! 845: * None. ! 846: * ! 847: * Side effects: ! 848: * None. ! 849: * ! 850: *-------------------------------------------------------------- ! 851: */ ! 852: ! 853: static void ! 854: ShiftLine(p1Ptr, p2Ptr, distance, p3Ptr) ! 855: XPoint *p1Ptr; /* First point on line. */ ! 856: XPoint *p2Ptr; /* Second point on line. */ ! 857: int distance; /* New line is to be this many ! 858: * units to the left of original ! 859: * line, when looking from p1 to ! 860: * p2. May be negative. */ ! 861: XPoint *p3Ptr; /* Store coords of point on new ! 862: * line here. */ ! 863: { ! 864: int dx, dy, dxNeg, dyNeg; ! 865: ! 866: /* ! 867: * The table below is used for a quick approximation in ! 868: * computing the new point. An index into the table ! 869: * is 128 times the slope of the original line (the slope ! 870: * must always be between 0 and 1). The value of the table ! 871: * entry is 128 times the amount to displace the new line ! 872: * in y for each unit of perpendicular distance. In other ! 873: * words, the table maps from the tangent of an angle to ! 874: * the inverse of its cosine. If the slope of the original ! 875: * line is greater than 1, then the displacement is done in ! 876: * x rather than in y. ! 877: */ ! 878: ! 879: static int shiftTable[129]; ! 880: ! 881: /* ! 882: * Initialize the table if this is the first time it is ! 883: * used. ! 884: */ ! 885: ! 886: if (shiftTable[0] == 0) { ! 887: int i; ! 888: double tangent, cosine; ! 889: ! 890: for (i = 0; i <= 128; i++) { ! 891: tangent = i/128.0; ! 892: cosine = 128/cos(atan(tangent)) + .5; ! 893: shiftTable[i] = cosine; ! 894: } ! 895: } ! 896: ! 897: *p3Ptr = *p1Ptr; ! 898: dx = p2Ptr->x - p1Ptr->x; ! 899: dy = p2Ptr->y - p1Ptr->y; ! 900: if (dy < 0) { ! 901: dyNeg = 1; ! 902: dy = -dy; ! 903: } else { ! 904: dyNeg = 0; ! 905: } ! 906: if (dx < 0) { ! 907: dxNeg = 1; ! 908: dx = -dx; ! 909: } else { ! 910: dxNeg = 0; ! 911: } ! 912: if (dy <= dx) { ! 913: dy = ((distance * shiftTable[(dy<<7)/dx]) + 64) >> 7; ! 914: if (!dxNeg) { ! 915: dy = -dy; ! 916: } ! 917: p3Ptr->y += dy; ! 918: } else { ! 919: dx = ((distance * shiftTable[(dx<<7)/dy]) + 64) >> 7; ! 920: if (dyNeg) { ! 921: dx = -dx; ! 922: } ! 923: p3Ptr->x += dx; ! 924: } ! 925: } ! 926: ! 927: /* ! 928: *-------------------------------------------------------------- ! 929: * ! 930: * Intersect -- ! 931: * ! 932: * Find the intersection point between two lines. ! 933: * ! 934: * Results: ! 935: * Under normal conditions 0 is returned and the point ! 936: * at *iPtr is filled in with the intersection between ! 937: * the two lines. If the two lines are parallel, then ! 938: * -1 is returned and *iPtr isn't modified. ! 939: * ! 940: * Side effects: ! 941: * None. ! 942: * ! 943: *-------------------------------------------------------------- ! 944: */ ! 945: ! 946: static int ! 947: Intersect(a1Ptr, a2Ptr, b1Ptr, b2Ptr, iPtr) ! 948: XPoint *a1Ptr; /* First point of first line. */ ! 949: XPoint *a2Ptr; /* Second point of first line. */ ! 950: XPoint *b1Ptr; /* First point of second line. */ ! 951: XPoint *b2Ptr; /* Second point of second line. */ ! 952: XPoint *iPtr; /* Filled in with intersection point. */ ! 953: { ! 954: int dxadyb, dxbdya, dxadxb, dyadyb, p, q; ! 955: ! 956: /* ! 957: * The code below is just a straightforward manipulation of two ! 958: * equations of the form y = (x-x1)*(y2-y1)/(x2-x1) + y1 to solve ! 959: * for the x-coordinate of intersection, then the y-coordinate. ! 960: */ ! 961: ! 962: dxadyb = (a2Ptr->x - a1Ptr->x)*(b2Ptr->y - b1Ptr->y); ! 963: dxbdya = (b2Ptr->x - b1Ptr->x)*(a2Ptr->y - a1Ptr->y); ! 964: dxadxb = (a2Ptr->x - a1Ptr->x)*(b2Ptr->x - b1Ptr->x); ! 965: dyadyb = (a2Ptr->y - a1Ptr->y)*(b2Ptr->y - b1Ptr->y); ! 966: ! 967: if (dxadyb == dxbdya) { ! 968: return -1; ! 969: } ! 970: p = (a1Ptr->x*dxbdya - b1Ptr->x*dxadyb + (b1Ptr->y - a1Ptr->y)*dxadxb); ! 971: q = dxbdya - dxadyb; ! 972: if (q < 0) { ! 973: p = -p; ! 974: q = -q; ! 975: } ! 976: if (p < 0) { ! 977: iPtr->x = - ((-p + q/2)/q); ! 978: } else { ! 979: iPtr->x = (p + q/2)/q; ! 980: } ! 981: p = (a1Ptr->y*dxadyb - b1Ptr->y*dxbdya + (b1Ptr->x - a1Ptr->x)*dyadyb); ! 982: q = dxadyb - dxbdya; ! 983: if (q < 0) { ! 984: p = -p; ! 985: q = -q; ! 986: } ! 987: if (p < 0) { ! 988: iPtr->y = - ((-p + q/2)/q); ! 989: } else { ! 990: iPtr->y = (p + q/2)/q; ! 991: } ! 992: return 0; ! 993: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.