![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkcvwind.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 tkcvwind.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkCanvWind.c -- ! 3: * ! 4: * This file implements window 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/tkCanvWind.c,v 1.4 92/08/24 09:24:22 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 window item. ! 27: */ ! 28: ! 29: typedef struct WindowItem { ! 30: Tk_Item header; /* Generic stuff that's the same for all ! 31: * types. MUST BE FIRST IN STRUCTURE. */ ! 32: double x, y; /* Coordinates of positioning point for ! 33: * window. */ ! 34: Tk_Window tkwin; /* Window associated with item. NULL means ! 35: * window has been destroyed. */ ! 36: int width; /* Width to use for window (<= 0 means use ! 37: * window's requested width). */ ! 38: int height; /* Width to use for window (<= 0 means use ! 39: * window's requested width). */ ! 40: Tk_Anchor anchor; /* Where to anchor window relative to ! 41: * (x,y). */ ! 42: Tk_Canvas *canvasPtr; /* Canvas containing this item. */ ! 43: } WindowItem; ! 44: ! 45: /* ! 46: * Information used for parsing configuration specs: ! 47: */ ! 48: ! 49: static Tk_ConfigSpec configSpecs[] = { ! 50: {TK_CONFIG_ANCHOR, "-anchor", (char *) NULL, (char *) NULL, ! 51: "center", Tk_Offset(WindowItem, anchor), TK_CONFIG_DONT_SET_DEFAULT}, ! 52: {TK_CONFIG_PIXELS, "-height", (char *) NULL, (char *) NULL, ! 53: "0", Tk_Offset(WindowItem, height), TK_CONFIG_DONT_SET_DEFAULT}, ! 54: {TK_CONFIG_CUSTOM, "-tags", (char *) NULL, (char *) NULL, ! 55: (char *) NULL, 0, TK_CONFIG_NULL_OK, &tkCanvasTagsOption}, ! 56: {TK_CONFIG_PIXELS, "-width", (char *) NULL, (char *) NULL, ! 57: "0", Tk_Offset(WindowItem, width), TK_CONFIG_DONT_SET_DEFAULT}, ! 58: {TK_CONFIG_WINDOW, "-window", (char *) NULL, (char *) NULL, ! 59: (char *) NULL, Tk_Offset(WindowItem, tkwin), TK_CONFIG_NULL_OK}, ! 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 ComputeWindowBbox _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 69: WindowItem *winItemPtr)); ! 70: static int ConfigureWinItem _ANSI_ARGS_(( ! 71: Tk_Canvas *canvasPtr, Tk_Item *itemPtr, int argc, ! 72: char **argv, int flags)); ! 73: static int CreateWinItem _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 74: struct Tk_Item *itemPtr, int argc, char **argv)); ! 75: static void DeleteWinItem _ANSI_ARGS_((Tk_Item *itemPtr)); ! 76: static void DisplayWinItem _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 77: Tk_Item *itemPtr, Drawable dst)); ! 78: static void ScaleWinItem _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 79: Tk_Item *itemPtr, double originX, double originY, ! 80: double scaleX, double scaleY)); ! 81: static void TranslateWinItem _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 82: Tk_Item *itemPtr, double deltaX, double deltaY)); ! 83: static int WinItemCoords _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 84: Tk_Item *itemPtr, int argc, char **argv)); ! 85: static void WinItemRequestProc _ANSI_ARGS_((ClientData clientData, ! 86: Tk_Window tkwin)); ! 87: static void WinItemStructureProc _ANSI_ARGS_(( ! 88: ClientData clientData, XEvent *eventPtr)); ! 89: static int WinItemToArea _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 90: Tk_Item *itemPtr, double *rectPtr)); ! 91: static double WinItemToPoint _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 92: Tk_Item *itemPtr, double *pointPtr)); ! 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 TkWindowType = { ! 100: "window", /* name */ ! 101: sizeof(WindowItem), /* itemSize */ ! 102: CreateWinItem, /* createProc */ ! 103: configSpecs, /* configSpecs */ ! 104: ConfigureWinItem, /* configureProc */ ! 105: WinItemCoords, /* coordProc */ ! 106: DeleteWinItem, /* deleteProc */ ! 107: DisplayWinItem, /* displayProc */ ! 108: 1, /* alwaysRedraw */ ! 109: WinItemToPoint, /* pointProc */ ! 110: WinItemToArea, /* areaProc */ ! 111: (Tk_ItemPostscriptProc *) NULL, /* postscriptProc */ ! 112: ScaleWinItem, /* scaleProc */ ! 113: TranslateWinItem, /* 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: /* ! 123: *-------------------------------------------------------------- ! 124: * ! 125: * CreateWinItem -- ! 126: * ! 127: * This procedure is invoked to create a new window ! 128: * item in a canvas. ! 129: * ! 130: * Results: ! 131: * A standard Tcl return value. If an error occurred in ! 132: * creating the item, then an error message is left in ! 133: * canvasPtr->interp->result; in this case itemPtr is ! 134: * left uninitialized, so it can be safely freed by the ! 135: * caller. ! 136: * ! 137: * Side effects: ! 138: * A new window item is created. ! 139: * ! 140: *-------------------------------------------------------------- ! 141: */ ! 142: ! 143: static int ! 144: CreateWinItem(canvasPtr, itemPtr, argc, argv) ! 145: register Tk_Canvas *canvasPtr; /* Canvas to hold new item. */ ! 146: Tk_Item *itemPtr; /* Record to hold new item; header ! 147: * has been initialized by caller. */ ! 148: int argc; /* Number of arguments in argv. */ ! 149: char **argv; /* Arguments describing rectangle. */ ! 150: { ! 151: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 152: ! 153: if (argc < 2) { ! 154: Tcl_AppendResult(canvasPtr->interp, "wrong # args: should be \"", ! 155: Tk_PathName(canvasPtr->tkwin), "\" create ", ! 156: itemPtr->typePtr->name, " x y ?options?", ! 157: (char *) NULL); ! 158: return TCL_ERROR; ! 159: } ! 160: ! 161: /* ! 162: * Initialize item's record. ! 163: */ ! 164: ! 165: winItemPtr->tkwin = NULL; ! 166: winItemPtr->width = 0; ! 167: winItemPtr->height = 0; ! 168: winItemPtr->anchor = TK_ANCHOR_CENTER; ! 169: winItemPtr->canvasPtr = canvasPtr; ! 170: ! 171: /* ! 172: * Process the arguments to fill in the item record. ! 173: */ ! 174: ! 175: if ((TkGetCanvasCoord(canvasPtr, argv[0], &winItemPtr->x) != TCL_OK) ! 176: || (TkGetCanvasCoord(canvasPtr, argv[1], ! 177: &winItemPtr->y) != TCL_OK)) { ! 178: return TCL_ERROR; ! 179: } ! 180: ! 181: if (ConfigureWinItem(canvasPtr, itemPtr, argc-2, argv+2, 0) != TCL_OK) { ! 182: DeleteWinItem(itemPtr); ! 183: return TCL_ERROR; ! 184: } ! 185: return TCL_OK; ! 186: } ! 187: ! 188: /* ! 189: *-------------------------------------------------------------- ! 190: * ! 191: * WinItemCoords -- ! 192: * ! 193: * This procedure is invoked to process the "coords" widget ! 194: * command on window items. See the user documentation for ! 195: * details on what it does. ! 196: * ! 197: * Results: ! 198: * Returns TCL_OK or TCL_ERROR, and sets canvasPtr->interp->result. ! 199: * ! 200: * Side effects: ! 201: * The coordinates for the given item may be changed. ! 202: * ! 203: *-------------------------------------------------------------- ! 204: */ ! 205: ! 206: static int ! 207: WinItemCoords(canvasPtr, itemPtr, argc, argv) ! 208: register Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 209: Tk_Item *itemPtr; /* Item whose coordinates are to be ! 210: * read or modified. */ ! 211: int argc; /* Number of coordinates supplied in ! 212: * argv. */ ! 213: char **argv; /* Array of coordinates: x1, y1, ! 214: * x2, y2, ... */ ! 215: { ! 216: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 217: ! 218: if (argc == 0) { ! 219: sprintf(canvasPtr->interp->result, "%g %g", winItemPtr->x, ! 220: winItemPtr->y); ! 221: } else if (argc == 2) { ! 222: if ((TkGetCanvasCoord(canvasPtr, argv[0], &winItemPtr->x) != TCL_OK) ! 223: || (TkGetCanvasCoord(canvasPtr, argv[1], ! 224: &winItemPtr->y) != TCL_OK)) { ! 225: return TCL_ERROR; ! 226: } ! 227: ComputeWindowBbox(canvasPtr, winItemPtr); ! 228: } else { ! 229: sprintf(canvasPtr->interp->result, ! 230: "wrong # coordinates: expected 0 or 2, got %d", ! 231: argc); ! 232: return TCL_ERROR; ! 233: } ! 234: return TCL_OK; ! 235: } ! 236: ! 237: /* ! 238: *-------------------------------------------------------------- ! 239: * ! 240: * ConfigureWinItem -- ! 241: * ! 242: * This procedure is invoked to configure various aspects ! 243: * of a window item, such as its anchor position. ! 244: * ! 245: * Results: ! 246: * A standard Tcl result code. If an error occurs, then ! 247: * an error message is left in canvasPtr->interp->result. ! 248: * ! 249: * Side effects: ! 250: * Configuration information may be set for itemPtr. ! 251: * ! 252: *-------------------------------------------------------------- ! 253: */ ! 254: ! 255: static int ! 256: ConfigureWinItem(canvasPtr, itemPtr, argc, argv, flags) ! 257: Tk_Canvas *canvasPtr; /* Canvas containing itemPtr. */ ! 258: Tk_Item *itemPtr; /* Window item to reconfigure. */ ! 259: int argc; /* Number of elements in argv. */ ! 260: char **argv; /* Arguments describing things to configure. */ ! 261: int flags; /* Flags to pass to Tk_ConfigureWidget. */ ! 262: { ! 263: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 264: Tk_Window oldWindow; ! 265: ! 266: oldWindow = winItemPtr->tkwin; ! 267: if (Tk_ConfigureWidget(canvasPtr->interp, canvasPtr->tkwin, ! 268: configSpecs, argc, argv, (char *) winItemPtr, flags) != TCL_OK) { ! 269: return TCL_ERROR; ! 270: } ! 271: ! 272: /* ! 273: * A few of the options require additional processing. ! 274: */ ! 275: ! 276: if (oldWindow != winItemPtr->tkwin) { ! 277: if (oldWindow != NULL) { ! 278: Tk_DeleteEventHandler(oldWindow, StructureNotifyMask, ! 279: WinItemStructureProc, (ClientData) winItemPtr); ! 280: Tk_ManageGeometry(oldWindow, (Tk_GeometryProc *) NULL, ! 281: (ClientData) NULL); ! 282: Tk_UnmapWindow(oldWindow); ! 283: } ! 284: if (winItemPtr->tkwin != NULL) { ! 285: Tk_Window ancestor, parent; ! 286: ! 287: /* ! 288: * Make sure that the canvas is either the parent of the ! 289: * window associated with the item or a descendant of that ! 290: * parent. Also, don't allow a top-level window to be ! 291: * managed inside a canvas. ! 292: */ ! 293: ! 294: parent = Tk_Parent(winItemPtr->tkwin); ! 295: for (ancestor = canvasPtr->tkwin; ; ! 296: ancestor = Tk_Parent(ancestor)) { ! 297: if (ancestor == parent) { ! 298: break; ! 299: } ! 300: if (((Tk_FakeWin *) (ancestor))->flags & TK_TOP_LEVEL) { ! 301: badWindow: ! 302: Tcl_AppendResult(canvasPtr->interp, "can't use ", ! 303: Tk_PathName(winItemPtr->tkwin), ! 304: " in a window item of this canvas", (char *) NULL); ! 305: winItemPtr->tkwin = NULL; ! 306: return TCL_ERROR; ! 307: } ! 308: } ! 309: if (((Tk_FakeWin *) (winItemPtr->tkwin))->flags & TK_TOP_LEVEL) { ! 310: goto badWindow; ! 311: } ! 312: if (winItemPtr->tkwin == canvasPtr->tkwin) { ! 313: goto badWindow; ! 314: } ! 315: Tk_CreateEventHandler(winItemPtr->tkwin, StructureNotifyMask, ! 316: WinItemStructureProc, (ClientData) winItemPtr); ! 317: Tk_ManageGeometry(winItemPtr->tkwin, WinItemRequestProc, ! 318: (ClientData) winItemPtr); ! 319: } ! 320: } ! 321: ! 322: ComputeWindowBbox(canvasPtr, winItemPtr); ! 323: ! 324: return TCL_OK; ! 325: } ! 326: ! 327: /* ! 328: *-------------------------------------------------------------- ! 329: * ! 330: * DeleteWinItem -- ! 331: * ! 332: * This procedure is called to clean up the data structure ! 333: * associated with a window item. ! 334: * ! 335: * Results: ! 336: * None. ! 337: * ! 338: * Side effects: ! 339: * Resources associated with itemPtr are released. ! 340: * ! 341: *-------------------------------------------------------------- ! 342: */ ! 343: ! 344: static void ! 345: DeleteWinItem(itemPtr) ! 346: Tk_Item *itemPtr; /* Item that is being deleted. */ ! 347: { ! 348: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 349: ! 350: if (winItemPtr->tkwin != NULL) { ! 351: Tk_DeleteEventHandler(winItemPtr->tkwin, StructureNotifyMask, ! 352: WinItemStructureProc, (ClientData) winItemPtr); ! 353: Tk_ManageGeometry(winItemPtr->tkwin, (Tk_GeometryProc *) NULL, ! 354: (ClientData) NULL); ! 355: Tk_UnmapWindow(winItemPtr->tkwin); ! 356: } ! 357: } ! 358: ! 359: /* ! 360: *-------------------------------------------------------------- ! 361: * ! 362: * ComputeWindowBbox -- ! 363: * ! 364: * This procedure is invoked to compute the bounding box of ! 365: * all the pixels that may be drawn as part of a window item. ! 366: * This procedure is where the child window's placement is ! 367: * computed. ! 368: * ! 369: * Results: ! 370: * None. ! 371: * ! 372: * Side effects: ! 373: * The fields x1, y1, x2, and y2 are updated in the header ! 374: * for itemPtr. ! 375: * ! 376: *-------------------------------------------------------------- ! 377: */ ! 378: ! 379: /* ARGSUSED */ ! 380: static void ! 381: ComputeWindowBbox(canvasPtr, winItemPtr) ! 382: Tk_Canvas *canvasPtr; /* Canvas that contains item. */ ! 383: register WindowItem *winItemPtr; /* Item whose bbox is to be ! 384: * recomputed. */ ! 385: { ! 386: int width, height, x, y; ! 387: ! 388: x = winItemPtr->x + 0.5; ! 389: y = winItemPtr->y + 0.5; ! 390: ! 391: if (winItemPtr->tkwin == NULL) { ! 392: winItemPtr->header.x1 = winItemPtr->header.x2 = x; ! 393: winItemPtr->header.y1 = winItemPtr->header.y2 = y; ! 394: return; ! 395: } ! 396: ! 397: /* ! 398: * Compute dimensions of window. ! 399: */ ! 400: ! 401: width = winItemPtr->width; ! 402: if (width <= 0) { ! 403: width = Tk_ReqWidth(winItemPtr->tkwin); ! 404: if (width <= 0) { ! 405: width = 1; ! 406: } ! 407: } ! 408: height = winItemPtr->height; ! 409: if (height <= 0) { ! 410: height = Tk_ReqHeight(winItemPtr->tkwin); ! 411: if (height <= 0) { ! 412: height = 1; ! 413: } ! 414: } ! 415: ! 416: /* ! 417: * Compute location of window, using anchor information. ! 418: */ ! 419: ! 420: switch (winItemPtr->anchor) { ! 421: case TK_ANCHOR_N: ! 422: x -= width/2; ! 423: break; ! 424: case TK_ANCHOR_NE: ! 425: x -= width; ! 426: break; ! 427: case TK_ANCHOR_E: ! 428: x -= width; ! 429: y -= height/2; ! 430: break; ! 431: case TK_ANCHOR_SE: ! 432: x -= width; ! 433: y -= height; ! 434: break; ! 435: case TK_ANCHOR_S: ! 436: x -= width/2; ! 437: y -= height; ! 438: break; ! 439: case TK_ANCHOR_SW: ! 440: y -= height; ! 441: break; ! 442: case TK_ANCHOR_W: ! 443: y -= height/2; ! 444: break; ! 445: case TK_ANCHOR_NW: ! 446: break; ! 447: case TK_ANCHOR_CENTER: ! 448: x -= width/2; ! 449: y -= height/2; ! 450: break; ! 451: } ! 452: ! 453: /* ! 454: * Store the information in the item header. ! 455: */ ! 456: ! 457: winItemPtr->header.x1 = x; ! 458: winItemPtr->header.y1 = y; ! 459: winItemPtr->header.x2 = x + width; ! 460: winItemPtr->header.y2 = y + height; ! 461: } ! 462: ! 463: /* ! 464: *-------------------------------------------------------------- ! 465: * ! 466: * DisplayWinItem -- ! 467: * ! 468: * This procedure is invoked to "draw" a window item in a given ! 469: * drawable. Since the window draws itself, we needn't do any ! 470: * actual redisplay here. However, this procedure takes care ! 471: * of actually repositioning the child window so that it occupies ! 472: * the correct screen position. ! 473: * ! 474: * Results: ! 475: * None. ! 476: * ! 477: * Side effects: ! 478: * The child window's position may get changed. ! 479: * ! 480: *-------------------------------------------------------------- ! 481: */ ! 482: ! 483: /* ARGSUSED */ ! 484: static void ! 485: DisplayWinItem(canvasPtr, itemPtr, drawable) ! 486: register Tk_Canvas *canvasPtr; /* Canvas that contains item. */ ! 487: Tk_Item *itemPtr; /* Item to be displayed. */ ! 488: Drawable drawable; /* Pixmap or window in which to draw ! 489: * item. */ ! 490: { ! 491: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 492: int x,y, width, height; ! 493: Tk_Window ancestor, parent; ! 494: ! 495: if (winItemPtr->tkwin == NULL) { ! 496: return; ! 497: } ! 498: x = winItemPtr->header.x1 - canvasPtr->xOrigin; ! 499: y = winItemPtr->header.y1 - canvasPtr->yOrigin; ! 500: width = winItemPtr->header.x2 - winItemPtr->header.x1; ! 501: height = winItemPtr->header.y2 - winItemPtr->header.y1; ! 502: ! 503: /* ! 504: * If the canvas isn't the parent of the window, then translate the ! 505: * coordinates from those of the canvas to those of the window's ! 506: * parent. ! 507: */ ! 508: ! 509: parent = Tk_Parent(winItemPtr->tkwin); ! 510: for (ancestor = canvasPtr->tkwin; ancestor != parent; ! 511: ancestor = Tk_Parent(ancestor)) { ! 512: x += Tk_X(ancestor) + Tk_Changes(ancestor)->border_width; ! 513: y += Tk_Y(ancestor) + Tk_Changes(ancestor)->border_width; ! 514: } ! 515: ! 516: /* ! 517: * Reconfigure the window if it isn't already in the correct place. ! 518: */ ! 519: ! 520: if ((x != Tk_X(winItemPtr->tkwin)) || (y != Tk_Y(winItemPtr->tkwin)) ! 521: || (width != Tk_Width(winItemPtr->tkwin)) ! 522: || (height != Tk_Height(winItemPtr->tkwin))) { ! 523: Tk_MoveResizeWindow(winItemPtr->tkwin, x, y, (unsigned int) width, ! 524: (unsigned int) height); ! 525: } ! 526: if (!Tk_IsMapped(winItemPtr->tkwin)) { ! 527: Tk_MapWindow(winItemPtr->tkwin); ! 528: } ! 529: } ! 530: ! 531: /* ! 532: *-------------------------------------------------------------- ! 533: * ! 534: * WinItemToPoint -- ! 535: * ! 536: * Computes the distance from a given point to a given ! 537: * rectangle, in canvas units. ! 538: * ! 539: * Results: ! 540: * The return value is 0 if the point whose x and y coordinates ! 541: * are coordPtr[0] and coordPtr[1] is inside the window. If the ! 542: * point isn't inside the window then the return value is the ! 543: * distance from the point to the window. ! 544: * ! 545: * Side effects: ! 546: * None. ! 547: * ! 548: *-------------------------------------------------------------- ! 549: */ ! 550: ! 551: /* ARGSUSED */ ! 552: static double ! 553: WinItemToPoint(canvasPtr, itemPtr, pointPtr) ! 554: Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 555: Tk_Item *itemPtr; /* Item to check against point. */ ! 556: double *pointPtr; /* Pointer to x and y coordinates. */ ! 557: { ! 558: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 559: double x1, x2, y1, y2, xDiff, yDiff; ! 560: ! 561: x1 = winItemPtr->header.x1; ! 562: y1 = winItemPtr->header.y1; ! 563: x2 = winItemPtr->header.x2; ! 564: y2 = winItemPtr->header.y2; ! 565: ! 566: /* ! 567: * Point is outside rectangle. ! 568: */ ! 569: ! 570: if (pointPtr[0] < x1) { ! 571: xDiff = x1 - pointPtr[0]; ! 572: } else if (pointPtr[0] > x2) { ! 573: xDiff = pointPtr[0] - x2; ! 574: } else { ! 575: xDiff = 0; ! 576: } ! 577: ! 578: if (pointPtr[1] < y1) { ! 579: yDiff = y1 - pointPtr[1]; ! 580: } else if (pointPtr[1] > y2) { ! 581: yDiff = pointPtr[1] - y2; ! 582: } else { ! 583: yDiff = 0; ! 584: } ! 585: ! 586: return hypot(xDiff, yDiff); ! 587: } ! 588: ! 589: /* ! 590: *-------------------------------------------------------------- ! 591: * ! 592: * WinItemToArea -- ! 593: * ! 594: * This procedure is called to determine whether an item ! 595: * lies entirely inside, entirely outside, or overlapping ! 596: * a given rectangle. ! 597: * ! 598: * Results: ! 599: * -1 is returned if the item is entirely outside the area ! 600: * given by rectPtr, 0 if it overlaps, and 1 if it is entirely ! 601: * inside the given area. ! 602: * ! 603: * Side effects: ! 604: * None. ! 605: * ! 606: *-------------------------------------------------------------- ! 607: */ ! 608: ! 609: /* ARGSUSED */ ! 610: static int ! 611: WinItemToArea(canvasPtr, itemPtr, rectPtr) ! 612: Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 613: Tk_Item *itemPtr; /* Item to check against rectangle. */ ! 614: double *rectPtr; /* Pointer to array of four coordinates ! 615: * (x1, y1, x2, y2) describing rectangular ! 616: * area. */ ! 617: { ! 618: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 619: ! 620: if ((rectPtr[2] <= winItemPtr->header.x1) ! 621: || (rectPtr[0] >= winItemPtr->header.x2) ! 622: || (rectPtr[3] <= winItemPtr->header.y1) ! 623: || (rectPtr[1] >= winItemPtr->header.y2)) { ! 624: return -1; ! 625: } ! 626: if ((rectPtr[0] <= winItemPtr->header.x1) ! 627: && (rectPtr[1] <= winItemPtr->header.y1) ! 628: && (rectPtr[2] >= winItemPtr->header.x2) ! 629: && (rectPtr[3] >= winItemPtr->header.y2)) { ! 630: return 1; ! 631: } ! 632: return 0; ! 633: } ! 634: ! 635: /* ! 636: *-------------------------------------------------------------- ! 637: * ! 638: * ScaleWinItem -- ! 639: * ! 640: * This procedure is invoked to rescale a rectangle or oval ! 641: * item. ! 642: * ! 643: * Results: ! 644: * None. ! 645: * ! 646: * Side effects: ! 647: * The rectangle or oval referred to by itemPtr is rescaled ! 648: * so that the following transformation is applied to all ! 649: * point coordinates: ! 650: * x' = originX + scaleX*(x-originX) ! 651: * y' = originY + scaleY*(y-originY) ! 652: * ! 653: *-------------------------------------------------------------- ! 654: */ ! 655: ! 656: static void ! 657: ScaleWinItem(canvasPtr, itemPtr, originX, originY, scaleX, scaleY) ! 658: Tk_Canvas *canvasPtr; /* Canvas containing rectangle. */ ! 659: Tk_Item *itemPtr; /* Rectangle to be scaled. */ ! 660: double originX, originY; /* Origin about which to scale rect. */ ! 661: double scaleX; /* Amount to scale in X direction. */ ! 662: double scaleY; /* Amount to scale in Y direction. */ ! 663: { ! 664: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 665: ! 666: winItemPtr->x = originX + scaleX*(winItemPtr->x - originX); ! 667: winItemPtr->y = originY + scaleY*(winItemPtr->y - originY); ! 668: if (winItemPtr->width > 0) { ! 669: winItemPtr->width = scaleY*winItemPtr->width; ! 670: } ! 671: if (winItemPtr->height > 0) { ! 672: winItemPtr->height = scaleY*winItemPtr->height; ! 673: } ! 674: ComputeWindowBbox(canvasPtr, winItemPtr); ! 675: } ! 676: ! 677: /* ! 678: *-------------------------------------------------------------- ! 679: * ! 680: * TranslateWinItem -- ! 681: * ! 682: * This procedure is called to move a rectangle or oval by a ! 683: * given amount. ! 684: * ! 685: * Results: ! 686: * None. ! 687: * ! 688: * Side effects: ! 689: * The position of the rectangle or oval is offset by ! 690: * (xDelta, yDelta), and the bounding box is updated in the ! 691: * generic part of the item structure. ! 692: * ! 693: *-------------------------------------------------------------- ! 694: */ ! 695: ! 696: static void ! 697: TranslateWinItem(canvasPtr, itemPtr, deltaX, deltaY) ! 698: Tk_Canvas *canvasPtr; /* Canvas containing item. */ ! 699: Tk_Item *itemPtr; /* Item that is being moved. */ ! 700: double deltaX, deltaY; /* Amount by which item is to be ! 701: * moved. */ ! 702: { ! 703: register WindowItem *winItemPtr = (WindowItem *) itemPtr; ! 704: ! 705: winItemPtr->x += deltaX; ! 706: winItemPtr->y += deltaY; ! 707: ComputeWindowBbox(canvasPtr, winItemPtr); ! 708: } ! 709: ! 710: /* ! 711: *-------------------------------------------------------------- ! 712: * ! 713: * WinItemStructureProc -- ! 714: * ! 715: * This procedure is invoked whenever StructureNotify events ! 716: * occur for a window that's managed as part of a canvas window ! 717: * item. This procudure's only purpose is to clean up when ! 718: * windows are deleted. ! 719: * ! 720: * Results: ! 721: * None. ! 722: * ! 723: * Side effects: ! 724: * The window is disassociated from the window item when it is ! 725: * deleted. ! 726: * ! 727: *-------------------------------------------------------------- ! 728: */ ! 729: ! 730: static void ! 731: WinItemStructureProc(clientData, eventPtr) ! 732: ClientData clientData; /* Pointer to record describing window item. */ ! 733: XEvent *eventPtr; /* Describes what just happened. */ ! 734: { ! 735: register WindowItem *winItemPtr = (WindowItem *) clientData; ! 736: ! 737: if (eventPtr->type == DestroyNotify) { ! 738: winItemPtr->tkwin = NULL; ! 739: } ! 740: } ! 741: ! 742: /* ! 743: *-------------------------------------------------------------- ! 744: * ! 745: * WinItemRequestProc -- ! 746: * ! 747: * This procedure is invoked whenever a window that's associated ! 748: * with a window canvas item changes its requested dimensions. ! 749: * ! 750: * Results: ! 751: * None. ! 752: * ! 753: * Side effects: ! 754: * The size and location on the screen of the window may change, ! 755: * depending on the options specified for the window item. ! 756: * ! 757: *-------------------------------------------------------------- ! 758: */ ! 759: ! 760: /* ARGSUSED */ ! 761: static void ! 762: WinItemRequestProc(clientData, tkwin) ! 763: ClientData clientData; /* Pointer to record for window item. */ ! 764: Tk_Window tkwin; /* Window that changed its desired ! 765: * size. */ ! 766: { ! 767: WindowItem *winItemPtr = (WindowItem *) clientData; ! 768: ! 769: ComputeWindowBbox(winItemPtr->canvasPtr, winItemPtr); ! 770: DisplayWinItem(winItemPtr->canvasPtr, (Tk_Item *) winItemPtr, ! 771: (Drawable) None); ! 772: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.