![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkcanvas.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 tkcanvas.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkCanvas.c -- ! 3: * ! 4: * This module implements canvas widgets for the Tk toolkit. ! 5: * A canvas displays a background and a collection of graphical ! 6: * objects such as rectangles, lines, and texts. ! 7: * ! 8: * Copyright 1991-1992 Regents of the University of California. ! 9: * Permission to use, copy, modify, and distribute this ! 10: * software and its documentation for any purpose and without ! 11: * fee is hereby granted, provided that the above copyright ! 12: * notice appear in all copies. The University of California ! 13: * makes no representations about the suitability of this ! 14: * software for any purpose. It is provided "as is" without ! 15: * express or implied warranty. ! 16: */ ! 17: ! 18: #ifndef lint ! 19: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkCanvas.c,v 1.28 92/08/19 08:47:57 ouster Exp $ SPRITE (Berkeley)"; ! 20: #endif ! 21: ! 22: #include <stdio.h> ! 23: #include <stdlib.h> ! 24: #include <string.h> ! 25: #include <assert.h> ! 26: #include "default.h" ! 27: #include "tkint.h" ! 28: #include "tkconfig.h" ! 29: #include "tkcanvas.h" ! 30: ! 31: /* ! 32: * See tkCanvas.h for key data structures used to implement canvases. ! 33: */ ! 34: ! 35: /* ! 36: * The structure defined below is used to keep track of a tag search ! 37: * in progress. Only the "prevPtr" field should be accessed by anyone ! 38: * other than StartTagSearch and NextItem. ! 39: */ ! 40: ! 41: typedef struct TagSearch { ! 42: Tk_Canvas *canvasPtr; /* Canvas widget being searched. */ ! 43: Tk_Uid tag; /* Tag to search for. 0 means return ! 44: * all items. */ ! 45: Tk_Item *prevPtr; /* Item just before last one found (or NULL ! 46: * if last one found was first in the item ! 47: * list of canvasPtr). */ ! 48: Tk_Item *currentPtr; /* Pointer to last item returned. */ ! 49: int searchOver; /* Non-zero means NextItem should always ! 50: * return NULL. */ ! 51: } TagSearch; ! 52: ! 53: /* ! 54: * Information used for argv parsing. ! 55: */ ! 56: ! 57: ! 58: static Tk_ConfigSpec configSpecs[] = { ! 59: {TK_CONFIG_BORDER, "-background", "background", "Background", ! 60: DEF_CANVAS_BG_COLOR, Tk_Offset(Tk_Canvas, bgBorder), ! 61: TK_CONFIG_COLOR_ONLY}, ! 62: {TK_CONFIG_COLOR, (char *) NULL, (char *) NULL, (char *) NULL, ! 63: (char *) NULL, Tk_Offset(Tk_Canvas, bgColor), ! 64: TK_CONFIG_COLOR_ONLY}, ! 65: {TK_CONFIG_BORDER, "-background", "background", "Background", ! 66: DEF_CANVAS_BG_MONO, Tk_Offset(Tk_Canvas, bgBorder), ! 67: TK_CONFIG_MONO_ONLY}, ! 68: {TK_CONFIG_COLOR, (char *) NULL, (char *) NULL, (char *) NULL, ! 69: (char *) NULL, Tk_Offset(Tk_Canvas, bgColor), ! 70: TK_CONFIG_MONO_ONLY}, ! 71: {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL, ! 72: (char *) NULL, 0, 0}, ! 73: {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL, ! 74: (char *) NULL, 0, 0}, ! 75: {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth", ! 76: DEF_CANVAS_BORDER_WIDTH, Tk_Offset(Tk_Canvas, borderWidth), 0}, ! 77: {TK_CONFIG_DOUBLE, "-closeenough", "closeEnough", "CloseEnough", ! 78: DEF_CANVAS_CLOSE_ENOUGH, Tk_Offset(Tk_Canvas, closeEnough), 0}, ! 79: {TK_CONFIG_BOOLEAN, "-confine", "confine", "Confine", ! 80: DEF_CANVAS_CONFINE, Tk_Offset(Tk_Canvas, confine), 0}, ! 81: {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor", ! 82: DEF_CANVAS_CURSOR, Tk_Offset(Tk_Canvas, cursor), TK_CONFIG_NULL_OK}, ! 83: {TK_CONFIG_BORDER, "-cursorbackground", "cursorBackground", "Foreground", ! 84: DEF_CANVAS_CURSOR_BG, Tk_Offset(Tk_Canvas, cursorBorder), 0}, ! 85: {TK_CONFIG_PIXELS, "-cursorborderwidth", "cursorBorderWidth", "BorderWidth", ! 86: DEF_CANVAS_CURSOR_BD_COLOR, Tk_Offset(Tk_Canvas, cursorBorderWidth), ! 87: TK_CONFIG_COLOR_ONLY}, ! 88: {TK_CONFIG_PIXELS, "-cursorborderwidth", "cursorBorderWidth", "BorderWidth", ! 89: DEF_CANVAS_CURSOR_BD_MONO, Tk_Offset(Tk_Canvas, cursorBorderWidth), ! 90: TK_CONFIG_MONO_ONLY}, ! 91: {TK_CONFIG_INT, "-cursorofftime", "cursorOffTime", "OffTime", ! 92: DEF_CANVAS_CURSOR_OFF_TIME, Tk_Offset(Tk_Canvas, cursorOffTime), 0}, ! 93: {TK_CONFIG_INT, "-cursorontime", "cursorOnTime", "OnTime", ! 94: DEF_CANVAS_CURSOR_ON_TIME, Tk_Offset(Tk_Canvas, cursorOnTime), 0}, ! 95: {TK_CONFIG_PIXELS, "-cursorwidth", "cursorWidth", "CursorWidth", ! 96: DEF_CANVAS_CURSOR_WIDTH, Tk_Offset(Tk_Canvas, cursorWidth), 0}, ! 97: {TK_CONFIG_PIXELS, "-height", "height", "Height", ! 98: DEF_CANVAS_HEIGHT, Tk_Offset(Tk_Canvas, height), 0}, ! 99: {TK_CONFIG_RELIEF, "-relief", "relief", "Relief", ! 100: DEF_CANVAS_RELIEF, Tk_Offset(Tk_Canvas, relief), 0}, ! 101: {TK_CONFIG_PIXELS, "-scrollincrement", "scrollIncrement", "ScrollIncrement", ! 102: DEF_CANVAS_SCROLL_INCREMENT, Tk_Offset(Tk_Canvas, scrollIncrement), 0}, ! 103: {TK_CONFIG_STRING, "-scrollregion", "scrollRegion", "ScrollRegion", ! 104: DEF_CANVAS_SCROLL_REGION, Tk_Offset(Tk_Canvas, regionString), 0}, ! 105: {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground", ! 106: DEF_CANVAS_SELECT_COLOR, Tk_Offset(Tk_Canvas, selBorder), ! 107: TK_CONFIG_COLOR_ONLY}, ! 108: {TK_CONFIG_BORDER, "-selectbackground", "selectBackground", "Foreground", ! 109: DEF_CANVAS_SELECT_MONO, Tk_Offset(Tk_Canvas, selBorder), ! 110: TK_CONFIG_MONO_ONLY}, ! 111: {TK_CONFIG_PIXELS, "-selectborderwidth", "selectBorderWidth", "BorderWidth", ! 112: DEF_CANVAS_SELECT_BD_COLOR, Tk_Offset(Tk_Canvas, selBorderWidth), ! 113: TK_CONFIG_COLOR_ONLY}, ! 114: {TK_CONFIG_PIXELS, "-selectborderwidth", "selectBorderWidth", "BorderWidth", ! 115: DEF_CANVAS_SELECT_BD_MONO, Tk_Offset(Tk_Canvas, selBorderWidth), ! 116: TK_CONFIG_MONO_ONLY}, ! 117: {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background", ! 118: DEF_CANVAS_SELECT_FG_COLOR, Tk_Offset(Tk_Canvas, selFgColorPtr), ! 119: TK_CONFIG_COLOR_ONLY}, ! 120: {TK_CONFIG_COLOR, "-selectforeground", "selectForeground", "Background", ! 121: DEF_CANVAS_SELECT_FG_MONO, Tk_Offset(Tk_Canvas, selFgColorPtr), ! 122: TK_CONFIG_MONO_ONLY}, ! 123: {TK_CONFIG_PIXELS, "-width", "width", "Width", ! 124: DEF_CANVAS_WIDTH, Tk_Offset(Tk_Canvas, width), 0}, ! 125: {TK_CONFIG_STRING, "-xscrollcommand", "xScrollCommand", "ScrollCommand", ! 126: DEF_CANVAS_X_SCROLL_CMD, Tk_Offset(Tk_Canvas, xScrollCmd), 0}, ! 127: {TK_CONFIG_STRING, "-yscrollcommand", "yScrollCommand", "ScrollCommand", ! 128: DEF_CANVAS_Y_SCROLL_CMD, Tk_Offset(Tk_Canvas, yScrollCmd), 0}, ! 129: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL, ! 130: (char *) NULL, 0, 0} ! 131: }; ! 132: ! 133: /* ! 134: * List of all the item types known at present: ! 135: */ ! 136: ! 137: static Tk_ItemType *typeList = NULL; /* NULL means initialization hasn't ! 138: * been done yet. */ ! 139: ! 140: /* ! 141: * Standard item types provided by Tk: ! 142: */ ! 143: ! 144: extern Tk_ItemType TkArcType, TkBitmapType, TkLineType; ! 145: extern Tk_ItemType TkOvalType, TkPolygonType; ! 146: extern Tk_ItemType TkRectangleType, TkTextType, TkWindowType; ! 147: ! 148: /* ! 149: * Various Tk_Uid's used by this module (set up during initialization): ! 150: */ ! 151: ! 152: static Tk_Uid allUid = NULL; ! 153: static Tk_Uid currentUid = NULL; ! 154: ! 155: /* ! 156: * Statistics counters: ! 157: */ ! 158: ! 159: static int numIdSearches; ! 160: static int numSlowSearches; ! 161: ! 162: static int CanvasUpdateTime = 200; // Added by Don. ! 163: ! 164: /* ! 165: * Prototypes for procedures defined later in this file: ! 166: */ ! 167: ! 168: static void CanvasBindProc _ANSI_ARGS_((ClientData clientData, ! 169: XEvent *eventPtr)); ! 170: static void CanvasBlinkProc _ANSI_ARGS_((ClientData clientData)); ! 171: static void CanvasDoEvent _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 172: XEvent *eventPtr)); ! 173: static void CanvasEventProc _ANSI_ARGS_((ClientData clientData, ! 174: XEvent *eventPtr)); ! 175: static int CanvasFetchSelection _ANSI_ARGS_(( ! 176: ClientData clientData, int offset, ! 177: char *buffer, int maxBytes)); ! 178: static void CanvasFocusProc _ANSI_ARGS_((ClientData clientData, ! 179: int gotFocus)); ! 180: static void CanvasLostSelection _ANSI_ARGS_(( ! 181: ClientData clientData)); ! 182: static void CanvasSelectTo _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 183: Tk_Item *itemPtr, int index)); ! 184: static void CanvasSetOrigin _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 185: int xOrigin, int yOrigin)); ! 186: static int CanvasTagsParseProc _ANSI_ARGS_((ClientData clientData, ! 187: Tcl_Interp *interp, Tk_Window tkwin, char *value, ! 188: char *widgRec, int offset)); ! 189: static char * CanvasTagsPrintProc _ANSI_ARGS_((ClientData clientData, ! 190: Tk_Window tkwin, char *widgRec, int offset, ! 191: Tcl_FreeProc **freeProcPtr)); ! 192: static void CanvasUpdateScrollbars _ANSI_ARGS_(( ! 193: Tk_Canvas *canvasPtr)); ! 194: static int CanvasWidgetCmd _ANSI_ARGS_((ClientData clientData, ! 195: Tcl_Interp *interp, int argc, char **argv)); ! 196: static int ConfigureCanvas _ANSI_ARGS_((Tcl_Interp *interp, ! 197: Tk_Canvas *canvasPtr, int argc, char **argv, ! 198: int flags)); ! 199: static void DestroyCanvas _ANSI_ARGS_((ClientData clientData)); ! 200: static void DisplayCanvas _ANSI_ARGS_((ClientData clientData)); ! 201: static void DoItem _ANSI_ARGS_((Tcl_Interp *interp, ! 202: Tk_Item *itemPtr, Tk_Uid tag)); ! 203: static void EventuallyRedrawArea _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 204: int x1, int y1, int x2, int y2)); ! 205: static int FindItems _ANSI_ARGS_((Tcl_Interp *interp, ! 206: Tk_Canvas *canvasPtr, int argc, char **argv, ! 207: char *newTag, char *cmdName, char *option)); ! 208: static int FindArea _ANSI_ARGS_((Tcl_Interp *interp, ! 209: Tk_Canvas *canvasPtr, char **argv, Tk_Uid uid, ! 210: int enclosed)); ! 211: static double GridAlign _ANSI_ARGS_((double coord, double spacing)); ! 212: static void InitCanvas _ANSI_ARGS_((void)); ! 213: static Tk_Item * NextItem _ANSI_ARGS_((TagSearch *searchPtr)); ! 214: static void PickCurrentItem _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 215: XEvent *eventPtr)); ! 216: static void RelinkItems _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 217: char *tag, Tk_Item *prevPtr)); ! 218: #if defined(USE_XPM3) ! 219: static int SaveCanvas _ANSI_ARGS_((Tcl_Interp *interp, ! 220: Tk_Canvas *canvasPtr, char *fileName, int x, ! 221: int y, unsigned int width, unsigned int height)); ! 222: #endif ! 223: static Tk_Item * StartTagSearch _ANSI_ARGS_((Tk_Canvas *canvasPtr, ! 224: char *tag, TagSearch *searchPtr)); ! 225: ! 226: /* ! 227: * Custom option for handling "-tags" options for canvas items: ! 228: */ ! 229: ! 230: Tk_CustomOption tkCanvasTagsOption = { ! 231: CanvasTagsParseProc, ! 232: CanvasTagsPrintProc, ! 233: (ClientData) NULL ! 234: }; ! 235: ! 236: /* ! 237: *-------------------------------------------------------------- ! 238: * ! 239: * Tk_CanvasCmd -- ! 240: * ! 241: * This procedure is invoked to process the "canvas" Tcl ! 242: * command. See the user documentation for details on what ! 243: * it does. ! 244: * ! 245: * Results: ! 246: * A standard Tcl result. ! 247: * ! 248: * Side effects: ! 249: * See the user documentation. ! 250: * ! 251: *-------------------------------------------------------------- ! 252: */ ! 253: ! 254: int ! 255: Tk_CanvasCmd(clientData, interp, argc, argv) ! 256: ClientData clientData; /* Main window associated with ! 257: * interpreter. */ ! 258: Tcl_Interp *interp; /* Current interpreter. */ ! 259: int argc; /* Number of arguments. */ ! 260: char **argv; /* Argument strings. */ ! 261: { ! 262: Tk_Window tkwin = (Tk_Window) clientData; ! 263: register Tk_Canvas *canvasPtr; ! 264: Tk_Window new; ! 265: ! 266: if (typeList == NULL) { ! 267: InitCanvas(); ! 268: } ! 269: ! 270: if (argc < 2) { ! 271: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 272: argv[0], " pathName ?options?\"", (char *) NULL); ! 273: return TCL_ERROR; ! 274: } ! 275: ! 276: new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], (char *) NULL); ! 277: if (new == NULL) { ! 278: return TCL_ERROR; ! 279: } ! 280: ! 281: /* ! 282: * Initialize fields that won't be initialized by ConfigureCanvas, ! 283: * or which ConfigureCanvas expects to have reasonable values ! 284: * (e.g. resource pointers). ! 285: */ ! 286: ! 287: canvasPtr = (Tk_Canvas *) ckalloc(sizeof(Tk_Canvas)); ! 288: canvasPtr->tkwin = new; ! 289: canvasPtr->interp = interp; ! 290: canvasPtr->firstItemPtr = NULL; ! 291: canvasPtr->lastItemPtr = NULL; ! 292: canvasPtr->bgBorder = NULL; ! 293: canvasPtr->bgColor = NULL; ! 294: canvasPtr->pixmapGC = None; ! 295: canvasPtr->selBorder = NULL; ! 296: canvasPtr->selFgColorPtr = NULL; ! 297: canvasPtr->selItemPtr = NULL; ! 298: canvasPtr->selectFirst = -1; ! 299: canvasPtr->selectLast = -1; ! 300: canvasPtr->cursorBorder = NULL; ! 301: canvasPtr->cursorBlinkHandler = (Tk_TimerToken) NULL; ! 302: canvasPtr->focusItemPtr = NULL; ! 303: canvasPtr->xOrigin = canvasPtr->yOrigin = 0; ! 304: canvasPtr->drawableXOrigin = canvasPtr->drawableYOrigin = 0; ! 305: canvasPtr->bindingTable = NULL; ! 306: canvasPtr->currentItemPtr = NULL; ! 307: canvasPtr->pickEvent.type = LeaveNotify; ! 308: canvasPtr->xScrollCmd = NULL; ! 309: canvasPtr->yScrollCmd = NULL; ! 310: canvasPtr->regionString = NULL; ! 311: canvasPtr->hotPtr = NULL; ! 312: canvasPtr->cursor = None; ! 313: canvasPtr->pixelsPerMM = WidthOfScreen(Tk_Screen(new)); ! 314: canvasPtr->pixelsPerMM /= WidthMMOfScreen(Tk_Screen(new)); ! 315: canvasPtr->flags = 0; ! 316: canvasPtr->nextId = 1; ! 317: canvasPtr->updateTimerToken = NULL; ! 318: ! 319: Tk_SetClass(canvasPtr->tkwin, "Canvas"); ! 320: Tk_CreateEventHandler(canvasPtr->tkwin, ExposureMask|StructureNotifyMask, ! 321: CanvasEventProc, (ClientData) canvasPtr); ! 322: Tk_CreateEventHandler(canvasPtr->tkwin, KeyPressMask|KeyReleaseMask ! 323: |ButtonPressMask|ButtonReleaseMask|EnterWindowMask ! 324: |LeaveWindowMask|PointerMotionMask, CanvasBindProc, ! 325: (ClientData) canvasPtr); ! 326: Tk_CreateSelHandler(canvasPtr->tkwin, XA_STRING, CanvasFetchSelection, ! 327: (ClientData) canvasPtr, XA_STRING); ! 328: Tcl_CreateCommand(interp, Tk_PathName(canvasPtr->tkwin), CanvasWidgetCmd, ! 329: (ClientData) canvasPtr, (void (*)()) NULL); ! 330: if (ConfigureCanvas(interp, canvasPtr, argc-2, argv+2, 0) != TCL_OK) { ! 331: goto error; ! 332: } ! 333: Tk_CreateFocusHandler(canvasPtr->tkwin, CanvasFocusProc, ! 334: (ClientData) canvasPtr); ! 335: ! 336: interp->result = Tk_PathName(canvasPtr->tkwin); ! 337: return TCL_OK; ! 338: ! 339: error: ! 340: Tk_DestroyWindow(canvasPtr->tkwin); ! 341: return TCL_ERROR; ! 342: } ! 343: ! 344: /* ! 345: *-------------------------------------------------------------- ! 346: * ! 347: * CanvasWidgetCmd -- ! 348: * ! 349: * This procedure is invoked to process the Tcl command ! 350: * that corresponds to a widget managed by this module. ! 351: * See the user documentation for details on what it does. ! 352: * ! 353: * Results: ! 354: * A standard Tcl result. ! 355: * ! 356: * Side effects: ! 357: * See the user documentation. ! 358: * ! 359: *-------------------------------------------------------------- ! 360: */ ! 361: ! 362: static int ! 363: CanvasWidgetCmd(clientData, interp, argc, argv) ! 364: ClientData clientData; /* Information about canvas ! 365: * widget. */ ! 366: Tcl_Interp *interp; /* Current interpreter. */ ! 367: int argc; /* Number of arguments. */ ! 368: char **argv; /* Argument strings. */ ! 369: { ! 370: register Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 371: int length, result; ! 372: char c; ! 373: Tk_Item *itemPtr = NULL; /* Initialization needed only to ! 374: * prevent compiler warning. */ ! 375: TagSearch search; ! 376: ! 377: if (argc < 2) { ! 378: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 379: argv[0], " option ?arg arg ...?\"", (char *) NULL); ! 380: return TCL_ERROR; ! 381: } ! 382: Tk_Preserve((ClientData) canvasPtr); ! 383: result = TCL_OK; ! 384: c = argv[1][0]; ! 385: length = strlen(argv[1]); ! 386: if ((c == 'a') && (strncmp(argv[1], "addtag", length) == 0)) { ! 387: if (argc < 4) { ! 388: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 389: argv[0], " addtags tag searchCommand ?arg arg ...?\"", ! 390: (char *) NULL); ! 391: goto error; ! 392: } ! 393: result = FindItems(interp, canvasPtr, argc-3, argv+3, argv[2], argv[0], ! 394: " addtag tag"); ! 395: } else if ((c == 'b') && (strncmp(argv[1], "bbox", length) == 0) ! 396: && (length >= 2)) { ! 397: int i, gotAny; ! 398: int x1 = 0, y1 = 0, x2 = 0, y2 = 0; /* Initializations needed ! 399: * only to prevent compiler ! 400: * warnings. */ ! 401: ! 402: if (argc < 3) { ! 403: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 404: argv[0], " bbox tagOrId ?tagOrId ...?\"", ! 405: (char *) NULL); ! 406: goto error; ! 407: } ! 408: gotAny = 0; ! 409: for (i = 2; i < argc; i++) { ! 410: for (itemPtr = StartTagSearch(canvasPtr, argv[i], &search); ! 411: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 412: if (!gotAny) { ! 413: x1 = itemPtr->x1; ! 414: y1 = itemPtr->y1; ! 415: x2 = itemPtr->x2; ! 416: y2 = itemPtr->y2; ! 417: gotAny = 1; ! 418: } else { ! 419: if (itemPtr->x1 < x1) { ! 420: x1 = itemPtr->x1; ! 421: } ! 422: if (itemPtr->y1 < y1) { ! 423: y1 = itemPtr->y1; ! 424: } ! 425: if (itemPtr->x2 > x2) { ! 426: x2 = itemPtr->x2; ! 427: } ! 428: if (itemPtr->y2 > y2) { ! 429: y2 = itemPtr->y2; ! 430: } ! 431: } ! 432: } ! 433: } ! 434: if (gotAny) { ! 435: sprintf(interp->result, "%d %d %d %d", x1, y1, x2, y2); ! 436: } ! 437: } else if ((c == 'b') && (strncmp(argv[1], "bind", length) == 0) ! 438: && (length >= 2)) { ! 439: ClientData object; ! 440: ! 441: if ((argc < 3) || (argc > 5)) { ! 442: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 443: argv[0], " bind tagOrId ?sequence? ?command?\"", ! 444: (char *) NULL); ! 445: goto error; ! 446: } ! 447: ! 448: /* ! 449: * Figure out what object to use for the binding (individual ! 450: * item vs. tag). ! 451: */ ! 452: ! 453: object = 0; ! 454: if (isdigit(argv[2][0])) { ! 455: int id; ! 456: char *end; ! 457: ! 458: id = strtoul(argv[2], &end, 0); ! 459: if (*end != 0) { ! 460: goto bindByTag; ! 461: } ! 462: for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL; ! 463: itemPtr = itemPtr->nextPtr) { ! 464: if (itemPtr->id == id) { ! 465: object = (ClientData) itemPtr; ! 466: break; ! 467: } ! 468: } ! 469: if (object == 0) { ! 470: Tcl_AppendResult(interp, "item \"", argv[2], ! 471: "\" doesn't exist", (char *) NULL); ! 472: goto error; ! 473: } ! 474: } else { ! 475: bindByTag: ! 476: object = (ClientData) Tk_GetUid(argv[2]); ! 477: } ! 478: ! 479: /* ! 480: * Make a binding table if the canvas doesn't already have ! 481: * one. ! 482: */ ! 483: ! 484: if (canvasPtr->bindingTable == NULL) { ! 485: canvasPtr->bindingTable = Tk_CreateBindingTable(interp); ! 486: } ! 487: ! 488: if (argc == 5) { ! 489: int append = 0; ! 490: unsigned long mask; ! 491: ! 492: if (argv[4][0] == 0) { ! 493: result = Tk_DeleteBinding(interp, canvasPtr->bindingTable, ! 494: object, argv[3]); ! 495: goto done; ! 496: } ! 497: if (argv[4][0] == '+') { ! 498: argv[4]++; ! 499: append = 1; ! 500: } ! 501: mask = Tk_CreateBinding(interp, canvasPtr->bindingTable, ! 502: object, argv[3], argv[4], append); ! 503: if (mask == 0) { ! 504: goto error; ! 505: } ! 506: if (mask & ~(ButtonMotionMask|Button1MotionMask|Button2MotionMask ! 507: |Button3MotionMask|Button4MotionMask|Button5MotionMask ! 508: |ButtonPressMask|ButtonReleaseMask|EnterWindowMask ! 509: |LeaveWindowMask|KeyPressMask|KeyReleaseMask ! 510: |PointerMotionMask)) { ! 511: Tk_DeleteBinding(interp, canvasPtr->bindingTable, ! 512: object, argv[3]); ! 513: Tcl_ResetResult(interp); ! 514: Tcl_AppendResult(interp, "requested illegal events; ", ! 515: "only key, button, motion, and enter/leave ", ! 516: "events may be used", (char *) NULL); ! 517: goto error; ! 518: } ! 519: } else if (argc == 4) { ! 520: char *command; ! 521: ! 522: command = Tk_GetBinding(interp, canvasPtr->bindingTable, ! 523: object, argv[3]); ! 524: if (command == NULL) { ! 525: goto error; ! 526: } ! 527: interp->result = command; ! 528: } else { ! 529: Tk_GetAllBindings(interp, canvasPtr->bindingTable, object); ! 530: } ! 531: } else if ((c == 'c') && (strcmp(argv[1], "canvasx") == 0)) { ! 532: int x; ! 533: double grid; ! 534: ! 535: if ((argc < 3) || (argc > 4)) { ! 536: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 537: argv[0], " canvasx screenx ?gridspacing?\"", ! 538: (char *) NULL); ! 539: goto error; ! 540: } ! 541: if (Tk_GetPixels(interp, canvasPtr->tkwin, argv[2], &x) != TCL_OK) { ! 542: goto error; ! 543: } ! 544: if (argc == 4) { ! 545: if (TkGetCanvasCoord(canvasPtr, argv[3], &grid) != TCL_OK) { ! 546: goto error; ! 547: } ! 548: } else { ! 549: grid = 0.0; ! 550: } ! 551: x += canvasPtr->xOrigin; ! 552: sprintf(interp->result, "%g", GridAlign((double) x, grid)); ! 553: } else if ((c == 'c') && (strcmp(argv[1], "canvasy") == 0)) { ! 554: int y; ! 555: double grid; ! 556: ! 557: if ((argc < 3) || (argc > 4)) { ! 558: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 559: argv[0], " canvasy screeny ?gridspacing?\"", ! 560: (char *) NULL); ! 561: goto error; ! 562: } ! 563: if (Tk_GetPixels(interp, canvasPtr->tkwin, argv[2], &y) != TCL_OK) { ! 564: goto error; ! 565: } ! 566: if (argc == 4) { ! 567: if (TkGetCanvasCoord(canvasPtr, argv[3], &grid) != TCL_OK) { ! 568: goto error; ! 569: } ! 570: } else { ! 571: grid = 0.0; ! 572: } ! 573: y += canvasPtr->yOrigin; ! 574: sprintf(interp->result, "%g", GridAlign((double) y, grid)); ! 575: } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0) ! 576: && (length >= 3)) { ! 577: if (argc == 2) { ! 578: result = Tk_ConfigureInfo(interp, canvasPtr->tkwin, configSpecs, ! 579: (char *) canvasPtr, (char *) NULL, 0); ! 580: } else if (argc == 3) { ! 581: result = Tk_ConfigureInfo(interp, canvasPtr->tkwin, configSpecs, ! 582: (char *) canvasPtr, argv[2], 0); ! 583: } else { ! 584: result = ConfigureCanvas(interp, canvasPtr, argc-2, argv+2, ! 585: TK_CONFIG_ARGV_ONLY); ! 586: } ! 587: } else if ((c == 'c') && (strncmp(argv[1], "coords", length) == 0) ! 588: && (length >= 3)) { ! 589: if (argc < 3) { ! 590: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 591: argv[0], " coords tagOrId ?x y x y ...?\"", ! 592: (char *) NULL); ! 593: goto error; ! 594: } ! 595: itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 596: if (itemPtr != NULL) { ! 597: if (argc != 3) { ! 598: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 599: itemPtr->x2, itemPtr->y2); ! 600: } ! 601: if (itemPtr->typePtr->coordProc != NULL) { ! 602: result = (*itemPtr->typePtr->coordProc)(canvasPtr, itemPtr, ! 603: argc-3, argv+3); ! 604: } ! 605: if (argc != 3) { ! 606: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 607: itemPtr->x2, itemPtr->y2); ! 608: } ! 609: } ! 610: } else if ((c == 'c') && (strncmp(argv[1], "create", length) == 0) ! 611: && (length >= 2)) { ! 612: register Tk_ItemType *typePtr; ! 613: Tk_ItemType *matchPtr = NULL; ! 614: register Tk_Item *itemPtr; ! 615: ! 616: if (argc < 3) { ! 617: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 618: argv[0], " create type ?arg arg ...?\"", (char *) NULL); ! 619: goto error; ! 620: } ! 621: c = argv[2][0]; ! 622: length = strlen(argv[2]); ! 623: for (typePtr = typeList; typePtr != NULL; typePtr = typePtr->nextPtr) { ! 624: if ((c == typePtr->name[0]) ! 625: && (strncmp(argv[2], typePtr->name, length) == 0)) { ! 626: if (matchPtr != NULL) { ! 627: badType: ! 628: Tcl_AppendResult(interp, ! 629: "unknown or ambiguous item type \"", ! 630: argv[2], "\"", (char *) NULL); ! 631: goto error; ! 632: } ! 633: matchPtr = typePtr; ! 634: } ! 635: } ! 636: if (matchPtr == NULL) { ! 637: goto badType; ! 638: } ! 639: typePtr = matchPtr; ! 640: itemPtr = (Tk_Item *) ckalloc((unsigned) typePtr->itemSize); ! 641: itemPtr->id = canvasPtr->nextId; ! 642: canvasPtr->nextId++; ! 643: itemPtr->tagPtr = itemPtr->staticTagSpace; ! 644: itemPtr->tagSpace = TK_TAG_SPACE; ! 645: itemPtr->numTags = 0; ! 646: itemPtr->typePtr = typePtr; ! 647: if ((*typePtr->createProc)(canvasPtr, itemPtr, argc-3, argv+3) ! 648: != TCL_OK) { ! 649: ckfree((char *) itemPtr); ! 650: goto error; ! 651: } ! 652: itemPtr->nextPtr = NULL; ! 653: canvasPtr->hotPtr = itemPtr; ! 654: canvasPtr->hotPrevPtr = canvasPtr->lastItemPtr; ! 655: if (canvasPtr->lastItemPtr == NULL) { ! 656: canvasPtr->firstItemPtr = itemPtr; ! 657: } else { ! 658: canvasPtr->lastItemPtr->nextPtr = itemPtr; ! 659: } ! 660: canvasPtr->lastItemPtr = itemPtr; ! 661: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 662: itemPtr->x2, itemPtr->y2); ! 663: canvasPtr->flags |= REPICK_NEEDED; ! 664: sprintf(interp->result, "%d", itemPtr->id); ! 665: } else if ((c == 'c') && (strncmp(argv[1], "cursor", length) == 0) ! 666: && (length >= 2)) { ! 667: int index; ! 668: ! 669: if (argc != 4) { ! 670: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 671: argv[0], " cursor tagOrId index\"", ! 672: (char *) NULL); ! 673: goto error; ! 674: } ! 675: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 676: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 677: if ((itemPtr->typePtr->indexProc == NULL) ! 678: || (itemPtr->typePtr->cursorProc == NULL)) { ! 679: goto done; ! 680: } ! 681: if ((*itemPtr->typePtr->indexProc)(canvasPtr, itemPtr, ! 682: argv[3], &index) != TCL_OK) { ! 683: goto error; ! 684: } ! 685: (*itemPtr->typePtr->cursorProc)(canvasPtr, itemPtr, index); ! 686: if ((itemPtr == canvasPtr->focusItemPtr) ! 687: && (canvasPtr->flags & CURSOR_ON)) { ! 688: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 689: itemPtr->x2, itemPtr->y2); ! 690: } ! 691: } ! 692: } else if ((c == 'd') && (strncmp(argv[1], "dchars", length) == 0) ! 693: && (length >= 2)) { ! 694: int first, last; ! 695: ! 696: if ((argc != 4) && (argc != 5)) { ! 697: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 698: argv[0], " dchars tagOrId first ?last?\"", ! 699: (char *) NULL); ! 700: goto error; ! 701: } ! 702: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 703: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 704: if ((itemPtr->typePtr->indexProc == NULL) ! 705: || (itemPtr->typePtr->dCharsProc == NULL)) { ! 706: continue; ! 707: } ! 708: if ((*itemPtr->typePtr->indexProc)(canvasPtr, itemPtr, ! 709: argv[3], &first) != TCL_OK) { ! 710: goto error; ! 711: } ! 712: if (argc == 5) { ! 713: if ((*itemPtr->typePtr->indexProc)(canvasPtr, itemPtr, ! 714: argv[4], &last) != TCL_OK) { ! 715: goto error; ! 716: } ! 717: } else { ! 718: last = first; ! 719: } ! 720: ! 721: /* ! 722: * Redraw both item's old and new areas: it's possible ! 723: * that a delete could result in a new area larger than ! 724: * the old area. ! 725: */ ! 726: ! 727: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 728: itemPtr->x2, itemPtr->y2); ! 729: result = (*itemPtr->typePtr->dCharsProc)(canvasPtr, itemPtr, ! 730: first, last); ! 731: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 732: itemPtr->x2, itemPtr->y2); ! 733: if (result != TCL_OK) { ! 734: goto error; ! 735: } ! 736: } ! 737: } else if ((c == 'd') && (strncmp(argv[1], "delete", length) == 0) ! 738: && (length >= 2)) { ! 739: if (argc != 3) { ! 740: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 741: argv[0], " delete tagOrId\"", ! 742: (char *) NULL); ! 743: goto error; ! 744: } ! 745: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 746: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 747: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 748: itemPtr->x2, itemPtr->y2); ! 749: (*itemPtr->typePtr->deleteProc)(itemPtr); ! 750: if (itemPtr->tagPtr != itemPtr->staticTagSpace) { ! 751: ckfree((char *) itemPtr->tagPtr); ! 752: } ! 753: if (search.prevPtr == NULL) { ! 754: canvasPtr->firstItemPtr = itemPtr->nextPtr; ! 755: if (canvasPtr->firstItemPtr == NULL) { ! 756: canvasPtr->lastItemPtr = NULL; ! 757: } ! 758: } else { ! 759: search.prevPtr->nextPtr = itemPtr->nextPtr; ! 760: } ! 761: if (canvasPtr->lastItemPtr == itemPtr) { ! 762: canvasPtr->lastItemPtr = search.prevPtr; ! 763: } ! 764: ckfree((char *) itemPtr); ! 765: if (itemPtr == canvasPtr->currentItemPtr) { ! 766: canvasPtr->currentItemPtr = NULL; ! 767: canvasPtr->flags |= REPICK_NEEDED; ! 768: } ! 769: if (itemPtr == canvasPtr->focusItemPtr) { ! 770: canvasPtr->focusItemPtr = NULL; ! 771: } ! 772: if (itemPtr == canvasPtr->selItemPtr) { ! 773: canvasPtr->selItemPtr = NULL; ! 774: } ! 775: if ((itemPtr == canvasPtr->hotPtr) ! 776: || (itemPtr = canvasPtr->hotPrevPtr)) { ! 777: canvasPtr->hotPtr = NULL; ! 778: } ! 779: } ! 780: } else if ((c == 'd') && (strncmp(argv[1], "dtag", length) == 0) ! 781: && (length >= 2)) { ! 782: Tk_Uid tag; ! 783: int i; ! 784: ! 785: if ((argc != 3) && (argc != 4)) { ! 786: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 787: argv[0], " dtag tagOrId ?tagToDelete?\"", ! 788: (char *) NULL); ! 789: goto error; ! 790: } ! 791: if (argc == 4) { ! 792: tag = Tk_GetUid(argv[3]); ! 793: } else { ! 794: tag = Tk_GetUid(argv[2]); ! 795: } ! 796: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 797: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 798: for (i = itemPtr->numTags-1; i >= 0; i--) { ! 799: if (itemPtr->tagPtr[i] == tag) { ! 800: itemPtr->tagPtr[i] = itemPtr->tagPtr[itemPtr->numTags-1]; ! 801: itemPtr->numTags--; ! 802: } ! 803: } ! 804: } ! 805: } else if ((c == 'f') && (strncmp(argv[1], "find", length) == 0) ! 806: && (length >= 2)) { ! 807: if (argc < 3) { ! 808: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 809: argv[0], " find searchCommand ?arg arg ...?\"", ! 810: (char *) NULL); ! 811: goto error; ! 812: } ! 813: result = FindItems(interp, canvasPtr, argc-2, argv+2, (char *) NULL, ! 814: argv[0]," find"); ! 815: } else if ((c == 'f') && (strncmp(argv[1], "focus", length) == 0) ! 816: && (length >= 2)) { ! 817: if (argc > 3) { ! 818: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 819: argv[0], " focus ?tagOrId?\"", ! 820: (char *) NULL); ! 821: goto error; ! 822: } ! 823: itemPtr = canvasPtr->focusItemPtr; ! 824: if (argc == 2) { ! 825: if (itemPtr != NULL) { ! 826: sprintf(interp->result, "%d", itemPtr->id); ! 827: } ! 828: goto done; ! 829: } ! 830: if ((itemPtr != NULL) && (canvasPtr->flags & GOT_FOCUS)) { ! 831: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 832: itemPtr->x2, itemPtr->y2); ! 833: } ! 834: if (argv[2][0] == 0) { ! 835: canvasPtr->focusItemPtr = NULL; ! 836: goto done; ! 837: } ! 838: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 839: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 840: if (itemPtr->typePtr->cursorProc != NULL) { ! 841: break; ! 842: } ! 843: } ! 844: if (itemPtr == NULL) { ! 845: goto done; ! 846: } ! 847: canvasPtr->focusItemPtr = itemPtr; ! 848: if (canvasPtr->flags & GOT_FOCUS) { ! 849: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 850: itemPtr->x2, itemPtr->y2); ! 851: } ! 852: } else if ((c == 'g') && (strncmp(argv[1], "gettags", length) == 0)) { ! 853: if (argc != 3) { ! 854: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 855: argv[0], " gettags tagOrId\"", (char *) NULL); ! 856: goto error; ! 857: } ! 858: itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 859: if (itemPtr != NULL) { ! 860: int i; ! 861: for (i = 0; i < itemPtr->numTags; i++) { ! 862: Tcl_AppendElement(interp, (char *) itemPtr->tagPtr[i], 0); ! 863: } ! 864: } ! 865: } else if ((c == 'i') && (strncmp(argv[1], "index", length) == 0) ! 866: && (length >= 3)) { ! 867: int index; ! 868: ! 869: if (argc != 4) { ! 870: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 871: argv[0], " index tagOrId string\"", ! 872: (char *) NULL); ! 873: goto error; ! 874: } ! 875: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 876: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 877: if (itemPtr->typePtr->indexProc != NULL) { ! 878: break; ! 879: } ! 880: } ! 881: if (itemPtr == NULL) { ! 882: Tcl_AppendResult(interp, "can't find an indexable item \"", ! 883: argv[2], "\"", (char *) NULL); ! 884: goto error; ! 885: } ! 886: if ((*itemPtr->typePtr->indexProc)(canvasPtr, itemPtr, ! 887: argv[3], &index) != TCL_OK) { ! 888: goto error; ! 889: } ! 890: sprintf(interp->result, "%d", index); ! 891: } else if ((c == 'i') && (strncmp(argv[1], "insert", length) == 0) ! 892: && (length >= 3)) { ! 893: int beforeThis; ! 894: ! 895: if (argc != 5) { ! 896: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 897: argv[0], " insert tagOrId beforeThis string\"", ! 898: (char *) NULL); ! 899: goto error; ! 900: } ! 901: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 902: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 903: if ((itemPtr->typePtr->indexProc == NULL) ! 904: || (itemPtr->typePtr->insertProc == NULL)) { ! 905: continue; ! 906: } ! 907: if ((*itemPtr->typePtr->indexProc)(canvasPtr, itemPtr, ! 908: argv[3], &beforeThis) != TCL_OK) { ! 909: goto error; ! 910: } ! 911: ! 912: /* ! 913: * Redraw both item's old and new areas: it's possible ! 914: * that an insertion could result in a new area either ! 915: * larger or smaller than the old area. ! 916: */ ! 917: ! 918: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 919: itemPtr->x2, itemPtr->y2); ! 920: result = (*itemPtr->typePtr->insertProc)(canvasPtr, itemPtr, ! 921: beforeThis, argv[4]); ! 922: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 923: itemPtr->x2, itemPtr->y2); ! 924: if (result != TCL_OK) { ! 925: goto error; ! 926: } ! 927: } ! 928: } else if ((c == 'i') && (strncmp(argv[1], "itemconfigure", length) == 0) ! 929: && (length >= 2)) { ! 930: if (argc < 3) { ! 931: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 932: argv[0], " itemconfigure tagOrId ?option value ...?\"", ! 933: (char *) NULL); ! 934: goto error; ! 935: } ! 936: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 937: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 938: if (argc == 3) { ! 939: result = Tk_ConfigureInfo(canvasPtr->interp, canvasPtr->tkwin, ! 940: itemPtr->typePtr->configSpecs, (char *) itemPtr, ! 941: (char *) NULL, 0); ! 942: } else if (argc == 4) { ! 943: result = Tk_ConfigureInfo(canvasPtr->interp, canvasPtr->tkwin, ! 944: itemPtr->typePtr->configSpecs, (char *) itemPtr, ! 945: argv[3], 0); ! 946: } else { ! 947: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 948: itemPtr->x2, itemPtr->y2); ! 949: result = (*itemPtr->typePtr->configProc)(canvasPtr, itemPtr, ! 950: argc-3, argv+3, TK_CONFIG_ARGV_ONLY); ! 951: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 952: itemPtr->x2, itemPtr->y2); ! 953: canvasPtr->flags |= REPICK_NEEDED; ! 954: } ! 955: if ((result != TCL_OK) || (argc < 5)) { ! 956: break; ! 957: } ! 958: } ! 959: } else if ((c == 'l') && (strncmp(argv[1], "lower", length) == 0)) { ! 960: Tk_Item *prevPtr; ! 961: ! 962: if ((argc != 3) && (argc != 4)) { ! 963: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 964: argv[0], " lower tagOrId ?belowThis?\"", ! 965: (char *) NULL); ! 966: goto error; ! 967: } ! 968: ! 969: /* ! 970: * First find the item just after which we'll insert the ! 971: * named items. ! 972: */ ! 973: ! 974: if (argc == 3) { ! 975: prevPtr = NULL; ! 976: } else { ! 977: prevPtr = StartTagSearch(canvasPtr, argv[3], &search); ! 978: if (prevPtr != NULL) { ! 979: prevPtr = search.prevPtr; ! 980: } else { ! 981: Tcl_AppendResult(interp, "tag \"", argv[3], ! 982: "\" doesn't match any items", (char *) NULL); ! 983: goto error; ! 984: } ! 985: } ! 986: RelinkItems(canvasPtr, argv[2], prevPtr); ! 987: } else if ((c == 'm') && (strncmp(argv[1], "move", length) == 0)) { ! 988: double xAmount, yAmount; ! 989: ! 990: if (argc != 5) { ! 991: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 992: argv[0], " move tagOrId xAmount yAmount\"", ! 993: (char *) NULL); ! 994: goto error; ! 995: } ! 996: if ((TkGetCanvasCoord(canvasPtr, argv[3], &xAmount) != TCL_OK) ! 997: || (TkGetCanvasCoord(canvasPtr, argv[4], &yAmount) != TCL_OK)) { ! 998: goto error; ! 999: } ! 1000: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 1001: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 1002: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 1003: itemPtr->x2, itemPtr->y2); ! 1004: (void) (*itemPtr->typePtr->translateProc)(canvasPtr, itemPtr, ! 1005: xAmount, yAmount); ! 1006: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 1007: itemPtr->x2, itemPtr->y2); ! 1008: canvasPtr->flags |= REPICK_NEEDED; ! 1009: } ! 1010: } else if ((c == 'r') && (strncmp(argv[1], "raise", length) == 0)) { ! 1011: Tk_Item *prevPtr; ! 1012: ! 1013: if ((argc != 3) && (argc != 4)) { ! 1014: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1015: argv[0], " raise tagOrId ?aboveThis?\"", ! 1016: (char *) NULL); ! 1017: goto error; ! 1018: } ! 1019: ! 1020: /* ! 1021: * First find the item just after which we'll insert the ! 1022: * named items. ! 1023: */ ! 1024: ! 1025: if (argc == 3) { ! 1026: prevPtr = canvasPtr->lastItemPtr; ! 1027: } else { ! 1028: prevPtr = NULL; ! 1029: for (itemPtr = StartTagSearch(canvasPtr, argv[3], &search); ! 1030: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 1031: prevPtr = itemPtr; ! 1032: } ! 1033: if (prevPtr == NULL) { ! 1034: Tcl_AppendResult(interp, "tagOrId \"", argv[3], ! 1035: "\" doesn't match any items", (char *) NULL); ! 1036: goto error; ! 1037: } ! 1038: } ! 1039: RelinkItems(canvasPtr, argv[2], prevPtr); ! 1040: #if defined(USE_XPM3) ! 1041: } else if ((c == 's') && (strncmp(argv[1], "save", length) == 0) ! 1042: && (length >= 3)) { ! 1043: if (argc != 3 && argc != 7) { ! 1044: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1045: argv[0], " save fileName ?x y width height?\"", ! 1046: (char *) NULL); ! 1047: goto error; ! 1048: } ! 1049: if (argc == 3) { ! 1050: if (SaveCanvas(interp, canvasPtr, argv[2], 0, 0, 0, 0) != TCL_OK) { ! 1051: goto error; ! 1052: } ! 1053: } else { ! 1054: if (SaveCanvas(interp, canvasPtr, argv[2], atol(argv[3]), ! 1055: atol(argv[4]), atol(argv[5]), atol(argv[6]))) { ! 1056: goto error; ! 1057: } ! 1058: } ! 1059: #endif ! 1060: } else if ((c == 's') && (strncmp(argv[1], "scale", length) == 0) ! 1061: && (length >= 3)) { ! 1062: double xOrigin, yOrigin, xScale, yScale; ! 1063: ! 1064: if (argc != 7) { ! 1065: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1066: argv[0], " scale tagOrId xOrigin yOrigin xScale yScale\"", ! 1067: (char *) NULL); ! 1068: goto error; ! 1069: } ! 1070: if ((TkGetCanvasCoord(canvasPtr, argv[3], &xOrigin) != TCL_OK) ! 1071: || (TkGetCanvasCoord(canvasPtr, argv[4], &yOrigin) != TCL_OK) ! 1072: || (Tcl_GetDouble(interp, argv[5], &xScale) != TCL_OK) ! 1073: || (Tcl_GetDouble(interp, argv[6], &yScale) != TCL_OK)) { ! 1074: goto error; ! 1075: } ! 1076: if ((xScale <= 0.0) || (yScale <= 0.0)) { ! 1077: interp->result = "scale factors must be greater than zero"; ! 1078: goto error; ! 1079: } ! 1080: for (itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 1081: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 1082: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 1083: itemPtr->x2, itemPtr->y2); ! 1084: (void) (*itemPtr->typePtr->scaleProc)(canvasPtr, itemPtr, ! 1085: xOrigin, yOrigin, xScale, yScale); ! 1086: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 1087: itemPtr->x2, itemPtr->y2); ! 1088: canvasPtr->flags |= REPICK_NEEDED; ! 1089: } ! 1090: } else if ((c == 's') && (strncmp(argv[1], "scan", length) == 0) ! 1091: && (length >= 3)) { ! 1092: int x, y; ! 1093: ! 1094: if (argc != 5) { ! 1095: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1096: argv[0], " scan mark|dragto x y\"", (char *) NULL); ! 1097: goto error; ! 1098: } ! 1099: if ((Tcl_GetInt(interp, argv[3], &x) != TCL_OK) ! 1100: || (Tcl_GetInt(interp, argv[4], &y) != TCL_OK)){ ! 1101: goto error; ! 1102: } ! 1103: if ((argv[2][0] == 'm') ! 1104: && (strncmp(argv[2], "mark", strlen(argv[2])) == 0)) { ! 1105: canvasPtr->scanX = x; ! 1106: canvasPtr->scanXOrigin = canvasPtr->xOrigin; ! 1107: canvasPtr->scanY = y; ! 1108: canvasPtr->scanYOrigin = canvasPtr->yOrigin; ! 1109: } else if ((argv[2][0] == 'd') ! 1110: && (strncmp(argv[2], "dragto", strlen(argv[2])) == 0)) { ! 1111: int newXOrigin, newYOrigin, tmp; ! 1112: ! 1113: /* ! 1114: * Compute a new view origin for the canvas, amplifying the ! 1115: * mouse motion and rounding to the nearest multiple of the ! 1116: * scroll increment. ! 1117: */ ! 1118: ! 1119: tmp = canvasPtr->scanXOrigin - 10*(x - canvasPtr->scanX) ! 1120: - canvasPtr->scrollX1; ! 1121: if (tmp >= 0) { ! 1122: tmp = (tmp + canvasPtr->scrollIncrement/2) ! 1123: /canvasPtr->scrollIncrement; ! 1124: } else { ! 1125: tmp = -(((-tmp) + canvasPtr->scrollIncrement/2) ! 1126: /canvasPtr->scrollIncrement); ! 1127: } ! 1128: newXOrigin = canvasPtr->scrollX1 + tmp*canvasPtr->scrollIncrement; ! 1129: tmp = canvasPtr->scanYOrigin - 10*(y - canvasPtr->scanY) ! 1130: - canvasPtr->scrollY1; ! 1131: if (tmp >= 0) { ! 1132: tmp = (tmp + canvasPtr->scrollIncrement/2) ! 1133: /canvasPtr->scrollIncrement; ! 1134: } else { ! 1135: tmp = -(((-tmp) + canvasPtr->scrollIncrement/2) ! 1136: /canvasPtr->scrollIncrement); ! 1137: } ! 1138: newYOrigin = canvasPtr->scrollY1 + tmp*canvasPtr->scrollIncrement; ! 1139: CanvasSetOrigin(canvasPtr, newXOrigin, newYOrigin); ! 1140: } else { ! 1141: Tcl_AppendResult(interp, "bad scan option \"", argv[2], ! 1142: "\": must be mark or dragto", (char *) NULL); ! 1143: goto error; ! 1144: } ! 1145: } else if ((c == 's') && (strncmp(argv[1], "select", length) == 0) ! 1146: && (length >= 2)) { ! 1147: int index; ! 1148: ! 1149: if (argc < 3) { ! 1150: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1151: argv[0], " select option ?tagOrId? ?arg?\"", (char *) NULL); ! 1152: goto error; ! 1153: } ! 1154: if (argc >= 4) { ! 1155: for (itemPtr = StartTagSearch(canvasPtr, argv[3], &search); ! 1156: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 1157: if ((itemPtr->typePtr->indexProc != NULL) ! 1158: && (itemPtr->typePtr->selectionProc != NULL)){ ! 1159: break; ! 1160: } ! 1161: } ! 1162: if (itemPtr == NULL) { ! 1163: Tcl_AppendResult(interp, ! 1164: "can't find an indexable and selectable item \"", ! 1165: argv[3], "\"", (char *) NULL); ! 1166: goto error; ! 1167: } ! 1168: } ! 1169: if (argc == 5) { ! 1170: if ((*itemPtr->typePtr->indexProc)(canvasPtr, itemPtr, ! 1171: argv[4], &index) != TCL_OK) { ! 1172: goto error; ! 1173: } ! 1174: } ! 1175: length = strlen(argv[2]); ! 1176: c = argv[2][0]; ! 1177: if ((c == 'a') && (strncmp(argv[2], "adjust", length) == 0)) { ! 1178: if (argc != 5) { ! 1179: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1180: argv[0], " select adjust tagOrId index\"", ! 1181: (char *) NULL); ! 1182: goto error; ! 1183: } ! 1184: if (canvasPtr->selItemPtr == itemPtr) { ! 1185: if (index < (canvasPtr->selectFirst ! 1186: + canvasPtr->selectLast)/2) { ! 1187: canvasPtr->selectAnchor = canvasPtr->selectLast + 1; ! 1188: } else { ! 1189: canvasPtr->selectAnchor = canvasPtr->selectFirst; ! 1190: } ! 1191: } ! 1192: CanvasSelectTo(canvasPtr, itemPtr, index); ! 1193: } else if ((c == 'c') && (argv[2] != NULL) ! 1194: && (strncmp(argv[2], "clear", length) == 0)) { ! 1195: if (argc != 3) { ! 1196: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1197: argv[0], " select clear\"", (char *) NULL); ! 1198: goto error; ! 1199: } ! 1200: if (canvasPtr->selItemPtr != NULL) { ! 1201: EventuallyRedrawArea(canvasPtr, canvasPtr->selItemPtr->x1, ! 1202: canvasPtr->selItemPtr->y1, canvasPtr->selItemPtr->x2, ! 1203: canvasPtr->selItemPtr->y2); ! 1204: canvasPtr->selItemPtr = NULL; ! 1205: } ! 1206: goto done; ! 1207: } else if ((c == 'f') && (strncmp(argv[2], "from", length) == 0)) { ! 1208: if (argc != 5) { ! 1209: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1210: argv[0], " select from tagOrId index\"", ! 1211: (char *) NULL); ! 1212: goto error; ! 1213: } ! 1214: canvasPtr->anchorItemPtr = itemPtr; ! 1215: canvasPtr->selectAnchor = index; ! 1216: } else if ((c == 'i') && (strncmp(argv[2], "item", length) == 0)) { ! 1217: if (argc != 3) { ! 1218: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1219: argv[0], " select item\"", (char *) NULL); ! 1220: goto error; ! 1221: } ! 1222: if (canvasPtr->selItemPtr != NULL) { ! 1223: sprintf(interp->result, "%d", canvasPtr->selItemPtr->id); ! 1224: } ! 1225: } else if ((c == 't') && (strncmp(argv[2], "to", length) == 0)) { ! 1226: if (argc != 5) { ! 1227: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1228: argv[0], " select to tagOrId index\"", ! 1229: (char *) NULL); ! 1230: goto error; ! 1231: } ! 1232: CanvasSelectTo(canvasPtr, itemPtr, index); ! 1233: } else { ! 1234: Tcl_AppendResult(interp, "bad select option \"", argv[2], ! 1235: "\": must be adjust, clear, from, item, or to", ! 1236: (char *) NULL); ! 1237: goto error; ! 1238: } ! 1239: } else if ((c == 't') && (strncmp(argv[1], "type", length) == 0)) { ! 1240: if (argc != 3) { ! 1241: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1242: argv[0], " type tag\"", (char *) NULL); ! 1243: goto error; ! 1244: } ! 1245: itemPtr = StartTagSearch(canvasPtr, argv[2], &search); ! 1246: if (itemPtr != NULL) { ! 1247: interp->result = itemPtr->typePtr->name; ! 1248: } ! 1249: } else if ((c == 'x') && (strncmp(argv[1], "xview", length) == 0)) { ! 1250: int index; ! 1251: ! 1252: if (argc != 3) { ! 1253: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1254: argv[0], " xview index\"", (char *) NULL); ! 1255: goto error; ! 1256: } ! 1257: if (Tcl_GetInt(canvasPtr->interp, argv[2], &index) != TCL_OK) { ! 1258: goto error; ! 1259: } ! 1260: CanvasSetOrigin(canvasPtr, ! 1261: (canvasPtr->scrollX1 + index*canvasPtr->scrollIncrement), ! 1262: canvasPtr->yOrigin); ! 1263: } else if ((c == 'y') && (strncmp(argv[1], "yview", length) == 0)) { ! 1264: int index; ! 1265: ! 1266: if (argc != 3) { ! 1267: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 1268: argv[0], " yview index\"", (char *) NULL); ! 1269: goto error; ! 1270: } ! 1271: if (Tcl_GetInt(canvasPtr->interp, argv[2], &index) != TCL_OK) { ! 1272: goto error; ! 1273: } ! 1274: CanvasSetOrigin(canvasPtr, canvasPtr->xOrigin, ! 1275: (canvasPtr->scrollY1 + index*canvasPtr->scrollIncrement)); ! 1276: } else { ! 1277: Tcl_AppendResult(interp, "bad option \"", argv[1], ! 1278: "\": must be addtag, bbox, bind, ", ! 1279: "canvasx, canvasy, configure, coords, create, ", ! 1280: "cursor, dchars, delete, dtag, find, focus, ", ! 1281: "gettags, index, insert, itemconfigure, lower, ", ! 1282: "move, raise, scale, scan, select, type, xview, or yview", ! 1283: (char *) NULL); ! 1284: goto error; ! 1285: } ! 1286: done: ! 1287: Tk_Release((ClientData) canvasPtr); ! 1288: return result; ! 1289: ! 1290: error: ! 1291: Tk_Release((ClientData) canvasPtr); ! 1292: return TCL_ERROR; ! 1293: } ! 1294: ! 1295: /* ! 1296: *---------------------------------------------------------------------- ! 1297: * ! 1298: * DestroyCanvas -- ! 1299: * ! 1300: * This procedure is invoked by Tk_EventuallyFree or Tk_Release ! 1301: * to clean up the internal structure of a canvas at a safe time ! 1302: * (when no-one is using it anymore). ! 1303: * ! 1304: * Results: ! 1305: * None. ! 1306: * ! 1307: * Side effects: ! 1308: * Everything associated with the canvas is freed up. ! 1309: * ! 1310: *---------------------------------------------------------------------- ! 1311: */ ! 1312: ! 1313: static void ! 1314: DestroyCanvas(clientData) ! 1315: ClientData clientData; /* Info about canvas widget. */ ! 1316: { ! 1317: register Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 1318: register Tk_Item *itemPtr; ! 1319: ! 1320: for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL; ! 1321: itemPtr = canvasPtr->firstItemPtr) { ! 1322: canvasPtr->firstItemPtr = itemPtr->nextPtr; ! 1323: (*itemPtr->typePtr->deleteProc)(itemPtr); ! 1324: if (itemPtr->tagPtr != itemPtr->staticTagSpace) { ! 1325: ckfree((char *) itemPtr->tagPtr); ! 1326: } ! 1327: ckfree((char *) itemPtr); ! 1328: } ! 1329: ! 1330: if (canvasPtr->bgBorder != NULL) { ! 1331: Tk_Free3DBorder(canvasPtr->bgBorder); ! 1332: } ! 1333: if (canvasPtr->bgColor != NULL) { ! 1334: Tk_FreeColor(canvasPtr->bgColor); ! 1335: } ! 1336: if (canvasPtr->pixmapGC != None) { ! 1337: Tk_FreeGC(canvasPtr->pixmapGC); ! 1338: } ! 1339: if (canvasPtr->selBorder != NULL) { ! 1340: Tk_Free3DBorder(canvasPtr->selBorder); ! 1341: } ! 1342: if (canvasPtr->selFgColorPtr != NULL) { ! 1343: Tk_FreeColor(canvasPtr->selFgColorPtr); ! 1344: } ! 1345: if (canvasPtr->cursorBorder != NULL) { ! 1346: Tk_Free3DBorder(canvasPtr->cursorBorder); ! 1347: } ! 1348: Tk_DeleteTimerHandler(canvasPtr->cursorBlinkHandler); ! 1349: if (canvasPtr->bindingTable != NULL) { ! 1350: Tk_DeleteBindingTable(canvasPtr->bindingTable); ! 1351: } ! 1352: if (canvasPtr->xScrollCmd != NULL) { ! 1353: ckfree(canvasPtr->xScrollCmd); ! 1354: } ! 1355: if (canvasPtr->yScrollCmd != NULL) { ! 1356: ckfree(canvasPtr->yScrollCmd); ! 1357: } ! 1358: if (canvasPtr->regionString != NULL) { ! 1359: ckfree(canvasPtr->regionString); ! 1360: } ! 1361: if (canvasPtr->cursor != None) { ! 1362: Tk_FreeCursor(canvasPtr->cursor); ! 1363: } ! 1364: ckfree((char *) canvasPtr); ! 1365: } ! 1366: ! 1367: /* ! 1368: *---------------------------------------------------------------------- ! 1369: * ! 1370: * ConfigureCanvas -- ! 1371: * ! 1372: * This procedure is called to process an argv/argc list, plus ! 1373: * the Tk option database, in order to configure (or ! 1374: * reconfigure) a canvas widget. ! 1375: * ! 1376: * Results: ! 1377: * The return value is a standard Tcl result. If TCL_ERROR is ! 1378: * returned, then interp->result contains an error message. ! 1379: * ! 1380: * Side effects: ! 1381: * Configuration information, such as colors, border width, ! 1382: * etc. get set for canvasPtr; old resources get freed, ! 1383: * if there were any. ! 1384: * ! 1385: *---------------------------------------------------------------------- ! 1386: */ ! 1387: ! 1388: static int ! 1389: ConfigureCanvas(interp, canvasPtr, argc, argv, flags) ! 1390: Tcl_Interp *interp; /* Used for error reporting. */ ! 1391: register Tk_Canvas *canvasPtr; /* Information about widget; may or may ! 1392: * not already have values for some fields. */ ! 1393: int argc; /* Number of valid entries in argv. */ ! 1394: char **argv; /* Arguments. */ ! 1395: int flags; /* Flags to pass to Tk_ConfigureWidget. */ ! 1396: { ! 1397: XGCValues gcValues; ! 1398: GC new; ! 1399: ! 1400: if (Tk_ConfigureWidget(interp, canvasPtr->tkwin, configSpecs, ! 1401: argc, argv, (char *) canvasPtr, flags) != TCL_OK) { ! 1402: return TCL_ERROR; ! 1403: } ! 1404: ! 1405: /* ! 1406: * A few options need special processing, such as setting the ! 1407: * background from a 3-D border and creating a GC for copying ! 1408: * bits to the screen. ! 1409: */ ! 1410: ! 1411: Tk_SetBackgroundFromBorder(canvasPtr->tkwin, canvasPtr->bgBorder); ! 1412: ! 1413: gcValues.function = GXcopy; ! 1414: gcValues.foreground = canvasPtr->bgColor->pixel; ! 1415: gcValues.graphics_exposures = False; ! 1416: new = Tk_GetGC(canvasPtr->tkwin, ! 1417: GCFunction|GCForeground|GCGraphicsExposures, &gcValues); ! 1418: if (canvasPtr->pixmapGC != None) { ! 1419: Tk_FreeGC(canvasPtr->pixmapGC); ! 1420: } ! 1421: canvasPtr->pixmapGC = new; ! 1422: ! 1423: /* ! 1424: * Reset the desired dimensions for the window. ! 1425: */ ! 1426: ! 1427: Tk_GeometryRequest(canvasPtr->tkwin, canvasPtr->width, canvasPtr->height); ! 1428: ! 1429: /* ! 1430: * Restart the cursor timing sequence in case the on-time or off-time ! 1431: * just changed. ! 1432: */ ! 1433: ! 1434: if (canvasPtr->flags & GOT_FOCUS) { ! 1435: CanvasFocusProc((ClientData) canvasPtr, 1); ! 1436: } ! 1437: ! 1438: /* ! 1439: * Recompute the scroll region. ! 1440: */ ! 1441: ! 1442: canvasPtr->scrollX1 = 0; ! 1443: canvasPtr->scrollY1 = 0; ! 1444: canvasPtr->scrollX2 = 0; ! 1445: canvasPtr->scrollY2 = 0; ! 1446: if (canvasPtr->regionString != NULL) { ! 1447: int argc2; ! 1448: char **argv2; ! 1449: ! 1450: if (Tcl_SplitList(canvasPtr->interp, canvasPtr->regionString, ! 1451: &argc2, &argv2) != TCL_OK) { ! 1452: return TCL_ERROR; ! 1453: } ! 1454: if (argc2 != 4) { ! 1455: badRegion: ! 1456: Tcl_AppendResult(interp, "bad scrollRegion \"", ! 1457: canvasPtr->regionString, "\"", (char *) NULL); ! 1458: ckfree(canvasPtr->regionString); ! 1459: ckfree((char *) argv2); ! 1460: canvasPtr->regionString = NULL; ! 1461: return TCL_ERROR; ! 1462: } ! 1463: if ((Tk_GetPixels(canvasPtr->interp, canvasPtr->tkwin, ! 1464: argv2[0], &canvasPtr->scrollX1) != TCL_OK) ! 1465: || (Tk_GetPixels(canvasPtr->interp, canvasPtr->tkwin, ! 1466: argv2[1], &canvasPtr->scrollY1) != TCL_OK) ! 1467: || (Tk_GetPixels(canvasPtr->interp, canvasPtr->tkwin, ! 1468: argv2[2], &canvasPtr->scrollX2) != TCL_OK) ! 1469: || (Tk_GetPixels(canvasPtr->interp, canvasPtr->tkwin, ! 1470: argv2[3], &canvasPtr->scrollY2) != TCL_OK)) { ! 1471: goto badRegion; ! 1472: } ! 1473: ckfree((char *) argv2); ! 1474: } ! 1475: ! 1476: /* ! 1477: * Reset the canvases origin (this is a no-op unless confine ! 1478: * mode has just been turned on or the scroll region has changed). ! 1479: */ ! 1480: ! 1481: CanvasSetOrigin(canvasPtr, canvasPtr->xOrigin, canvasPtr->yOrigin); ! 1482: canvasPtr->flags |= UPDATE_SCROLLBARS; ! 1483: EventuallyRedrawArea(canvasPtr, canvasPtr->xOrigin, canvasPtr->yOrigin, ! 1484: canvasPtr->xOrigin + Tk_Width(canvasPtr->tkwin), ! 1485: canvasPtr->yOrigin + Tk_Height(canvasPtr->tkwin)); ! 1486: return TCL_OK; ! 1487: } ! 1488: ! 1489: #if defined(USE_XPM3) ! 1490: //#include "xpmtk.h" ! 1491: #include <xpm.h> ! 1492: /* ! 1493: *-------------------------------------------------------------- ! 1494: * ! 1495: * SaveCanvas -- ! 1496: * ! 1497: * This procedure saves the contents of a canvas window. ! 1498: * ! 1499: * Results: ! 1500: * The return value is a standard Tcl result. If TCL_ERROR is ! 1501: * returned, then interp->result contains an error message. ! 1502: * ! 1503: * Side effects: ! 1504: * A pixmap is written to a file. ! 1505: * ! 1506: *-------------------------------------------------------------- ! 1507: */ ! 1508: ! 1509: static int ! 1510: SaveCanvas(interp, canvasPtr, fileName, x, y, width, height) ! 1511: Tcl_Interp *interp; /* Used for error reporting. */ ! 1512: register Tk_Canvas *canvasPtr; /* Information about widget */ ! 1513: char *fileName; /* the output file name. */ ! 1514: int x; /* upper left x coordinate. */ ! 1515: int y; /* upper left y coordinate. */ ! 1516: unsigned int width; /* width of pixmap area to save. */ ! 1517: unsigned int height; /* height of pixmap area to save. */ ! 1518: { ! 1519: register Tk_Window tkwin = canvasPtr->tkwin; ! 1520: register Tk_Item *itemPtr; ! 1521: Pixmap pixmap; ! 1522: Pixmap savePixmap; ! 1523: int screenX1, screenX2, screenY1, screenY2; ! 1524: XpmAttributes xpm_attributes; ! 1525: ! 1526: if (canvasPtr->tkwin == NULL) { ! 1527: return TCL_OK; ! 1528: } ! 1529: if (!Tk_IsMapped(tkwin)) { ! 1530: return TCL_OK; ! 1531: } ! 1532: if (!(fileName && *fileName)) { ! 1533: Tcl_ResetResult(interp); ! 1534: Tcl_AppendResult(interp, "no filename specified for canvas saving", ! 1535: (char *) NULL); ! 1536: return TCL_ERROR; ! 1537: } ! 1538: ! 1539: /* ! 1540: * Choose a new current item if that is needed (this could cause ! 1541: * event handlers to be invoked). ! 1542: */ ! 1543: ! 1544: while (canvasPtr->flags & REPICK_NEEDED) { ! 1545: Tk_Preserve((ClientData) canvasPtr); ! 1546: canvasPtr->flags &= ~REPICK_NEEDED; ! 1547: PickCurrentItem(canvasPtr, &canvasPtr->pickEvent); ! 1548: tkwin = canvasPtr->tkwin; ! 1549: Tk_Release((ClientData) canvasPtr); ! 1550: if (tkwin == NULL) { ! 1551: return TCL_OK; ! 1552: } ! 1553: } ! 1554: ! 1555: if(x == 0 && y == 0 && width == 0 && height == 0) { ! 1556: screenX1 = 0; ! 1557: screenY1 = 0; ! 1558: screenX2 = Tk_Width(tkwin); ! 1559: screenY2 = Tk_Height(tkwin); ! 1560: width = Tk_Width(tkwin); ! 1561: height = Tk_Height(tkwin); ! 1562: } else { ! 1563: if(width != 0 && height != 0) { ! 1564: screenX1 = x; ! 1565: screenY1 = y; ! 1566: screenX2 = x + width; ! 1567: screenY2 = y + height; ! 1568: } else { ! 1569: Tcl_ResetResult(interp); ! 1570: Tcl_AppendResult(interp, "no correct size specified for canvas saving", ! 1571: (char *) NULL); ! 1572: return TCL_ERROR; ! 1573: } ! 1574: } ! 1575: ! 1576: /* ! 1577: * Saving is done in a temporary pixmap that is allocated ! 1578: * here and freed at the end of the procedure. All drawing ! 1579: * is done to the pixmap, and the pixmap is saved to the ! 1580: * file at the end of the procedure. ! 1581: * ! 1582: * Some tricky points about the pixmap: ! 1583: * ! 1584: * 1. We only allocate a large enough pixmap to hold the ! 1585: * area that has to be saved. This saves time in ! 1586: * in the X server for large objects that cover much ! 1587: * more than the area being saved: only the area ! 1588: * of the pixmap will actually have to be saved. ! 1589: * 2. The origin of the pixmap is adjusted to an even multiple ! 1590: * of 32 bits. This is so that stipple patterns with a size ! 1591: * of 8 or 16 or 32 bits will always line up when information ! 1592: * is copied back to the screen. ! 1593: * 3. Some X servers (e.g. the one for DECstations) have troubles ! 1594: * with characters that overlap an edge of the pixmap (on the ! 1595: * DEC servers, as of 8/18/92, such characters are drawn one ! 1596: * pixel too far to the right). To handle this problem, ! 1597: * make the pixmap a bit larger than is absolutely needed ! 1598: * so that for normal-sized fonts the characters that ovelap ! 1599: * the edge of the pixmap will be outside the area we care ! 1600: * about. ! 1601: */ ! 1602: ! 1603: canvasPtr->drawableXOrigin = (screenX1 - 30) & ~0x1f; ! 1604: canvasPtr->drawableYOrigin = (screenY1 - 30) & ~0x1f; ! 1605: pixmap = XCreatePixmap(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1606: screenX2 + 30 - canvasPtr->drawableXOrigin, ! 1607: screenY2 + 30 - canvasPtr->drawableYOrigin, ! 1608: Tk_DefaultDepth(Tk_Screen(tkwin))); ! 1609: savePixmap = XCreatePixmap(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1610: width, height, Tk_DefaultDepth(Tk_Screen(tkwin))); ! 1611: ! 1612: /* ! 1613: * Clear the area to be redrawn. ! 1614: */ ! 1615: ! 1616: XFillRectangle(Tk_Display(tkwin), pixmap, canvasPtr->pixmapGC, ! 1617: screenX1 - canvasPtr->drawableXOrigin, ! 1618: screenY1 - canvasPtr->drawableYOrigin, ! 1619: (unsigned int) (screenX2 - screenX1), ! 1620: (unsigned int) (screenY2 - screenY1)); ! 1621: XFillRectangle(Tk_Display(tkwin), savePixmap, canvasPtr->pixmapGC, ! 1622: 0, 0, width, height); ! 1623: ! 1624: /* ! 1625: * Scan through the item list, redrawing those items that need it. ! 1626: * An item must be redraw if either (a) it intersects the smaller ! 1627: * on-screen area or (b) it intersects the full canvas area and its ! 1628: * type requests that it be redrawn always (e.g. so subwindows can ! 1629: * be unmapped when they move off-screen). ! 1630: */ ! 1631: ! 1632: for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL; ! 1633: itemPtr = itemPtr->nextPtr) { ! 1634: if ((itemPtr->x1 >= screenX2) ! 1635: || (itemPtr->y1 >= screenY2) ! 1636: || (itemPtr->x2 < screenX1) ! 1637: || (itemPtr->y2 < screenY1)) { ! 1638: if (!itemPtr->typePtr->alwaysRedraw ! 1639: || (itemPtr->x1 >= canvasPtr->redrawX2) ! 1640: || (itemPtr->y1 >= canvasPtr->redrawY2) ! 1641: || (itemPtr->x2 < canvasPtr->redrawX1) ! 1642: || (itemPtr->y2 < canvasPtr->redrawY1)) { ! 1643: continue; ! 1644: } ! 1645: } ! 1646: (*itemPtr->typePtr->displayProc)(canvasPtr, itemPtr, pixmap); ! 1647: } ! 1648: ! 1649: /* ! 1650: * Copy from the temporary pixmap to the save pixmap. ! 1651: */ ! 1652: ! 1653: XCopyArea(Tk_Display(tkwin), pixmap, savePixmap, ! 1654: canvasPtr->pixmapGC, ! 1655: screenX1 - canvasPtr->drawableXOrigin, ! 1656: screenY1 - canvasPtr->drawableYOrigin, ! 1657: screenX2 - screenX1, screenY2 - screenY1, 0, 0); ! 1658: ! 1659: /* ! 1660: * Save temporary pixmap. ! 1661: */ ! 1662: ! 1663: xpm_attributes.width = width; ! 1664: xpm_attributes.height = height; ! 1665: xpm_attributes.visual = Tk_DefaultVisual(Tk_Screen(tkwin)); ! 1666: xpm_attributes.colormap = Tk_DefaultColormap(Tk_Screen(tkwin)); ! 1667: xpm_attributes.valuemask = XpmSize | XpmVisual | XpmColormap; ! 1668: if(XpmWriteFileFromPixmap(Tk_Display(tkwin), fileName, ! 1669: savePixmap, (Pixmap) NULL, ! 1670: &xpm_attributes) != XpmSuccess) { ! 1671: XFreePixmap(Tk_Display(tkwin), pixmap); ! 1672: XFreePixmap(Tk_Display(tkwin), savePixmap); ! 1673: Tcl_ResetResult(interp); ! 1674: Tcl_AppendResult(interp, "could not save pixmap for canvas", ! 1675: (char *) NULL); ! 1676: return TCL_ERROR; ! 1677: } ! 1678: XFreePixmap(Tk_Display(tkwin), pixmap); ! 1679: XFreePixmap(Tk_Display(tkwin), savePixmap); ! 1680: ! 1681: return TCL_OK; ! 1682: } ! 1683: #endif ! 1684: ! 1685: /* ! 1686: *-------------------------------------------------------------- ! 1687: * ! 1688: * DisplayCanvas -- ! 1689: * ! 1690: * This procedure redraws the contents of a canvas window. ! 1691: * It is invoked as a do-when-idle handler, so it only runs ! 1692: * when there's nothing else for the application to do. ! 1693: * ! 1694: * Results: ! 1695: * None. ! 1696: * ! 1697: * Side effects: ! 1698: * Information appears on the screen. ! 1699: * ! 1700: *-------------------------------------------------------------- ! 1701: */ ! 1702: ! 1703: static void ! 1704: DisplayCanvas(clientData) ! 1705: ClientData clientData; /* Information about widget. */ ! 1706: { ! 1707: register Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 1708: register Tk_Window tkwin = canvasPtr->tkwin; ! 1709: register Tk_Item *itemPtr; ! 1710: Pixmap pixmap; ! 1711: int screenX1, screenX2, screenY1, screenY2; ! 1712: ! 1713: if (canvasPtr->tkwin == NULL) { ! 1714: return; ! 1715: } ! 1716: if (!Tk_IsMapped(tkwin)) { ! 1717: goto done; ! 1718: } ! 1719: ! 1720: /* ! 1721: * Choose a new current item if that is needed (this could cause ! 1722: * event handlers to be invoked). ! 1723: */ ! 1724: ! 1725: while (canvasPtr->flags & REPICK_NEEDED) { ! 1726: Tk_Preserve((ClientData) canvasPtr); ! 1727: canvasPtr->flags &= ~REPICK_NEEDED; ! 1728: PickCurrentItem(canvasPtr, &canvasPtr->pickEvent); ! 1729: tkwin = canvasPtr->tkwin; ! 1730: Tk_Release((ClientData) canvasPtr); ! 1731: if (tkwin == NULL) { ! 1732: return; ! 1733: } ! 1734: } ! 1735: ! 1736: /* ! 1737: * Compute the intersection between the area that needs redrawing ! 1738: * and the area that's visible on the screen. ! 1739: */ ! 1740: ! 1741: screenX1 = canvasPtr->xOrigin; ! 1742: screenY1 = canvasPtr->yOrigin; ! 1743: screenX2 = screenX1 + Tk_Width(tkwin); ! 1744: screenY2 = screenY1 + Tk_Height(tkwin); ! 1745: if (canvasPtr->redrawX1 > screenX1) { ! 1746: screenX1 = canvasPtr->redrawX1; ! 1747: } ! 1748: if (canvasPtr->redrawY1 > screenY1) { ! 1749: screenY1 = canvasPtr->redrawY1; ! 1750: } ! 1751: if (canvasPtr->redrawX2 < screenX2) { ! 1752: screenX2 = canvasPtr->redrawX2; ! 1753: } ! 1754: if (canvasPtr->redrawY2 < screenY2) { ! 1755: screenY2 = canvasPtr->redrawY2; ! 1756: } ! 1757: if ((screenX1 >= screenX2) || (screenY1 >= screenY2)) { ! 1758: goto done; ! 1759: } ! 1760: ! 1761: /* ! 1762: * Redrawing is done in a temporary pixmap that is allocated ! 1763: * here and freed at the end of the procedure. All drawing ! 1764: * is done to the pixmap, and the pixmap is copied to the ! 1765: * screen at the end of the procedure. The temporary pixmap ! 1766: * serves two purposes: ! 1767: * ! 1768: * 1. It provides a smoother visual effect (no clearing and ! 1769: * gradual redraw will be visible to users). ! 1770: * 2. It allows us to redraw only the objects that overlap ! 1771: * the redraw area. Otherwise incorrect results could ! 1772: * occur from redrawing things that stick outside of ! 1773: * the redraw area (we'd have to redraw everything in ! 1774: * order to make the overlaps look right). ! 1775: * ! 1776: * Some tricky points about the pixmap: ! 1777: * ! 1778: * 1. We only allocate a large enough pixmap to hold the ! 1779: * area that has to be redisplayed. This saves time in ! 1780: * in the X server for large objects that cover much ! 1781: * more than the area being redisplayed: only the area ! 1782: * of the pixmap will actually have to be redrawn. ! 1783: * 2. The origin of the pixmap is adjusted to an even multiple ! 1784: * of 32 bits. This is so that stipple patterns with a size ! 1785: * of 8 or 16 or 32 bits will always line up when information ! 1786: * is copied back to the screen. ! 1787: * 3. Some X servers (e.g. the one for DECstations) have troubles ! 1788: * with characters that overlap an edge of the pixmap (on the ! 1789: * DEC servers, as of 8/18/92, such characters are drawn one ! 1790: * pixel too far to the right). To handle this problem, ! 1791: * make the pixmap a bit larger than is absolutely needed ! 1792: * so that for normal-sized fonts the characters that ovelap ! 1793: * the edge of the pixmap will be outside the area we care ! 1794: * about. ! 1795: */ ! 1796: ! 1797: canvasPtr->drawableXOrigin = (screenX1 - 30) & ~0x1f; ! 1798: canvasPtr->drawableYOrigin = (screenY1 - 30) & ~0x1f; ! 1799: pixmap = XCreatePixmap(Tk_Display(tkwin), Tk_WindowId(tkwin), ! 1800: screenX2 + 30 - canvasPtr->drawableXOrigin, ! 1801: screenY2 + 30 - canvasPtr->drawableYOrigin, ! 1802: Tk_DefaultDepth(Tk_Screen(tkwin))); ! 1803: ! 1804: /* ! 1805: * Clear the area to be redrawn. ! 1806: */ ! 1807: ! 1808: XFillRectangle(Tk_Display(tkwin), pixmap, canvasPtr->pixmapGC, ! 1809: screenX1 - canvasPtr->drawableXOrigin, ! 1810: screenY1 - canvasPtr->drawableYOrigin, ! 1811: (unsigned int) (screenX2 - screenX1), ! 1812: (unsigned int) (screenY2 - screenY1)); ! 1813: ! 1814: /* ! 1815: * Scan through the item list, redrawing those items that need it. ! 1816: * An item must be redraw if either (a) it intersects the smaller ! 1817: * on-screen area or (b) it intersects the full canvas area and its ! 1818: * type requests that it be redrawn always (e.g. so subwindows can ! 1819: * be unmapped when they move off-screen). ! 1820: */ ! 1821: ! 1822: for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL; ! 1823: itemPtr = itemPtr->nextPtr) { ! 1824: if ((itemPtr->x1 >= screenX2) ! 1825: || (itemPtr->y1 >= screenY2) ! 1826: || (itemPtr->x2 < screenX1) ! 1827: || (itemPtr->y2 < screenY1)) { ! 1828: if (!itemPtr->typePtr->alwaysRedraw ! 1829: || (itemPtr->x1 >= canvasPtr->redrawX2) ! 1830: || (itemPtr->y1 >= canvasPtr->redrawY2) ! 1831: || (itemPtr->x2 < canvasPtr->redrawX1) ! 1832: || (itemPtr->y2 < canvasPtr->redrawY1)) { ! 1833: continue; ! 1834: } ! 1835: } ! 1836: (*itemPtr->typePtr->displayProc)(canvasPtr, itemPtr, pixmap); ! 1837: } ! 1838: ! 1839: /* ! 1840: * Draw the window border. ! 1841: */ ! 1842: ! 1843: if (canvasPtr->relief != TK_RELIEF_FLAT) { ! 1844: Tk_Draw3DRectangle(Tk_Display(tkwin), pixmap, ! 1845: canvasPtr->bgBorder, ! 1846: canvasPtr->xOrigin - canvasPtr->drawableXOrigin, ! 1847: canvasPtr->yOrigin - canvasPtr->drawableYOrigin, ! 1848: Tk_Width(tkwin), Tk_Height(tkwin), ! 1849: canvasPtr->borderWidth, canvasPtr->relief); ! 1850: } ! 1851: ! 1852: /* ! 1853: * Copy from the temporary pixmap to the screen, then free up ! 1854: * the temporary pixmap. ! 1855: */ ! 1856: ! 1857: XCopyArea(Tk_Display(tkwin), pixmap, Tk_WindowId(tkwin), ! 1858: canvasPtr->pixmapGC, ! 1859: screenX1 - canvasPtr->drawableXOrigin, ! 1860: screenY1 - canvasPtr->drawableYOrigin, ! 1861: screenX2 - screenX1, screenY2 - screenY1, ! 1862: screenX1 - canvasPtr->xOrigin, screenY1 - canvasPtr->yOrigin); ! 1863: XFreePixmap(Tk_Display(tkwin), pixmap); ! 1864: ! 1865: done: ! 1866: canvasPtr->flags &= ~REDRAW_PENDING; ! 1867: assert(canvasPtr->updateTimerToken != NULL); ! 1868: canvasPtr->updateTimerToken = NULL; ! 1869: if (canvasPtr->flags & UPDATE_SCROLLBARS) { ! 1870: CanvasUpdateScrollbars(canvasPtr); ! 1871: } ! 1872: } ! 1873: ! 1874: /* ! 1875: *-------------------------------------------------------------- ! 1876: * ! 1877: * CanvasEventProc -- ! 1878: * ! 1879: * This procedure is invoked by the Tk dispatcher for various ! 1880: * events on canvases. ! 1881: * ! 1882: * Results: ! 1883: * None. ! 1884: * ! 1885: * Side effects: ! 1886: * When the window gets deleted, internal structures get ! 1887: * cleaned up. When it gets exposed, it is redisplayed. ! 1888: * ! 1889: *-------------------------------------------------------------- ! 1890: */ ! 1891: ! 1892: static void ! 1893: CanvasEventProc(clientData, eventPtr) ! 1894: ClientData clientData; /* Information about window. */ ! 1895: XEvent *eventPtr; /* Information about event. */ ! 1896: { ! 1897: Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 1898: ! 1899: if (eventPtr->type == Expose) { ! 1900: int x, y; ! 1901: ! 1902: x = eventPtr->xexpose.x + canvasPtr->xOrigin; ! 1903: y = eventPtr->xexpose.y + canvasPtr->yOrigin; ! 1904: EventuallyRedrawArea(canvasPtr, x, y, x + eventPtr->xexpose.width, ! 1905: y + eventPtr->xexpose.height); ! 1906: } else if (eventPtr->type == DestroyNotify) { ! 1907: Tcl_DeleteCommand(canvasPtr->interp, Tk_PathName(canvasPtr->tkwin)); ! 1908: canvasPtr->tkwin = NULL; ! 1909: if (canvasPtr->flags & REDRAW_PENDING) { ! 1910: canvasPtr->flags &= ~REDRAW_PENDING; ! 1911: // Tk_CancelIdleCall(DisplayCanvas, (ClientData) canvasPtr); ! 1912: assert(canvasPtr->updateTimerToken != NULL); ! 1913: if (canvasPtr->updateTimerToken != NULL) { ! 1914: Tk_DeleteTimerHandler(canvasPtr->updateTimerToken); ! 1915: canvasPtr->updateTimerToken = 0; ! 1916: } ! 1917: } ! 1918: Tk_EventuallyFree((ClientData) canvasPtr, DestroyCanvas); ! 1919: } else if (eventPtr->type == ConfigureNotify) { ! 1920: canvasPtr->flags |= UPDATE_SCROLLBARS; ! 1921: ! 1922: /* ! 1923: * The call below is needed in order to recenter the canvas if ! 1924: * it's confined and its scroll region is smaller than the window. ! 1925: */ ! 1926: ! 1927: CanvasSetOrigin(canvasPtr, canvasPtr->xOrigin, canvasPtr->yOrigin); ! 1928: EventuallyRedrawArea(canvasPtr, 0, 0, Tk_Width(canvasPtr->tkwin), ! 1929: Tk_Height(canvasPtr->tkwin)); ! 1930: } ! 1931: } ! 1932: ! 1933: /* ! 1934: *-------------------------------------------------------------- ! 1935: * ! 1936: * EventuallyRedrawArea -- ! 1937: * ! 1938: * Arrange for part or all of a canvas widget to redrawn at ! 1939: * the next convenient time in the future. ! 1940: * ! 1941: * Results: ! 1942: * None. ! 1943: * ! 1944: * Side effects: ! 1945: * The screen will eventually be refreshed. ! 1946: * ! 1947: *-------------------------------------------------------------- ! 1948: */ ! 1949: ! 1950: static void ! 1951: EventuallyRedrawArea(canvasPtr, x1, y1, x2, y2) ! 1952: register Tk_Canvas *canvasPtr; /* Information about widget. */ ! 1953: int x1, y1; /* Upper left corner of area to ! 1954: * redraw. Pixels on edge are ! 1955: * redrawn. */ ! 1956: int x2, y2; /* Lower right corner of area to ! 1957: * redraw. Pixels on edge are ! 1958: * not redrawn. */ ! 1959: { ! 1960: if ((canvasPtr->tkwin == NULL) || !Tk_IsMapped(canvasPtr->tkwin)) { ! 1961: return; ! 1962: } ! 1963: if (canvasPtr->flags & REDRAW_PENDING) { ! 1964: if (x1 <= canvasPtr->redrawX1) { ! 1965: canvasPtr->redrawX1 = x1; ! 1966: } ! 1967: if (y1 <= canvasPtr->redrawY1) { ! 1968: canvasPtr->redrawY1 = y1; ! 1969: } ! 1970: if (x2 >= canvasPtr->redrawX2) { ! 1971: canvasPtr->redrawX2 = x2; ! 1972: } ! 1973: if (y2 >= canvasPtr->redrawY2) { ! 1974: canvasPtr->redrawY2 = y2; ! 1975: } ! 1976: } else { ! 1977: canvasPtr->redrawX1 = x1; ! 1978: canvasPtr->redrawY1 = y1; ! 1979: canvasPtr->redrawX2 = x2; ! 1980: canvasPtr->redrawY2 = y2; ! 1981: // Tk_DoWhenIdle(DisplayCanvas, (ClientData) canvasPtr); ! 1982: canvasPtr->flags |= REDRAW_PENDING; ! 1983: assert(canvasPtr->updateTimerToken == NULL); ! 1984: if (canvasPtr->updateTimerToken == 0) { ! 1985: canvasPtr->updateTimerToken = ! 1986: Tk_CreateTimerHandler( ! 1987: CanvasUpdateTime, ! 1988: DisplayCanvas, ! 1989: (ClientData) canvasPtr); ! 1990: } ! 1991: } ! 1992: } ! 1993: ! 1994: /* ! 1995: *-------------------------------------------------------------- ! 1996: * ! 1997: * Tk_CreateItemType -- ! 1998: * ! 1999: * This procedure may be invoked to add a new kind of canvas ! 2000: * element to the core item types supported by Tk. ! 2001: * ! 2002: * Results: ! 2003: * None. ! 2004: * ! 2005: * Side effects: ! 2006: * From now on, the new item type will be useable in canvas ! 2007: * widgets (e.g. typePtr->name can be used as the item type ! 2008: * in "create" widget commands). If there was already a ! 2009: * type with the same name as in typePtr, it is replaced with ! 2010: * the new type. ! 2011: * ! 2012: *-------------------------------------------------------------- ! 2013: */ ! 2014: ! 2015: void ! 2016: Tk_CreateItemType(typePtr) ! 2017: Tk_ItemType *typePtr; /* Information about item type; ! 2018: * storage must be statically ! 2019: * allocated (must live forever). */ ! 2020: { ! 2021: if (typeList == NULL) { ! 2022: InitCanvas(); ! 2023: } ! 2024: typePtr->nextPtr = typeList; ! 2025: typeList = typePtr; ! 2026: } ! 2027: ! 2028: /* ! 2029: *-------------------------------------------------------------- ! 2030: * ! 2031: * InitCanvas -- ! 2032: * ! 2033: * This procedure is invoked to perform once-only-ever ! 2034: * initialization for the module, such as setting up ! 2035: * the type table. ! 2036: * ! 2037: * Results: ! 2038: * None. ! 2039: * ! 2040: * Side effects: ! 2041: * None. ! 2042: * ! 2043: *-------------------------------------------------------------- ! 2044: */ ! 2045: ! 2046: static void ! 2047: InitCanvas() ! 2048: { ! 2049: if (typeList != NULL) { ! 2050: return; ! 2051: } ! 2052: typeList = &TkRectangleType; ! 2053: TkRectangleType.nextPtr = &TkTextType; ! 2054: TkTextType.nextPtr = &TkPolygonType; ! 2055: TkPolygonType.nextPtr = &TkOvalType; ! 2056: TkOvalType.nextPtr = &TkLineType; ! 2057: TkLineType.nextPtr = &TkWindowType; ! 2058: TkWindowType.nextPtr = &TkBitmapType; ! 2059: TkBitmapType.nextPtr = &TkArcType; ! 2060: TkArcType.nextPtr = NULL; ! 2061: allUid = Tk_GetUid("all"); ! 2062: currentUid = Tk_GetUid("current"); ! 2063: } ! 2064: ! 2065: /* ! 2066: *-------------------------------------------------------------- ! 2067: * ! 2068: * StartTagSearch -- ! 2069: * ! 2070: * This procedure is called to initiate an enumeration of ! 2071: * all items in a given canvas that contain a given tag. ! 2072: * ! 2073: * Results: ! 2074: * The return value is a pointer to the first item in ! 2075: * canvasPtr that matches tag, or NULL if there is no ! 2076: * such item. The information at *searchPtr is initialized ! 2077: * such that successive calls to NextItem will return ! 2078: * successive items that match tag. ! 2079: * ! 2080: * Side effects: ! 2081: * SearchPtr is linked into a list of searches in progress ! 2082: * on canvasPtr, so that elements can safely be deleted ! 2083: * while the search is in progress. EndTagSearch must be ! 2084: * called at the end of the search to unlink searchPtr from ! 2085: * this list. ! 2086: * ! 2087: *-------------------------------------------------------------- ! 2088: */ ! 2089: ! 2090: static Tk_Item * ! 2091: StartTagSearch(canvasPtr, tag, searchPtr) ! 2092: Tk_Canvas *canvasPtr; /* Canvas whose items are to be ! 2093: * searched. */ ! 2094: char *tag; /* String giving tag value. */ ! 2095: TagSearch *searchPtr; /* Record describing tag search; ! 2096: * will be initialized here. */ ! 2097: { ! 2098: int id; ! 2099: register Tk_Item *itemPtr, *prevPtr; ! 2100: register Tk_Uid *tagPtr; ! 2101: register Tk_Uid uid; ! 2102: register int count; ! 2103: ! 2104: /* ! 2105: * Initialize the search. ! 2106: */ ! 2107: ! 2108: searchPtr->canvasPtr = canvasPtr; ! 2109: searchPtr->searchOver = 0; ! 2110: ! 2111: /* ! 2112: * Find the first matching item in one of several ways. If the tag ! 2113: * is a number then it selects the single item with the matching ! 2114: * identifier. In this case see if the item being requested is the ! 2115: * hot item, in which case the search can be skipped. ! 2116: */ ! 2117: ! 2118: if (isdigit(*tag)) { ! 2119: char *end; ! 2120: ! 2121: numIdSearches++; ! 2122: id = strtoul(tag, &end, 0); ! 2123: if (*end == 0) { ! 2124: itemPtr = canvasPtr->hotPtr; ! 2125: prevPtr = canvasPtr->hotPrevPtr; ! 2126: if ((itemPtr == NULL) || (itemPtr->id != id) || (prevPtr == NULL) ! 2127: || (prevPtr->nextPtr != itemPtr)) { ! 2128: numSlowSearches++; ! 2129: for (prevPtr = NULL, itemPtr = canvasPtr->firstItemPtr; ! 2130: itemPtr != NULL; ! 2131: prevPtr = itemPtr, itemPtr = itemPtr->nextPtr) { ! 2132: if (itemPtr->id == id) { ! 2133: break; ! 2134: } ! 2135: } ! 2136: } ! 2137: searchPtr->prevPtr = prevPtr; ! 2138: searchPtr->searchOver = 1; ! 2139: canvasPtr->hotPtr = itemPtr; ! 2140: canvasPtr->hotPrevPtr = prevPtr; ! 2141: return itemPtr; ! 2142: } ! 2143: } ! 2144: ! 2145: searchPtr->tag = uid = Tk_GetUid(tag); ! 2146: if (uid == allUid) { ! 2147: ! 2148: /* ! 2149: * All items match. ! 2150: */ ! 2151: ! 2152: searchPtr->tag = NULL; ! 2153: searchPtr->prevPtr = NULL; ! 2154: searchPtr->currentPtr = canvasPtr->firstItemPtr; ! 2155: return canvasPtr->firstItemPtr; ! 2156: } ! 2157: ! 2158: /* ! 2159: * None of the above. Search for an item with a matching tag. ! 2160: */ ! 2161: ! 2162: for (prevPtr = NULL, itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL; ! 2163: prevPtr = itemPtr, itemPtr = itemPtr->nextPtr) { ! 2164: for (tagPtr = itemPtr->tagPtr, count = itemPtr->numTags; ! 2165: count > 0; tagPtr++, count--) { ! 2166: if (*tagPtr == uid) { ! 2167: searchPtr->prevPtr = prevPtr; ! 2168: searchPtr->currentPtr = itemPtr; ! 2169: return itemPtr; ! 2170: } ! 2171: } ! 2172: } ! 2173: searchPtr->prevPtr = prevPtr; ! 2174: searchPtr->searchOver = 1; ! 2175: return NULL; ! 2176: } ! 2177: ! 2178: /* ! 2179: *-------------------------------------------------------------- ! 2180: * ! 2181: * NextItem -- ! 2182: * ! 2183: * This procedure returns successive items that match a given ! 2184: * tag; it should be called only after StartTagSearch has been ! 2185: * used to begin a search. ! 2186: * ! 2187: * Results: ! 2188: * The return value is a pointer to the next item that matches ! 2189: * the tag specified to StartTagSearch, or NULL if no such ! 2190: * item exists. *SearchPtr is updated so that the next call ! 2191: * to this procedure will return the next item. ! 2192: * ! 2193: * Side effects: ! 2194: * None. ! 2195: * ! 2196: *-------------------------------------------------------------- ! 2197: */ ! 2198: ! 2199: static Tk_Item * ! 2200: NextItem(searchPtr) ! 2201: TagSearch *searchPtr; /* Record describing search in ! 2202: * progress. */ ! 2203: { ! 2204: register Tk_Item *itemPtr, *prevPtr; ! 2205: register int count; ! 2206: register Tk_Uid uid; ! 2207: register Tk_Uid *tagPtr; ! 2208: ! 2209: /* ! 2210: * Find next item in list (this may not actually be a suitable ! 2211: * one to return), and return if there are no items left. ! 2212: */ ! 2213: ! 2214: prevPtr = searchPtr->prevPtr; ! 2215: if (prevPtr == NULL) { ! 2216: itemPtr = searchPtr->canvasPtr->firstItemPtr; ! 2217: } else { ! 2218: itemPtr = prevPtr->nextPtr; ! 2219: } ! 2220: if ((itemPtr == NULL) || (searchPtr->searchOver)) { ! 2221: searchPtr->searchOver = 1; ! 2222: return NULL; ! 2223: } ! 2224: if (itemPtr != searchPtr->currentPtr) { ! 2225: /* ! 2226: * The structure of the list has changed. Probably the ! 2227: * previously-returned item was removed from the list. ! 2228: * In this case, don't advance prevPtr; just return ! 2229: * its new successor (i.e. do nothing here). ! 2230: */ ! 2231: } else { ! 2232: prevPtr = itemPtr; ! 2233: itemPtr = prevPtr->nextPtr; ! 2234: } ! 2235: ! 2236: /* ! 2237: * Handle special case of "all" search by returning next item. ! 2238: */ ! 2239: ! 2240: uid = searchPtr->tag; ! 2241: if (uid == NULL) { ! 2242: searchPtr->prevPtr = prevPtr; ! 2243: searchPtr->currentPtr = itemPtr; ! 2244: return itemPtr; ! 2245: } ! 2246: ! 2247: /* ! 2248: * Look for an item with a particular tag. ! 2249: */ ! 2250: ! 2251: for ( ; itemPtr != NULL; prevPtr = itemPtr, itemPtr = itemPtr->nextPtr) { ! 2252: for (tagPtr = itemPtr->tagPtr, count = itemPtr->numTags; ! 2253: count > 0; tagPtr++, count--) { ! 2254: if (*tagPtr == uid) { ! 2255: searchPtr->prevPtr = prevPtr; ! 2256: searchPtr->currentPtr = itemPtr; ! 2257: return itemPtr; ! 2258: } ! 2259: } ! 2260: } ! 2261: searchPtr->prevPtr = prevPtr; ! 2262: searchPtr->searchOver = 1; ! 2263: return NULL; ! 2264: } ! 2265: ! 2266: /* ! 2267: *-------------------------------------------------------------- ! 2268: * ! 2269: * DoItem -- ! 2270: * ! 2271: * This is a utility procedure called by FindItems. It ! 2272: * either adds itemPtr's id to the result forming in interp, ! 2273: * or it adds a new tag to itemPtr, depending on the value ! 2274: * of tag. ! 2275: * ! 2276: * Results: ! 2277: * None. ! 2278: * ! 2279: * Side effects: ! 2280: * If tag is NULL then itemPtr's id is added as a list element ! 2281: * to interp->result; otherwise tag is added to itemPtr's ! 2282: * list of tags. ! 2283: * ! 2284: *-------------------------------------------------------------- ! 2285: */ ! 2286: ! 2287: static void ! 2288: DoItem(interp, itemPtr, tag) ! 2289: Tcl_Interp *interp; /* Interpreter in which to (possibly) ! 2290: * record item id. */ ! 2291: register Tk_Item *itemPtr; /* Item to (possibly) modify. */ ! 2292: Tk_Uid tag; /* Tag to add to those already ! 2293: * present for item, or NULL. */ ! 2294: { ! 2295: register Tk_Uid *tagPtr; ! 2296: register int count; ! 2297: ! 2298: /* ! 2299: * Handle the "add-to-result" case and return, if appropriate. ! 2300: */ ! 2301: ! 2302: if (tag == NULL) { ! 2303: char msg[30]; ! 2304: sprintf(msg, "%d", itemPtr->id); ! 2305: Tcl_AppendElement(interp, msg, 0); ! 2306: return; ! 2307: } ! 2308: ! 2309: for (tagPtr = itemPtr->tagPtr, count = itemPtr->numTags; ! 2310: count > 0; tagPtr++, count--) { ! 2311: if (tag == *tagPtr) { ! 2312: return; ! 2313: } ! 2314: } ! 2315: ! 2316: /* ! 2317: * Grow the tag space if there's no more room left in the current ! 2318: * block. ! 2319: */ ! 2320: ! 2321: if (itemPtr->tagSpace == itemPtr->numTags) { ! 2322: Tk_Uid *newTagPtr; ! 2323: ! 2324: itemPtr->tagSpace += 5; ! 2325: newTagPtr = (Tk_Uid *) ckalloc((unsigned) ! 2326: (itemPtr->tagSpace * sizeof(Tk_Uid))); ! 2327: memcpy((VOID *) newTagPtr, (VOID *) itemPtr->tagPtr, ! 2328: (itemPtr->numTags * sizeof(Tk_Uid))); ! 2329: if (itemPtr->tagPtr != itemPtr->staticTagSpace) { ! 2330: ckfree((char *) itemPtr->tagPtr); ! 2331: } ! 2332: itemPtr->tagPtr = newTagPtr; ! 2333: tagPtr = &itemPtr->tagPtr[itemPtr->numTags]; ! 2334: } ! 2335: ! 2336: /* ! 2337: * Add in the new tag. ! 2338: */ ! 2339: ! 2340: *tagPtr = tag; ! 2341: itemPtr->numTags++; ! 2342: } ! 2343: ! 2344: /* ! 2345: *-------------------------------------------------------------- ! 2346: * ! 2347: * FindItems -- ! 2348: * ! 2349: * This procedure does all the work of implementing the ! 2350: * "find" and "addtag" options of the canvas widget command, ! 2351: * which locate items that have certain features (location, ! 2352: * tags, position in display list, etc.). ! 2353: * ! 2354: * Results: ! 2355: * A standard Tcl return value. If newTag is NULL, then a ! 2356: * list of ids from all the items that match argc/argv is ! 2357: * returned in interp->result. If newTag is NULL, then ! 2358: * the normal interp->result is an empty string. If an error ! 2359: * occurs, then interp->result will hold an error message. ! 2360: * ! 2361: * Side effects: ! 2362: * If newTag is non-NULL, then all the items that match the ! 2363: * information in argc/argv have that tag added to their ! 2364: * lists of tags. ! 2365: * ! 2366: *-------------------------------------------------------------- ! 2367: */ ! 2368: ! 2369: static int ! 2370: FindItems(interp, canvasPtr, argc, argv, newTag, cmdName, option) ! 2371: Tcl_Interp *interp; /* Interpreter for error reporting. */ ! 2372: Tk_Canvas *canvasPtr; /* Canvas whose items are to be ! 2373: * searched. */ ! 2374: int argc; /* Number of entries in argv. Must be ! 2375: * greater than zero. */ ! 2376: char **argv; /* Arguments that describe what items ! 2377: * to search for (see user doc on ! 2378: * "find" and "addtag" options). */ ! 2379: char *newTag; /* If non-NULL, gives new tag to set ! 2380: * on all found items; if NULL, then ! 2381: * ids of found items are returned ! 2382: * in interp->result. */ ! 2383: char *cmdName; /* Name of original Tcl command, for ! 2384: * use in error messages. */ ! 2385: char *option; /* For error messages: gives option ! 2386: * from Tcl command and other stuff ! 2387: * up to what's in argc/argv. */ ! 2388: { ! 2389: char c; ! 2390: int length; ! 2391: TagSearch search; ! 2392: register Tk_Item *itemPtr; ! 2393: Tk_Uid uid; ! 2394: ! 2395: if (newTag != NULL) { ! 2396: uid = Tk_GetUid(newTag); ! 2397: } else { ! 2398: uid = NULL; ! 2399: } ! 2400: c = argv[0][0]; ! 2401: length = strlen(argv[0]); ! 2402: if ((c == 'a') && (strncmp(argv[0], "above", length) == 0) ! 2403: && (length >= 2)) { ! 2404: Tk_Item *lastPtr = NULL; ! 2405: if (argc != 2) { ! 2406: Tcl_AppendResult(interp, "wrong # args: must be \"", ! 2407: cmdName, option, " above tagOrId", (char *) NULL); ! 2408: return TCL_ERROR; ! 2409: } ! 2410: for (itemPtr = StartTagSearch(canvasPtr, argv[1], &search); ! 2411: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 2412: lastPtr = itemPtr; ! 2413: } ! 2414: if ((lastPtr != NULL) && (lastPtr->nextPtr != NULL)) { ! 2415: DoItem(interp, lastPtr->nextPtr, uid); ! 2416: } ! 2417: } else if ((c == 'a') && (strncmp(argv[0], "all", length) == 0) ! 2418: && (length >= 2)) { ! 2419: if (argc != 1) { ! 2420: Tcl_AppendResult(interp, "wrong # args: must be \"", ! 2421: cmdName, option, " all", (char *) NULL); ! 2422: return TCL_ERROR; ! 2423: } ! 2424: ! 2425: for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL; ! 2426: itemPtr = itemPtr->nextPtr) { ! 2427: DoItem(interp, itemPtr, uid); ! 2428: } ! 2429: } else if ((c == 'b') && (strncmp(argv[0], "below", length) == 0)) { ! 2430: if (argc != 2) { ! 2431: Tcl_AppendResult(interp, "wrong # args: must be \"", ! 2432: cmdName, option, " below tagOrId", (char *) NULL); ! 2433: return TCL_ERROR; ! 2434: } ! 2435: itemPtr = StartTagSearch(canvasPtr, argv[1], &search); ! 2436: if (search.prevPtr != NULL) { ! 2437: DoItem(interp, search.prevPtr, uid); ! 2438: } ! 2439: } else if ((c == 'c') && (strncmp(argv[0], "closest", length) == 0)) { ! 2440: double closestDist; ! 2441: Tk_Item *startPtr, *closestPtr; ! 2442: double coords[2], halo; ! 2443: int x1, y1, x2, y2; ! 2444: ! 2445: if ((argc < 3) || (argc > 5)) { ! 2446: Tcl_AppendResult(interp, "wrong # args: must be \"", ! 2447: cmdName, option, " closest x y ?halo? ?start?", ! 2448: (char *) NULL); ! 2449: return TCL_ERROR; ! 2450: } ! 2451: if ((TkGetCanvasCoord(canvasPtr, argv[1], &coords[0]) != TCL_OK) ! 2452: || (TkGetCanvasCoord(canvasPtr, argv[2], &coords[1]) ! 2453: != TCL_OK)) { ! 2454: return TCL_ERROR; ! 2455: } ! 2456: if (argc > 3) { ! 2457: if (TkGetCanvasCoord(canvasPtr, argv[3], &halo) != TCL_OK) { ! 2458: return TCL_ERROR; ! 2459: } ! 2460: if (halo < 0.0) { ! 2461: Tcl_AppendResult(interp, "can't have negative halo value \"", ! 2462: argv[3], "\"", (char *) NULL); ! 2463: return TCL_ERROR; ! 2464: } ! 2465: } else { ! 2466: halo = 0.0; ! 2467: } ! 2468: ! 2469: /* ! 2470: * Find the item at which to start the search. ! 2471: */ ! 2472: ! 2473: startPtr = canvasPtr->firstItemPtr; ! 2474: if (argc == 5) { ! 2475: itemPtr = StartTagSearch(canvasPtr, argv[4], &search); ! 2476: if (itemPtr != NULL) { ! 2477: startPtr = itemPtr; ! 2478: } ! 2479: } ! 2480: ! 2481: /* ! 2482: * The code below is optimized so that it can eliminate most ! 2483: * items without having to call their item-specific procedures. ! 2484: * This is done by keeping a bounding box (x1, y1, x2, y2) that ! 2485: * an item's bbox must overlap if the item is to have any ! 2486: * chance of being closer than the closest so far. ! 2487: */ ! 2488: ! 2489: itemPtr = startPtr; ! 2490: if (itemPtr == NULL) { ! 2491: return TCL_OK; ! 2492: } ! 2493: closestDist = (*itemPtr->typePtr->pointProc)(canvasPtr, ! 2494: itemPtr, coords) - halo; ! 2495: if (closestDist < 0.0) { ! 2496: closestDist = 0.0; ! 2497: } ! 2498: while (1) { ! 2499: double newDist; ! 2500: ! 2501: /* ! 2502: * Update the bounding box using itemPtr, which is the ! 2503: * new closest item. ! 2504: */ ! 2505: ! 2506: x1 = (coords[0] - closestDist - halo - 1); ! 2507: y1 = (coords[1] - closestDist - halo - 1); ! 2508: x2 = (coords[0] + closestDist + halo + 1); ! 2509: y2 = (coords[1] + closestDist + halo + 1); ! 2510: closestPtr = itemPtr; ! 2511: ! 2512: /* ! 2513: * Search for an item that beats the current closest one. ! 2514: * Work circularly through the canvas's item list until ! 2515: * getting back to the starting item. ! 2516: */ ! 2517: ! 2518: while (1) { ! 2519: itemPtr = itemPtr->nextPtr; ! 2520: if (itemPtr == NULL) { ! 2521: itemPtr = canvasPtr->firstItemPtr; ! 2522: } ! 2523: if (itemPtr == startPtr) { ! 2524: DoItem(interp, closestPtr, uid); ! 2525: return TCL_OK; ! 2526: } ! 2527: if ((itemPtr->x1 >= x2) || (itemPtr->x2 <= x1) ! 2528: || (itemPtr->y1 >= y2) || (itemPtr->y2 <= y1)) { ! 2529: continue; ! 2530: } ! 2531: newDist = (*itemPtr->typePtr->pointProc)(canvasPtr, ! 2532: itemPtr, coords) - halo; ! 2533: if (newDist < 0.0) { ! 2534: newDist = 0.0; ! 2535: } ! 2536: if (newDist <= closestDist) { ! 2537: closestDist = newDist; ! 2538: break; ! 2539: } ! 2540: } ! 2541: } ! 2542: } else if ((c == 'e') && (strncmp(argv[0], "enclosed", length) == 0)) { ! 2543: if (argc != 5) { ! 2544: Tcl_AppendResult(interp, "wrong # args: must be \"", ! 2545: cmdName, option, " enclosed x1 y1 x2 y2", (char *) NULL); ! 2546: return TCL_ERROR; ! 2547: } ! 2548: return FindArea(interp, canvasPtr, argv+1, uid, 1); ! 2549: } else if ((c == 'o') && (strncmp(argv[0], "overlapping", length) == 0)) { ! 2550: if (argc != 5) { ! 2551: Tcl_AppendResult(interp, "wrong # args: must be \"", ! 2552: cmdName, option, " overlapping x1 y1 x2 y2", ! 2553: (char *) NULL); ! 2554: return TCL_ERROR; ! 2555: } ! 2556: return FindArea(interp, canvasPtr, argv+1, uid, 0); ! 2557: } else if ((c == 'w') && (strncmp(argv[0], "withtag", length) == 0)) { ! 2558: if (argc != 2) { ! 2559: Tcl_AppendResult(interp, "wrong # args: must be \"", ! 2560: cmdName, option, " withtag tagOrId", (char *) NULL); ! 2561: return TCL_ERROR; ! 2562: } ! 2563: for (itemPtr = StartTagSearch(canvasPtr, argv[1], &search); ! 2564: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 2565: DoItem(interp, itemPtr, uid); ! 2566: } ! 2567: } else { ! 2568: Tcl_AppendResult(interp, "bad search command \"", argv[0], ! 2569: "\": must be above, all, below, closest, enclosed, ", ! 2570: "overlapping, or withtag", (char *) NULL); ! 2571: return TCL_ERROR; ! 2572: } ! 2573: return TCL_OK; ! 2574: } ! 2575: ! 2576: /* ! 2577: *-------------------------------------------------------------- ! 2578: * ! 2579: * FindArea -- ! 2580: * ! 2581: * This procedure implements area searches for the "find" ! 2582: * and "addtag" options. ! 2583: * ! 2584: * Results: ! 2585: * A standard Tcl return value. If newTag is NULL, then a ! 2586: * list of ids from all the items overlapping or enclosed ! 2587: * by the rectangle given by argc is returned in interp->result. ! 2588: * If newTag is NULL, then the normal interp->result is an ! 2589: * empty string. If an error occurs, then interp->result will ! 2590: * hold an error message. ! 2591: * ! 2592: * Side effects: ! 2593: * If uid is non-NULL, then all the items overlapping ! 2594: * or enclosed by the area in argv have that tag added to ! 2595: * their lists of tags. ! 2596: * ! 2597: *-------------------------------------------------------------- ! 2598: */ ! 2599: ! 2600: static int ! 2601: FindArea(interp, canvasPtr, argv, uid, enclosed) ! 2602: Tcl_Interp *interp; /* Interpreter for error reporting ! 2603: * and result storing. */ ! 2604: Tk_Canvas *canvasPtr; /* Canvas whose items are to be ! 2605: * searched. */ ! 2606: char **argv; /* Array of four arguments that ! 2607: * give the coordinates of the ! 2608: * rectangular area to search. */ ! 2609: Tk_Uid uid; /* If non-NULL, gives new tag to set ! 2610: * on all found items; if NULL, then ! 2611: * ids of found items are returned ! 2612: * in interp->result. */ ! 2613: int enclosed; /* 0 means overlapping or enclosed ! 2614: * items are OK, 1 means only enclosed ! 2615: * items are OK. */ ! 2616: { ! 2617: double rect[4], tmp; ! 2618: int x1, y1, x2, y2; ! 2619: register Tk_Item *itemPtr; ! 2620: ! 2621: if ((TkGetCanvasCoord(canvasPtr, argv[0], &rect[0]) != TCL_OK) ! 2622: || (TkGetCanvasCoord(canvasPtr, argv[1], &rect[1]) != TCL_OK) ! 2623: || (TkGetCanvasCoord(canvasPtr, argv[2], &rect[2]) != TCL_OK) ! 2624: || (TkGetCanvasCoord(canvasPtr, argv[3], &rect[3]) != TCL_OK)) { ! 2625: return TCL_ERROR; ! 2626: } ! 2627: if (rect[0] > rect[2]) { ! 2628: tmp = rect[0]; rect[0] = rect[2]; rect[2] = tmp; ! 2629: } ! 2630: if (rect[1] > rect[3]) { ! 2631: tmp = rect[1]; rect[1] = rect[3]; rect[3] = tmp; ! 2632: } ! 2633: ! 2634: /* ! 2635: * Use an integer bounding box for a quick test, to avoid ! 2636: * calling item-specific code except for items that are close. ! 2637: */ ! 2638: ! 2639: x1 = (rect[0]-1.0); ! 2640: y1 = (rect[1]-1.0); ! 2641: x2 = (rect[2]+1.0); ! 2642: y2 = (rect[3]+1.0); ! 2643: for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL; ! 2644: itemPtr = itemPtr->nextPtr) { ! 2645: if ((itemPtr->x1 >= x2) || (itemPtr->x2 <= x1) ! 2646: || (itemPtr->y1 >= y2) || (itemPtr->y2 <= y1)) { ! 2647: continue; ! 2648: } ! 2649: if ((*itemPtr->typePtr->areaProc)(canvasPtr, itemPtr, rect) ! 2650: >= enclosed) { ! 2651: DoItem(interp, itemPtr, uid); ! 2652: } ! 2653: } ! 2654: return TCL_OK; ! 2655: } ! 2656: ! 2657: /* ! 2658: *-------------------------------------------------------------- ! 2659: * ! 2660: * RelinkItems -- ! 2661: * ! 2662: * Move one or more items to a different place in the ! 2663: * display order for a canvas. ! 2664: * ! 2665: * Results: ! 2666: * None. ! 2667: * ! 2668: * Side effects: ! 2669: * The items identified by "tag" are moved so that they ! 2670: * are all together in the display list and immediately ! 2671: * after prevPtr. The order of the moved items relative ! 2672: * to each other is not changed. ! 2673: * ! 2674: *-------------------------------------------------------------- ! 2675: */ ! 2676: ! 2677: static void ! 2678: RelinkItems(canvasPtr, tag, prevPtr) ! 2679: Tk_Canvas *canvasPtr; /* Canvas to be modified. */ ! 2680: char *tag; /* Tag identifying items to be moved ! 2681: * in the redisplay list. */ ! 2682: Tk_Item *prevPtr; /* Reposition the items so that they ! 2683: * go just after this item (NULL means ! 2684: * put at beginning of list). */ ! 2685: { ! 2686: register Tk_Item *itemPtr; ! 2687: TagSearch search; ! 2688: Tk_Item *firstMovePtr, *lastMovePtr; ! 2689: ! 2690: /* ! 2691: * Find all of the items to be moved and remove them from ! 2692: * the list, making an auxiliary list running from firstMovePtr ! 2693: * to lastMovePtr. Record their areas for redisplay. ! 2694: */ ! 2695: ! 2696: firstMovePtr = lastMovePtr = NULL; ! 2697: for (itemPtr = StartTagSearch(canvasPtr, tag, &search); ! 2698: itemPtr != NULL; itemPtr = NextItem(&search)) { ! 2699: if (itemPtr == prevPtr) { ! 2700: /* ! 2701: * Item after which insertion is to occur is being ! 2702: * moved! Switch to insert after its predecessor. ! 2703: */ ! 2704: ! 2705: prevPtr = search.prevPtr; ! 2706: } ! 2707: if (search.prevPtr == NULL) { ! 2708: canvasPtr->firstItemPtr = itemPtr->nextPtr; ! 2709: } else { ! 2710: search.prevPtr->nextPtr = itemPtr->nextPtr; ! 2711: } ! 2712: if (canvasPtr->lastItemPtr == itemPtr) { ! 2713: canvasPtr->lastItemPtr = search.prevPtr; ! 2714: } ! 2715: if (firstMovePtr == NULL) { ! 2716: firstMovePtr = itemPtr; ! 2717: } else { ! 2718: lastMovePtr->nextPtr = itemPtr; ! 2719: } ! 2720: lastMovePtr = itemPtr; ! 2721: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 2722: itemPtr->x2, itemPtr->y2); ! 2723: canvasPtr->flags |= REPICK_NEEDED; ! 2724: } ! 2725: ! 2726: /* ! 2727: * Insert the list of to-be-moved items back into the canvas's ! 2728: * at the desired position. ! 2729: */ ! 2730: ! 2731: if (firstMovePtr == NULL) { ! 2732: return; ! 2733: } ! 2734: if (prevPtr == NULL) { ! 2735: lastMovePtr->nextPtr = canvasPtr->firstItemPtr; ! 2736: canvasPtr->firstItemPtr = firstMovePtr; ! 2737: } else { ! 2738: lastMovePtr->nextPtr = prevPtr->nextPtr; ! 2739: prevPtr->nextPtr = firstMovePtr; ! 2740: } ! 2741: if (canvasPtr->lastItemPtr == prevPtr) { ! 2742: canvasPtr->lastItemPtr = lastMovePtr; ! 2743: } ! 2744: } ! 2745: ! 2746: /* ! 2747: *-------------------------------------------------------------- ! 2748: * ! 2749: * CanvasBindProc -- ! 2750: * ! 2751: * This procedure is invoked by the Tk dispatcher to handle ! 2752: * events associated with bindings on items. ! 2753: * ! 2754: * Results: ! 2755: * None. ! 2756: * ! 2757: * Side effects: ! 2758: * Depends on the command invoked as part of the binding ! 2759: * (if there was any). ! 2760: * ! 2761: *-------------------------------------------------------------- ! 2762: */ ! 2763: ! 2764: static void ! 2765: CanvasBindProc(clientData, eventPtr) ! 2766: ClientData clientData; /* Pointer to canvas structure. */ ! 2767: XEvent *eventPtr; /* Pointer to X event that just ! 2768: * happened. */ ! 2769: { ! 2770: Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 2771: int repick = 0; ! 2772: ! 2773: Tk_Preserve((ClientData) canvasPtr); ! 2774: ! 2775: /* ! 2776: * This code simulates grabs for mouse buttons by refusing to ! 2777: * pick a new current item between the time a mouse button goes ! 2778: * down and the time when the last mouse button is released is ! 2779: * released again. ! 2780: */ ! 2781: ! 2782: if (eventPtr->type == ButtonPress) { ! 2783: canvasPtr->flags |= BUTTON_DOWN; ! 2784: } else if (eventPtr->type == ButtonRelease) { ! 2785: int mask; ! 2786: ! 2787: switch (eventPtr->xbutton.button) { ! 2788: case Button1: ! 2789: mask = Button1Mask; ! 2790: break; ! 2791: case Button2: ! 2792: mask = Button2Mask; ! 2793: break; ! 2794: case Button3: ! 2795: mask = Button3Mask; ! 2796: break; ! 2797: case Button4: ! 2798: mask = Button4Mask; ! 2799: break; ! 2800: case Button5: ! 2801: mask = Button5Mask; ! 2802: break; ! 2803: default: ! 2804: mask = 0; ! 2805: break; ! 2806: } ! 2807: if ((eventPtr->xbutton.state & (Button1Mask|Button2Mask ! 2808: |Button3Mask|Button4Mask|Button5Mask)) == mask) { ! 2809: canvasPtr->flags &= ~BUTTON_DOWN; ! 2810: repick = 1; ! 2811: } ! 2812: } else if ((eventPtr->type == EnterNotify) ! 2813: || (eventPtr->type == LeaveNotify)) { ! 2814: PickCurrentItem(canvasPtr, eventPtr); ! 2815: goto done; ! 2816: } else if (eventPtr->type == MotionNotify) { ! 2817: PickCurrentItem(canvasPtr, eventPtr); ! 2818: } ! 2819: CanvasDoEvent(canvasPtr, eventPtr); ! 2820: if (repick) { ! 2821: unsigned int oldState; ! 2822: ! 2823: oldState = eventPtr->xbutton.state; ! 2824: eventPtr->xbutton.state &= ~(Button1Mask|Button2Mask ! 2825: |Button3Mask|Button4Mask|Button5Mask); ! 2826: PickCurrentItem(canvasPtr, eventPtr); ! 2827: eventPtr->xbutton.state = oldState; ! 2828: } ! 2829: ! 2830: done: ! 2831: Tk_Release((ClientData) canvasPtr); ! 2832: } ! 2833: ! 2834: /* ! 2835: *-------------------------------------------------------------- ! 2836: * ! 2837: * PickCurrentItem -- ! 2838: * ! 2839: * Find the topmost item in a canvas that contains a given ! 2840: * location and mark the the current item. If the current ! 2841: * item has changed, generate a fake exit event on the old ! 2842: * current item and a fake enter event on the new current ! 2843: * item. ! 2844: * ! 2845: * Results: ! 2846: * None. ! 2847: * ! 2848: * Side effects: ! 2849: * The current item for canvasPtr may change. If it does, ! 2850: * then the commands associated with item entry and exit ! 2851: * could do just about anything. ! 2852: * ! 2853: *-------------------------------------------------------------- ! 2854: */ ! 2855: ! 2856: static void ! 2857: PickCurrentItem(canvasPtr, eventPtr) ! 2858: register Tk_Canvas *canvasPtr; /* Canvas pointer in which to select ! 2859: * current item. */ ! 2860: XEvent *eventPtr; /* Event describing location of ! 2861: * mouse cursor. Must be EnterWindow, ! 2862: * LeaveWindow, ButtonRelease, or ! 2863: * MotionNotify. */ ! 2864: { ! 2865: Tk_Item *closestPtr = NULL; ! 2866: ! 2867: /* ! 2868: * If a button is down, then don't do anything at all; we'll be ! 2869: * called again when all buttons are up, and we can repick then. ! 2870: * This implements a form of mouse grabbing for canvases. ! 2871: */ ! 2872: ! 2873: if (canvasPtr->flags & BUTTON_DOWN) { ! 2874: return; ! 2875: } ! 2876: ! 2877: /* ! 2878: * Save information about this event in the canvas. The event in ! 2879: * the canvas is used for two purposes: ! 2880: * ! 2881: * 1. Event bindings: if the current item changes, fake events are ! 2882: * generated to allow item-enter and item-leave bindings to trigger. ! 2883: * 2. Reselection: if the current item gets deleted, can use the ! 2884: * saved event to find a new current item. ! 2885: * Translate MotionNotify events into EnterNotify events, since that's ! 2886: * what gets reported to item handlers. ! 2887: */ ! 2888: ! 2889: if (eventPtr != &canvasPtr->pickEvent) { ! 2890: if ((eventPtr->type == MotionNotify) ! 2891: || (eventPtr->type == ButtonRelease)) { ! 2892: canvasPtr->pickEvent.xcrossing.type = EnterNotify; ! 2893: canvasPtr->pickEvent.xcrossing.serial = eventPtr->xmotion.serial; ! 2894: canvasPtr->pickEvent.xcrossing.send_event ! 2895: = eventPtr->xmotion.send_event; ! 2896: canvasPtr->pickEvent.xcrossing.display = eventPtr->xmotion.display; ! 2897: canvasPtr->pickEvent.xcrossing.window = eventPtr->xmotion.window; ! 2898: canvasPtr->pickEvent.xcrossing.root = eventPtr->xmotion.root; ! 2899: canvasPtr->pickEvent.xcrossing.subwindow = None; ! 2900: canvasPtr->pickEvent.xcrossing.time = eventPtr->xmotion.time; ! 2901: canvasPtr->pickEvent.xcrossing.x = eventPtr->xmotion.x; ! 2902: canvasPtr->pickEvent.xcrossing.y = eventPtr->xmotion.y; ! 2903: canvasPtr->pickEvent.xcrossing.x_root = eventPtr->xmotion.x_root; ! 2904: canvasPtr->pickEvent.xcrossing.y_root = eventPtr->xmotion.y_root; ! 2905: canvasPtr->pickEvent.xcrossing.mode = NotifyNormal; ! 2906: canvasPtr->pickEvent.xcrossing.detail = NotifyNonlinear; ! 2907: canvasPtr->pickEvent.xcrossing.same_screen ! 2908: = eventPtr->xmotion.same_screen; ! 2909: canvasPtr->pickEvent.xcrossing.focus = False; ! 2910: canvasPtr->pickEvent.xcrossing.state = eventPtr->xmotion.state; ! 2911: } else { ! 2912: canvasPtr->pickEvent = *eventPtr; ! 2913: } ! 2914: } ! 2915: ! 2916: /* ! 2917: * A LeaveNotify event automatically means that there's no current ! 2918: * object, so the rest of the code below can be skipped. ! 2919: */ ! 2920: ! 2921: if (canvasPtr->pickEvent.type != LeaveNotify) { ! 2922: int x1, y1, x2, y2; ! 2923: double coords[2]; ! 2924: register Tk_Item *itemPtr; ! 2925: ! 2926: coords[0] = canvasPtr->pickEvent.xcrossing.x + canvasPtr->xOrigin; ! 2927: coords[1] = canvasPtr->pickEvent.xcrossing.y + canvasPtr->yOrigin; ! 2928: x1 = coords[0] - canvasPtr->closeEnough; ! 2929: y1 = coords[1] - canvasPtr->closeEnough; ! 2930: x2 = coords[0] + canvasPtr->closeEnough; ! 2931: y2 = coords[1] + canvasPtr->closeEnough; ! 2932: ! 2933: for (itemPtr = canvasPtr->firstItemPtr; itemPtr != NULL; ! 2934: itemPtr = itemPtr->nextPtr) { ! 2935: if ((itemPtr->x1 >= x2) || (itemPtr->x2 < x1) ! 2936: || (itemPtr->y1 >= y2) || (itemPtr->y2 < y1)) { ! 2937: continue; ! 2938: } ! 2939: if ((*itemPtr->typePtr->pointProc)(canvasPtr, ! 2940: itemPtr, coords) <= canvasPtr->closeEnough) { ! 2941: closestPtr = itemPtr; ! 2942: } ! 2943: } ! 2944: } ! 2945: ! 2946: /* ! 2947: * Simulate a LeaveNotify event on the previous current item and ! 2948: * an EnterNotify event on the new current item. Remove the "current" ! 2949: * tag from the previous current item and place it on the new current ! 2950: * item. ! 2951: */ ! 2952: ! 2953: if (closestPtr == canvasPtr->currentItemPtr) { ! 2954: return; ! 2955: } ! 2956: if (canvasPtr->currentItemPtr != NULL) { ! 2957: XEvent event; ! 2958: Tk_Item *itemPtr = canvasPtr->currentItemPtr; ! 2959: int i; ! 2960: ! 2961: event = canvasPtr->pickEvent; ! 2962: event.type = LeaveNotify; ! 2963: CanvasDoEvent(canvasPtr, &event); ! 2964: for (i = itemPtr->numTags-1; i >= 0; i--) { ! 2965: if (itemPtr->tagPtr[i] == currentUid) { ! 2966: itemPtr->tagPtr[i] = itemPtr->tagPtr[itemPtr->numTags-1]; ! 2967: itemPtr->numTags--; ! 2968: break; ! 2969: } ! 2970: } ! 2971: } ! 2972: canvasPtr->currentItemPtr = closestPtr; ! 2973: if (canvasPtr->currentItemPtr != NULL) { ! 2974: XEvent event; ! 2975: ! 2976: DoItem((Tcl_Interp *) NULL, closestPtr, currentUid); ! 2977: event = canvasPtr->pickEvent; ! 2978: event.type = EnterNotify; ! 2979: CanvasDoEvent(canvasPtr, &event); ! 2980: } ! 2981: } ! 2982: ! 2983: /* ! 2984: *-------------------------------------------------------------- ! 2985: * ! 2986: * CanvasDoEvent -- ! 2987: * ! 2988: * This procedure is called to invoke binding processing ! 2989: * for a new event that is associated with the current item ! 2990: * for a canvas. ! 2991: * ! 2992: * Results: ! 2993: * None. ! 2994: * ! 2995: * Side effects: ! 2996: * Depends on the bindings for the canvas. ! 2997: * ! 2998: *-------------------------------------------------------------- ! 2999: */ ! 3000: ! 3001: static void ! 3002: CanvasDoEvent(canvasPtr, eventPtr) ! 3003: Tk_Canvas *canvasPtr; /* Canvas widget in which event ! 3004: * occurred. */ ! 3005: XEvent *eventPtr; /* Real or simulated X event that ! 3006: * is to be processed. */ ! 3007: { ! 3008: #define NUM_STATIC 3 ! 3009: ClientData staticObjects[NUM_STATIC]; ! 3010: ClientData *objectPtr; ! 3011: int numObjects, i; ! 3012: register Tk_Item *itemPtr; ! 3013: ! 3014: if (canvasPtr->bindingTable == NULL) { ! 3015: return; ! 3016: } ! 3017: ! 3018: itemPtr = canvasPtr->currentItemPtr; ! 3019: if ((eventPtr->type == KeyPress) || (eventPtr->type == KeyRelease)) { ! 3020: itemPtr = canvasPtr->focusItemPtr; ! 3021: } ! 3022: if (itemPtr == NULL) { ! 3023: return; ! 3024: } ! 3025: ! 3026: /* ! 3027: * Set up an array with all the relevant objects for processing ! 3028: * this event. The relevant objects are (a) the event's item, ! 3029: * (b) the tags associated with the event's item, and (c) the ! 3030: * tag "all". If there are a lot of tags then malloc an array ! 3031: * to hold all of the objects. ! 3032: */ ! 3033: ! 3034: numObjects = itemPtr->numTags + 2; ! 3035: if (numObjects <= NUM_STATIC) { ! 3036: objectPtr = staticObjects; ! 3037: } else { ! 3038: objectPtr = (ClientData *) ckalloc((unsigned) ! 3039: (numObjects * sizeof(ClientData))); ! 3040: } ! 3041: objectPtr[0] = (ClientData) itemPtr; ! 3042: for (i = itemPtr->numTags-1; i >= 0; i--) { ! 3043: objectPtr[i+1] = (ClientData) itemPtr->tagPtr[i]; ! 3044: } ! 3045: objectPtr[itemPtr->numTags+1] = (ClientData) allUid; ! 3046: ! 3047: /* ! 3048: * Invoke the binding system, then free up the object array if ! 3049: * it was malloc-ed. ! 3050: */ ! 3051: ! 3052: Tk_BindEvent(canvasPtr->bindingTable, eventPtr, canvasPtr->tkwin, ! 3053: numObjects, objectPtr); ! 3054: if (objectPtr != staticObjects) { ! 3055: ckfree((char *) objectPtr); ! 3056: } ! 3057: } ! 3058: ! 3059: /* ! 3060: *---------------------------------------------------------------------- ! 3061: * ! 3062: * CanvasBlinkProc -- ! 3063: * ! 3064: * This procedure is called as a timer handler to blink the ! 3065: * insertion cursor off and on. ! 3066: * ! 3067: * Results: ! 3068: * None. ! 3069: * ! 3070: * Side effects: ! 3071: * The cursor gets turned on or off, redisplay gets invoked, ! 3072: * and this procedure reschedules itself. ! 3073: * ! 3074: *---------------------------------------------------------------------- ! 3075: */ ! 3076: ! 3077: static void ! 3078: CanvasBlinkProc(clientData) ! 3079: ClientData clientData; /* Pointer to record describing entry. */ ! 3080: { ! 3081: register Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 3082: ! 3083: if (!(canvasPtr->flags & GOT_FOCUS) || (canvasPtr->cursorOffTime == 0)) { ! 3084: return; ! 3085: } ! 3086: if (canvasPtr->flags & CURSOR_ON) { ! 3087: canvasPtr->flags &= ~CURSOR_ON; ! 3088: canvasPtr->cursorBlinkHandler = Tk_CreateTimerHandler( ! 3089: canvasPtr->cursorOffTime, CanvasBlinkProc, ! 3090: (ClientData) canvasPtr); ! 3091: } else { ! 3092: canvasPtr->flags |= CURSOR_ON; ! 3093: canvasPtr->cursorBlinkHandler = Tk_CreateTimerHandler( ! 3094: canvasPtr->cursorOnTime, CanvasBlinkProc, ! 3095: (ClientData) canvasPtr); ! 3096: } ! 3097: if (canvasPtr->focusItemPtr != NULL) { ! 3098: EventuallyRedrawArea(canvasPtr, canvasPtr->focusItemPtr->x1, ! 3099: canvasPtr->focusItemPtr->y1, canvasPtr->focusItemPtr->x2, ! 3100: canvasPtr->focusItemPtr->y2); ! 3101: } ! 3102: } ! 3103: ! 3104: /* ! 3105: *---------------------------------------------------------------------- ! 3106: * ! 3107: * CanvasFocusProc -- ! 3108: * ! 3109: * This procedure is called whenever a canvas gets or loses the ! 3110: * input focus. It's also called whenever the window is ! 3111: * reconfigured while it has the focus. ! 3112: * ! 3113: * Results: ! 3114: * None. ! 3115: * ! 3116: * Side effects: ! 3117: * The cursor gets turned on or off. ! 3118: * ! 3119: *---------------------------------------------------------------------- ! 3120: */ ! 3121: ! 3122: static void ! 3123: CanvasFocusProc(clientData, gotFocus) ! 3124: ClientData clientData; /* Pointer to structure describing entry. */ ! 3125: int gotFocus; /* 1 means window is getting focus, 0 means ! 3126: * it's losing it. */ ! 3127: { ! 3128: register Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 3129: ! 3130: Tk_DeleteTimerHandler(canvasPtr->cursorBlinkHandler); ! 3131: if (gotFocus) { ! 3132: canvasPtr->flags |= GOT_FOCUS | CURSOR_ON; ! 3133: if (canvasPtr->cursorOffTime != 0) { ! 3134: canvasPtr->cursorBlinkHandler = Tk_CreateTimerHandler( ! 3135: canvasPtr->cursorOnTime, CanvasBlinkProc, ! 3136: (ClientData) canvasPtr); ! 3137: } ! 3138: } else { ! 3139: canvasPtr->flags &= ~(GOT_FOCUS | CURSOR_ON); ! 3140: canvasPtr->cursorBlinkHandler = (Tk_TimerToken) NULL; ! 3141: } ! 3142: if (canvasPtr->focusItemPtr != NULL) { ! 3143: EventuallyRedrawArea(canvasPtr, canvasPtr->focusItemPtr->x1, ! 3144: canvasPtr->focusItemPtr->y1, canvasPtr->focusItemPtr->x2, ! 3145: canvasPtr->focusItemPtr->y2); ! 3146: } ! 3147: } ! 3148: ! 3149: /* ! 3150: *---------------------------------------------------------------------- ! 3151: * ! 3152: * CanvasSelectTo -- ! 3153: * ! 3154: * Modify the selection by moving its un-anchored end. This could ! 3155: * make the selection either larger or smaller. ! 3156: * ! 3157: * Results: ! 3158: * None. ! 3159: * ! 3160: * Side effects: ! 3161: * The selection changes. ! 3162: * ! 3163: *---------------------------------------------------------------------- ! 3164: */ ! 3165: ! 3166: static void ! 3167: CanvasSelectTo(canvasPtr, itemPtr, index) ! 3168: register Tk_Canvas *canvasPtr; /* Information about widget. */ ! 3169: register Tk_Item *itemPtr; /* Item that is to hold selection. */ ! 3170: int index; /* Index of element that is to ! 3171: * become the "other" end of the ! 3172: * selection. */ ! 3173: { ! 3174: int oldFirst, oldLast; ! 3175: Tk_Item *oldSelPtr; ! 3176: ! 3177: oldFirst = canvasPtr->selectFirst; ! 3178: oldLast = canvasPtr->selectLast; ! 3179: oldSelPtr = canvasPtr->selItemPtr; ! 3180: ! 3181: /* ! 3182: * Grab the selection if we don't own it already. ! 3183: */ ! 3184: ! 3185: if (canvasPtr->selItemPtr == NULL) { ! 3186: Tk_OwnSelection(canvasPtr->tkwin, CanvasLostSelection, ! 3187: (ClientData) canvasPtr); ! 3188: } else if (canvasPtr->selItemPtr != itemPtr) { ! 3189: EventuallyRedrawArea(canvasPtr, canvasPtr->selItemPtr->x1, ! 3190: canvasPtr->selItemPtr->y1, canvasPtr->selItemPtr->x2, ! 3191: canvasPtr->selItemPtr->y2); ! 3192: } ! 3193: canvasPtr->selItemPtr = itemPtr; ! 3194: ! 3195: if (canvasPtr->anchorItemPtr != itemPtr) { ! 3196: canvasPtr->anchorItemPtr = itemPtr; ! 3197: canvasPtr->selectAnchor = index; ! 3198: } ! 3199: if (canvasPtr->selectAnchor <= index) { ! 3200: canvasPtr->selectFirst = canvasPtr->selectAnchor; ! 3201: canvasPtr->selectLast = index; ! 3202: } else { ! 3203: canvasPtr->selectFirst = index; ! 3204: canvasPtr->selectLast = canvasPtr->selectAnchor - 1; ! 3205: } ! 3206: if ((canvasPtr->selectFirst != oldFirst) ! 3207: || (canvasPtr->selectLast != oldLast) ! 3208: || (itemPtr != oldSelPtr)) { ! 3209: EventuallyRedrawArea(canvasPtr, itemPtr->x1, itemPtr->y1, ! 3210: itemPtr->x2, itemPtr->y2); ! 3211: } ! 3212: } ! 3213: ! 3214: /* ! 3215: *-------------------------------------------------------------- ! 3216: * ! 3217: * CanvasFetchSelection -- ! 3218: * ! 3219: * This procedure is invoked by Tk to return part or all of ! 3220: * the selection, when the selection is in a canvas widget. ! 3221: * This procedure always returns the selection as a STRING. ! 3222: * ! 3223: * Results: ! 3224: * The return value is the number of non-NULL bytes stored ! 3225: * at buffer. Buffer is filled (or partially filled) with a ! 3226: * NULL-terminated string containing part or all of the selection, ! 3227: * as given by offset and maxBytes. ! 3228: * ! 3229: * Side effects: ! 3230: * None. ! 3231: * ! 3232: *-------------------------------------------------------------- ! 3233: */ ! 3234: ! 3235: static int ! 3236: CanvasFetchSelection(clientData, offset, buffer, maxBytes) ! 3237: ClientData clientData; /* Information about canvas widget. */ ! 3238: int offset; /* Offset within selection of first ! 3239: * character to be returned. */ ! 3240: char *buffer; /* Location in which to place ! 3241: * selection. */ ! 3242: int maxBytes; /* Maximum number of bytes to place ! 3243: * at buffer, not including terminating ! 3244: * NULL character. */ ! 3245: { ! 3246: register Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 3247: ! 3248: if (canvasPtr->selItemPtr == NULL) { ! 3249: return -1; ! 3250: } ! 3251: if (canvasPtr->selItemPtr->typePtr->selectionProc == NULL) { ! 3252: return -1; ! 3253: } ! 3254: return (*canvasPtr->selItemPtr->typePtr->selectionProc)( ! 3255: canvasPtr, canvasPtr->selItemPtr, offset, buffer, maxBytes); ! 3256: } ! 3257: ! 3258: /* ! 3259: *---------------------------------------------------------------------- ! 3260: * ! 3261: * CanvasLostSelection -- ! 3262: * ! 3263: * This procedure is called back by Tk when the selection is ! 3264: * grabbed away from a canvas widget. ! 3265: * ! 3266: * Results: ! 3267: * None. ! 3268: * ! 3269: * Side effects: ! 3270: * The existing selection is unhighlighted, and the window is ! 3271: * marked as not containing a selection. ! 3272: * ! 3273: *---------------------------------------------------------------------- ! 3274: */ ! 3275: ! 3276: static void ! 3277: CanvasLostSelection(clientData) ! 3278: ClientData clientData; /* Information about entry widget. */ ! 3279: { ! 3280: Tk_Canvas *canvasPtr = (Tk_Canvas *) clientData; ! 3281: ! 3282: if (canvasPtr->selItemPtr != NULL) { ! 3283: EventuallyRedrawArea(canvasPtr, canvasPtr->selItemPtr->x1, ! 3284: canvasPtr->selItemPtr->y1, canvasPtr->selItemPtr->x2, ! 3285: canvasPtr->selItemPtr->y2); ! 3286: } ! 3287: canvasPtr->selItemPtr = NULL; ! 3288: } ! 3289: ! 3290: /* ! 3291: *-------------------------------------------------------------- ! 3292: * ! 3293: * TkGetCanvasCoord -- ! 3294: * ! 3295: * Given a string, returns a floating-point canvas coordinate ! 3296: * corresponding to that string. ! 3297: * ! 3298: * Results: ! 3299: * The return value is a standard Tcl return result. If ! 3300: * TCL_OK is returned, then everything went well and the ! 3301: * canvas coordinate is stored at *doublePtr; otherwise ! 3302: * TCL_ERROR is returned and an error message is left in ! 3303: * canvasPtr->interp->result. ! 3304: * ! 3305: * Side effects: ! 3306: * None. ! 3307: * ! 3308: *-------------------------------------------------------------- ! 3309: */ ! 3310: ! 3311: int ! 3312: TkGetCanvasCoord(canvasPtr, string, doublePtr) ! 3313: Tk_Canvas *canvasPtr; /* Canvas to which coordinate applies. */ ! 3314: char *string; /* Describes coordinate (any screen ! 3315: * coordinate form may be used here). */ ! 3316: double *doublePtr; /* Place to store converted coordinate. */ ! 3317: { ! 3318: if (Tk_GetScreenMM(canvasPtr->interp, canvasPtr->tkwin, string, ! 3319: doublePtr) != TCL_OK) { ! 3320: return TCL_ERROR; ! 3321: } ! 3322: *doublePtr *= canvasPtr->pixelsPerMM; ! 3323: return TCL_OK; ! 3324: } ! 3325: ! 3326: /* ! 3327: *-------------------------------------------------------------- ! 3328: * ! 3329: * GridAlign -- ! 3330: * ! 3331: * Given a coordinate and a grid spacing, this procedure ! 3332: * computes the location of the nearest grid line to the ! 3333: * coordinate. ! 3334: * ! 3335: * Results: ! 3336: * The return value is the location of the grid line nearest ! 3337: * to coord. ! 3338: * ! 3339: * Side effects: ! 3340: * None. ! 3341: * ! 3342: *-------------------------------------------------------------- ! 3343: */ ! 3344: ! 3345: static double ! 3346: GridAlign(coord, spacing) ! 3347: double coord; /* Coordinate to grid-align. */ ! 3348: double spacing; /* Spacing between grid lines. If <= 0 ! 3349: * then no alignment is done. */ ! 3350: { ! 3351: if (spacing <= 0.0) { ! 3352: return coord; ! 3353: } ! 3354: if (coord < 0) { ! 3355: return -((int) ((-coord)/spacing + 0.5)) * spacing; ! 3356: } ! 3357: return ((int) (coord/spacing + 0.5)) * spacing; ! 3358: } ! 3359: ! 3360: /* ! 3361: *-------------------------------------------------------------- ! 3362: * ! 3363: * CanvasUpdateScrollbars -- ! 3364: * ! 3365: * This procedure is invoked whenever a canvas has changed in ! 3366: * a way that requires scrollbars to be redisplayed (e.g. the ! 3367: * view in the canvas has changed). ! 3368: * ! 3369: * Results: ! 3370: * None. ! 3371: * ! 3372: * Side effects: ! 3373: * If there are scrollbars associated with the canvas, then ! 3374: * their scrolling commands are invoked to cause them to ! 3375: * redisplay. If errors occur, additional Tcl commands may ! 3376: * be invoked to process the errors. ! 3377: * ! 3378: *-------------------------------------------------------------- ! 3379: */ ! 3380: ! 3381: static void ! 3382: CanvasUpdateScrollbars(canvasPtr) ! 3383: register Tk_Canvas *canvasPtr; /* Information about canvas. */ ! 3384: { ! 3385: int result, size, first, last, page; ! 3386: char args[200]; ! 3387: ! 3388: #define ROUND(number) \ ! 3389: if (number >= 0) { \ ! 3390: number = (number + canvasPtr->scrollIncrement/2) \ ! 3391: /canvasPtr->scrollIncrement; \ ! 3392: } else { \ ! 3393: number = -(((-number) + canvasPtr->scrollIncrement/2) \ ! 3394: /canvasPtr->scrollIncrement); \ ! 3395: } ! 3396: ! 3397: canvasPtr->flags &= ~UPDATE_SCROLLBARS; ! 3398: if (canvasPtr->xScrollCmd != NULL) { ! 3399: size = ((canvasPtr->scrollX2 - canvasPtr->scrollX1) ! 3400: /canvasPtr->scrollIncrement) + 1; ! 3401: first = canvasPtr->xOrigin - canvasPtr->scrollX1; ! 3402: ROUND(first); ! 3403: last = canvasPtr->xOrigin + Tk_Width(canvasPtr->tkwin) ! 3404: - 1 - canvasPtr->scrollX1; ! 3405: ROUND(last); ! 3406: page = last - first - 1; ! 3407: if (page <= 0) { ! 3408: page = 1; ! 3409: } ! 3410: sprintf(args, " %d %d %d %d", size, page, first, last); ! 3411: result = Tcl_VarEval(canvasPtr->interp, canvasPtr->xScrollCmd, args, ! 3412: (char *) NULL); ! 3413: if (result != TCL_OK) { ! 3414: TkBindError(canvasPtr->interp); ! 3415: } ! 3416: Tcl_ResetResult(canvasPtr->interp); ! 3417: } ! 3418: ! 3419: if (canvasPtr->yScrollCmd != NULL) { ! 3420: size = ((canvasPtr->scrollY2 - canvasPtr->scrollY1) ! 3421: /canvasPtr->scrollIncrement) + 1; ! 3422: first = canvasPtr->yOrigin - canvasPtr->scrollY1; ! 3423: ROUND(first); ! 3424: last = canvasPtr->yOrigin + Tk_Height(canvasPtr->tkwin) ! 3425: - 1 - canvasPtr->scrollY1; ! 3426: ROUND(last); ! 3427: page = last - first - 1; ! 3428: if (page <= 0) { ! 3429: page = 1; ! 3430: } ! 3431: sprintf(args, " %d %d %d %d", size, page, first, last); ! 3432: result = Tcl_VarEval(canvasPtr->interp, canvasPtr->yScrollCmd, args, ! 3433: (char *) NULL); ! 3434: if (result != TCL_OK) { ! 3435: TkBindError(canvasPtr->interp); ! 3436: } ! 3437: Tcl_ResetResult(canvasPtr->interp); ! 3438: } ! 3439: } ! 3440: ! 3441: /* ! 3442: *-------------------------------------------------------------- ! 3443: * ! 3444: * CanvasSetOrigin -- ! 3445: * ! 3446: * This procedure is invoked to change the mapping between ! 3447: * canvas coordinates and screen coordinates in the canvas ! 3448: * window. ! 3449: * ! 3450: * Results: ! 3451: * None. ! 3452: * ! 3453: * Side effects: ! 3454: * The canvas will be redisplayed to reflect the change in ! 3455: * view. In addition, scrollbars will be updated if there ! 3456: * are any. ! 3457: * ! 3458: *-------------------------------------------------------------- ! 3459: */ ! 3460: ! 3461: static void ! 3462: CanvasSetOrigin(canvasPtr, xOrigin, yOrigin) ! 3463: register Tk_Canvas *canvasPtr; /* Information about canvas. */ ! 3464: int xOrigin; /* New X origin for canvas (canvas ! 3465: * x-coord corresponding to left edge ! 3466: * of canvas window). */ ! 3467: int yOrigin; /* New Y origin for canvas (canvas ! 3468: * y-coord corresponding to top edge ! 3469: * of canvas window). */ ! 3470: { ! 3471: /* ! 3472: * Adjust the origin if necessary to keep as much as possible of the ! 3473: * canvas in the view. ! 3474: */ ! 3475: ! 3476: if ((canvasPtr->confine) && (canvasPtr->regionString != NULL)) { ! 3477: int windowWidth, windowHeight, canvasWidth, canvasHeight; ! 3478: ! 3479: windowWidth = Tk_Width(canvasPtr->tkwin); ! 3480: windowHeight = Tk_Height(canvasPtr->tkwin); ! 3481: canvasWidth = canvasPtr->scrollX2 - canvasPtr->scrollX1; ! 3482: canvasHeight = canvasPtr->scrollY2 - canvasPtr->scrollY1; ! 3483: if (canvasWidth < windowWidth) { ! 3484: xOrigin = (canvasPtr->scrollX1) - (windowWidth-canvasWidth)/2; ! 3485: } else if (xOrigin < canvasPtr->scrollX1) { ! 3486: xOrigin = canvasPtr->scrollX1; ! 3487: } else if (xOrigin > (canvasPtr->scrollX2 - windowWidth)) { ! 3488: xOrigin = canvasPtr->scrollX2 - windowWidth; ! 3489: } ! 3490: if (canvasHeight < windowHeight) { ! 3491: yOrigin = (canvasPtr->scrollY1) - (windowHeight-canvasHeight)/2; ! 3492: } else if (yOrigin < canvasPtr->scrollY1) { ! 3493: yOrigin = canvasPtr->scrollY1; ! 3494: } else if (yOrigin > (canvasPtr->scrollY2 - windowHeight)) { ! 3495: yOrigin = canvasPtr->scrollY2 - windowHeight; ! 3496: } ! 3497: } ! 3498: ! 3499: if ((xOrigin == canvasPtr->xOrigin) && (yOrigin == canvasPtr->yOrigin)) { ! 3500: return; ! 3501: } ! 3502: ! 3503: /* ! 3504: * Tricky point: must redisplay not only everything that's visible ! 3505: * in the window's final configuration, but also everything that was ! 3506: * visible in the initial configuration. This is needed because some ! 3507: * item types, like windows, need to know when they move off-screen ! 3508: * so they can explicitly undisplay themselves. ! 3509: */ ! 3510: ! 3511: EventuallyRedrawArea(canvasPtr, canvasPtr->xOrigin, canvasPtr->yOrigin, ! 3512: canvasPtr->xOrigin + Tk_Width(canvasPtr->tkwin), ! 3513: canvasPtr->yOrigin + Tk_Height(canvasPtr->tkwin)); ! 3514: canvasPtr->xOrigin = xOrigin; ! 3515: canvasPtr->yOrigin = yOrigin; ! 3516: canvasPtr->flags |= UPDATE_SCROLLBARS; ! 3517: EventuallyRedrawArea(canvasPtr, canvasPtr->xOrigin, canvasPtr->yOrigin, ! 3518: canvasPtr->xOrigin + Tk_Width(canvasPtr->tkwin), ! 3519: canvasPtr->yOrigin + Tk_Height(canvasPtr->tkwin)); ! 3520: } ! 3521: ! 3522: /* ! 3523: *-------------------------------------------------------------- ! 3524: * ! 3525: * CanvasTagsParseProc -- ! 3526: * ! 3527: * This procedure is invoked during option processing to handle ! 3528: * "-tags" options for canvas items. ! 3529: * ! 3530: * Results: ! 3531: * A standard Tcl return value. ! 3532: * ! 3533: * Side effects: ! 3534: * The tags for a given item get replaced by those indicated ! 3535: * in the value argument. ! 3536: * ! 3537: *-------------------------------------------------------------- ! 3538: */ ! 3539: ! 3540: /* ARGSUSED */ ! 3541: static int ! 3542: CanvasTagsParseProc(clientData, interp, tkwin, value, widgRec, offset) ! 3543: ClientData clientData; /* Not used.*/ ! 3544: Tcl_Interp *interp; /* Used for reporting errors. */ ! 3545: Tk_Window tkwin; /* Window containing canvas widget. */ ! 3546: char *value; /* Value of option (list of tag ! 3547: * names). */ ! 3548: char *widgRec; /* Pointer to record for item. */ ! 3549: int offset; /* Offset into item (ignored). */ ! 3550: { ! 3551: register Tk_Item *itemPtr = (Tk_Item *) widgRec; ! 3552: int argc, i; ! 3553: char **argv; ! 3554: Tk_Uid *newPtr; ! 3555: ! 3556: /* ! 3557: * Break the value up into the individual tag names. ! 3558: */ ! 3559: ! 3560: if (Tcl_SplitList(interp, value, &argc, &argv) != TCL_OK) { ! 3561: return TCL_ERROR; ! 3562: } ! 3563: ! 3564: /* ! 3565: * Make sure that there's enough space in the item to hold the ! 3566: * tag names. ! 3567: */ ! 3568: ! 3569: if (itemPtr->tagSpace < argc) { ! 3570: newPtr = (Tk_Uid *) ckalloc((unsigned) (argc * sizeof(Tk_Uid))); ! 3571: for (i = itemPtr->numTags-1; i >= 0; i--) { ! 3572: newPtr[i] = itemPtr->tagPtr[i]; ! 3573: } ! 3574: if (itemPtr->tagPtr != itemPtr->staticTagSpace) { ! 3575: ckfree((char *) itemPtr->tagPtr); ! 3576: } ! 3577: itemPtr->tagPtr = newPtr; ! 3578: itemPtr->tagSpace = argc; ! 3579: } ! 3580: itemPtr->numTags = argc; ! 3581: for (i = 0; i < argc; i++) { ! 3582: itemPtr->tagPtr[i] = Tk_GetUid(argv[i]); ! 3583: } ! 3584: ckfree((char *) argv); ! 3585: return TCL_OK; ! 3586: } ! 3587: ! 3588: /* ! 3589: *-------------------------------------------------------------- ! 3590: * ! 3591: * CanvasTagsPrintProc -- ! 3592: * ! 3593: * This procedure is invoked by the Tk configuration code ! 3594: * to produce a printable string for the "-tags" configuration ! 3595: * option for canvas items. ! 3596: * ! 3597: * Results: ! 3598: * The return value is a string describing all the tags for ! 3599: * the item referred to by "widgRec". In addition, *freeProcPtr ! 3600: * is filled in with the address of a procedure to call to free ! 3601: * the result string when it's no longer needed (or NULL to ! 3602: * indicate that the string doesn't need to be freed). ! 3603: * ! 3604: * Side effects: ! 3605: * None. ! 3606: * ! 3607: *-------------------------------------------------------------- ! 3608: */ ! 3609: ! 3610: /* ARGSUSED */ ! 3611: static char * ! 3612: CanvasTagsPrintProc(clientData, tkwin, widgRec, offset, freeProcPtr) ! 3613: ClientData clientData; /* Ignored. */ ! 3614: Tk_Window tkwin; /* Window containing canvas widget. */ ! 3615: char *widgRec; /* Pointer to record for item. */ ! 3616: int offset; /* Ignored. */ ! 3617: Tcl_FreeProc **freeProcPtr; /* Pointer to variable to fill in with ! 3618: * information about how to reclaim ! 3619: * storage for return string. */ ! 3620: { ! 3621: register Tk_Item *itemPtr = (Tk_Item *) widgRec; ! 3622: ! 3623: if (itemPtr->numTags == 0) { ! 3624: *freeProcPtr = (Tcl_FreeProc *) NULL; ! 3625: return ""; ! 3626: } ! 3627: if (itemPtr->numTags == 1) { ! 3628: *freeProcPtr = (Tcl_FreeProc *) NULL; ! 3629: return (char *) itemPtr->tagPtr[0]; ! 3630: } ! 3631: *freeProcPtr = (Tcl_FreeProc *) free; ! 3632: return Tcl_Merge(itemPtr->numTags, (char **) itemPtr->tagPtr); ! 3633: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.