![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkgrab.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 tkgrab.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkGrab.c -- ! 3: * ! 4: * This file provides procedures that implement grabs for Tk. ! 5: * ! 6: * Copyright 1992 Regents of the University of California. ! 7: * Permission to use, copy, modify, and distribute this ! 8: * software and its documentation for any purpose and without ! 9: * fee is hereby granted, provided that the above copyright ! 10: * notice appear in all copies. The University of California ! 11: * makes no representations about the suitability of this ! 12: * software for any purpose. It is provided "as is" without ! 13: * express or implied warranty. ! 14: */ ! 15: ! 16: #ifndef lint ! 17: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkGrab.c,v 1.18 92/08/07 09:55:31 ouster Exp $ SPRITE (Berkeley)"; ! 18: #endif ! 19: ! 20: #include "tkconfig.h" ! 21: #include "tkint.h" ! 22: ! 23: /* ! 24: *------------------------------------------------------------------- ! 25: * Problems with current grab implementation (8/7/92): ! 26: * ! 27: * 1. In a local grab the synthesized events are always placed at the ! 28: * front of the event queue. If there are several grabs and ungrabs ! 29: * in a row, the groups of events for the different grabs/ungrabs ! 30: * end up in backwards order. ! 31: * 2. The variables serverWinPtr and pointerWinPtr are hardly used at ! 32: * all and should probably be eliminated. ! 33: * 3. The fact that grabWinPtr is set at the time a grab is set or ! 34: * released, rather than when its events are processed, means that ! 35: * it can get out of sync with the event queue if there's a rapid ! 36: * sequence of grabs or ungrabs. The only solution I can think of ! 37: * is to keep a parallel queue to the event queue to update grabWinPtr ! 38: * (or, synthesize an event to change the pointer?). ! 39: *------------------------------------------------------------------- ! 40: */ ! 41: ! 42: /* ! 43: * Bit definitions for grabFlags field of TkDisplay structures: ! 44: * ! 45: * GRAB_GLOBAL 1 means this is a global grab (we grabbed via ! 46: * the server so all applications are locked out. ! 47: * 0 means this is a local grab that affects ! 48: * only this application. ! 49: * GRAB_BUTTON_RELEASE 1 means that a button-release event just ! 50: * occurred and we're in the middle of a sequence ! 51: * of Enter and Leave events with NotifyUngrab ! 52: * mode. ! 53: */ ! 54: ! 55: #define GRAB_GLOBAL 1 ! 56: #define GRAB_BUTTON_RELEASE 2 ! 57: ! 58: /* ! 59: * Forward declarations for procedures declared later in this file: ! 60: */ ! 61: ! 62: static void ChangeEventWindow _ANSI_ARGS_((XEvent *eventPtr, ! 63: TkWindow *winPtr)); ! 64: static void MovePointer _ANSI_ARGS_((XEvent *eventPtr, ! 65: TkWindow *sourcePtr, TkWindow *destPtr)); ! 66: static void MovePointer2 _ANSI_ARGS_((TkWindow *sourcePtr, ! 67: TkWindow *destPtr, int mode)); ! 68: ! 69: /* ! 70: *---------------------------------------------------------------------- ! 71: * ! 72: * Tk_GrabCmd -- ! 73: * ! 74: * This procedure is invoked to process the "grab" Tcl command. ! 75: * See the user documentation for details on what it does. ! 76: * ! 77: * Results: ! 78: * A standard Tcl result. ! 79: * ! 80: * Side effects: ! 81: * See the user documentation. ! 82: * ! 83: *---------------------------------------------------------------------- ! 84: */ ! 85: ! 86: /* ARGSUSED */ ! 87: int ! 88: Tk_GrabCmd(clientData, interp, argc, argv) ! 89: ClientData clientData; /* Main window associated with ! 90: * interpreter. */ ! 91: Tcl_Interp *interp; /* Current interpreter. */ ! 92: int argc; /* Number of arguments. */ ! 93: char **argv; /* Argument strings. */ ! 94: { ! 95: TkWindow *winPtr = (TkWindow *) clientData; ! 96: int length, lockScreen; ! 97: char *window; ! 98: ! 99: if (argc > 3) { ! 100: badArgs: ! 101: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 102: argv[0], " ?-global? ?window?\"", (char *) NULL); ! 103: return TCL_ERROR; ! 104: } ! 105: if (argc == 1) { ! 106: if ((winPtr->dispPtr->grabWinPtr != NULL) ! 107: && (winPtr->dispPtr->grabWinPtr->mainPtr ! 108: == winPtr->mainPtr)) { ! 109: interp->result = Tk_PathName(winPtr->dispPtr->grabWinPtr); ! 110: } else { ! 111: interp->result = "none"; ! 112: } ! 113: return TCL_OK; ! 114: } ! 115: if (argc == 3) { ! 116: length = strlen(argv[1]); ! 117: if (strncmp(argv[1], "-off", length) == 0) { ! 118: lockScreen = -1; ! 119: } else { ! 120: if ((strncmp(argv[1], "-global", length) != 0) || (length < 2)) { ! 121: goto badArgs; ! 122: } ! 123: lockScreen = 1; ! 124: } ! 125: window = argv[2]; ! 126: } else { ! 127: lockScreen = 0; ! 128: window = argv[1]; ! 129: } ! 130: if ((window[0] == '\0') ! 131: || (strncmp(window, "none", strlen(window)) == 0)) { ! 132: Tk_Ungrab((Tk_Window) winPtr); ! 133: } else { ! 134: Tk_Window tkwin; ! 135: ! 136: tkwin = Tk_NameToWindow(interp, window, (Tk_Window) winPtr); ! 137: if (tkwin == NULL) { ! 138: return TCL_ERROR; ! 139: } ! 140: if (lockScreen < 0) { ! 141: Tk_Ungrab(tkwin); ! 142: } else { ! 143: return Tk_Grab(interp, tkwin, lockScreen); ! 144: } ! 145: } ! 146: return TCL_OK; ! 147: } ! 148: ! 149: /* ! 150: *---------------------------------------------------------------------- ! 151: * ! 152: * Tk_Grab -- ! 153: * ! 154: * Grabs the pointer and keyboard, so that mouse-related events are ! 155: * only reported relative to a given window and its descendants. ! 156: * ! 157: * Results: ! 158: * A standard Tcl result is returned. TCL_OK is the normal return ! 159: * value; if the grab could not be set then TCL_ERROR is returned ! 160: * and interp->result will hold an error message. ! 161: * ! 162: * Side effects: ! 163: * Once this call completes successfully, no window outside the ! 164: * tree rooted at tkwin will receive pointer- or keyboard-related ! 165: * events until the next call to Tk_Ungrab. If a previous grab was ! 166: * in effect within this application, then it is replaced with a new ! 167: * one. ! 168: * ! 169: *---------------------------------------------------------------------- ! 170: */ ! 171: ! 172: int ! 173: Tk_Grab(interp, tkwin, grabGlobal) ! 174: Tcl_Interp *interp; /* Used for error reporting. */ ! 175: Tk_Window tkwin; /* Window on whose behalf the pointer ! 176: * is to be grabbed. */ ! 177: int grabGlobal; /* Non-zero means issue a grab to the ! 178: * server so that no other application ! 179: * gets mouse or keyboard events. ! 180: * Zero means the grab only applies ! 181: * within this application. */ ! 182: { ! 183: int grabResult; ! 184: TkWindow *winPtr = (TkWindow *) tkwin; ! 185: TkDisplay *dispPtr = winPtr->dispPtr; ! 186: int grabRequest, inSequence, ignoring, numEvents, i, diff; ! 187: XEvent *events, *eventPtr; ! 188: TkWindow *winPtr2; ! 189: ! 190: if (dispPtr->grabWinPtr != NULL) { ! 191: if ((dispPtr->grabWinPtr == winPtr) ! 192: && (grabGlobal == ((dispPtr->grabFlags & GRAB_GLOBAL) != 0))) { ! 193: return TCL_OK; ! 194: } ! 195: if (dispPtr->grabWinPtr->mainPtr != winPtr->mainPtr) { ! 196: alreadyGrabbed: ! 197: interp->result = "grab failed: another application has grab"; ! 198: return TCL_ERROR; ! 199: } ! 200: Tk_Ungrab(tkwin); ! 201: } ! 202: ! 203: if (grabGlobal) { ! 204: grabRequest = NextRequest(dispPtr->display); ! 205: grabResult = XGrabPointer(dispPtr->display, Tk_WindowId(tkwin), ! 206: True, ButtonPressMask|ButtonReleaseMask|ButtonMotionMask|PointerMotionMask, ! 207: GrabModeAsync, GrabModeAsync, None, None, ! 208: TkCurrentTime(dispPtr)); ! 209: if (grabResult != 0) { ! 210: grabError: ! 211: if (grabResult == GrabNotViewable) { ! 212: interp->result = "grab failed: window not viewable"; ! 213: } else if (grabResult == AlreadyGrabbed) { ! 214: goto alreadyGrabbed; ! 215: } else if (grabResult == GrabFrozen) { ! 216: interp->result = "grab failed: keyboard or pointer frozen"; ! 217: } else if (grabResult == GrabInvalidTime) { ! 218: interp->result = "grab failed: invalid time"; ! 219: } else { ! 220: char msg[100]; ! 221: ! 222: sprintf(msg, "grab failed for unknown reason (code %d)", ! 223: grabResult); ! 224: Tcl_AppendResult(interp, msg, (char *) NULL); ! 225: } ! 226: return TCL_ERROR; ! 227: } ! 228: grabResult = XGrabKeyboard(dispPtr->display, Tk_WindowId(tkwin), ! 229: False, GrabModeAsync, GrabModeAsync, TkCurrentTime(dispPtr)); ! 230: if (grabResult != 0) { ! 231: XUngrabPointer(dispPtr->display, TkCurrentTime(dispPtr)); ! 232: goto grabError; ! 233: } ! 234: dispPtr->grabFlags |= GRAB_GLOBAL; ! 235: } else { ! 236: /* ! 237: * The call to XUngrabPointer below is needed to release any ! 238: * existing auto-grab due to a button press. This is needed ! 239: * so that local grabs behave the same as global grabs (the ! 240: * button grab is released by the X server in a global grab). ! 241: */ ! 242: ! 243: XUngrabPointer(dispPtr->display, TkCurrentTime(dispPtr)); ! 244: grabRequest = LastKnownRequestProcessed(dispPtr->display); ! 245: dispPtr->grabFlags &= ~GRAB_GLOBAL; ! 246: ! 247: /* ! 248: * Since we're not telling the server about the grab, we have ! 249: * to generate Leave and Enter events to move the pointer from ! 250: * its current window to the grab window. ! 251: */ ! 252: ! 253: MovePointer2(dispPtr->pointerWinPtr, winPtr, NotifyGrab); ! 254: } ! 255: dispPtr->grabWinPtr = winPtr; ! 256: ! 257: /* ! 258: * When a grab occurs, X generates Enter and Leave events to move ! 259: * the pointer from its current window to the grab window, even if ! 260: * the current window is in the grab tree. We don't want these ! 261: * events getting through to the application if the current window ! 262: * is in the grab tree. In order to eliminate the bogus events, ! 263: * process all pending events and filter out the bogus ones. ! 264: * ! 265: * Also, filter out the final enter event into the grab window in ! 266: * any case: this event shouldn't be delivered until the mouse really ! 267: * moves into that window. ! 268: * ! 269: * The code below reads in all the pending events, filters out the bad ! 270: * ones, and then pushes back all the events that weren't filtered. ! 271: * Another alternative would be to simply process the events ! 272: * immediately rather than pushing them back again. However, this ! 273: * tends to interfere with scripts since it causes pending events ! 274: * to be processed during the "grab" command. The "grab" command ! 275: * might have been invoked in the middle of some computation where ! 276: * it's a bad idea to process new events. ! 277: */ ! 278: ! 279: XSync(dispPtr->display, False); ! 280: numEvents = QLength(dispPtr->display); ! 281: if (numEvents == 0) { ! 282: return TCL_OK; ! 283: } ! 284: events = (XEvent *) ckalloc((unsigned) (numEvents * sizeof(XEvent))); ! 285: for (i = 0; i < numEvents; i++) { ! 286: XNextEvent(dispPtr->display, &events[i]); ! 287: } ! 288: inSequence = ignoring = 0; ! 289: for (i = numEvents-1, eventPtr = events; i >= 0; i--, eventPtr++) { ! 290: if (((eventPtr->type != EnterNotify) ! 291: && (eventPtr->type != LeaveNotify)) ! 292: || (eventPtr->xcrossing.mode != NotifyGrab)) { ! 293: continue; ! 294: } ! 295: ! 296: /* ! 297: * The diff caculcation below is trickier than you might think, ! 298: * due to the fact that the event serial number is unsigned and ! 299: * serial numbers can wrap around. ! 300: */ ! 301: ! 302: diff = eventPtr->xcrossing.serial; ! 303: diff -= grabRequest; ! 304: if (!inSequence && (diff >= 0)) { ! 305: /* ! 306: * This is the first event of the grab sequence. See if its ! 307: * window is in the grab tree and ignore the sequence if it is. ! 308: */ ! 309: ! 310: inSequence = 1; ! 311: if (XFindContext(dispPtr->display, eventPtr->xcrossing.window, ! 312: tkWindowContext, (void *) &winPtr2) == 0) { ! 313: for ( ; winPtr2 != NULL; winPtr2 = winPtr2->parentPtr) { ! 314: if (winPtr2 == dispPtr->grabWinPtr) { ! 315: ignoring = 1; ! 316: break; ! 317: } ! 318: } ! 319: } ! 320: } ! 321: if (ignoring) { ! 322: eventPtr->type = 0; ! 323: } ! 324: if (inSequence && (eventPtr->type == EnterNotify) ! 325: && (dispPtr->grabWinPtr->window ! 326: == eventPtr->xcrossing.window)) { ! 327: eventPtr->type = 0; ! 328: break; ! 329: } ! 330: } ! 331: for (i = numEvents-1, eventPtr = &events[i]; i >= 0; i--, eventPtr--) { ! 332: if (eventPtr->type != 0) { ! 333: XPutBackEvent(dispPtr->display, eventPtr); ! 334: } ! 335: } ! 336: ckfree((char *) events); ! 337: return TCL_OK; ! 338: } ! 339: ! 340: /* ! 341: *---------------------------------------------------------------------- ! 342: * ! 343: * Tk_Ungrab -- ! 344: * ! 345: * Releases a grab on the mouse pointer and keyboard. ! 346: * ! 347: * Results: ! 348: * None. ! 349: * ! 350: * Side effects: ! 351: * Pointer and keyboard events will start being delivered to other ! 352: * windows again. ! 353: * ! 354: *---------------------------------------------------------------------- ! 355: */ ! 356: ! 357: void ! 358: Tk_Ungrab(tkwin) ! 359: Tk_Window tkwin; /* Window that identifies display ! 360: * for grab to be released. */ ! 361: { ! 362: TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr; ! 363: int inSequence, ignoring, ungrabRequest, numEvents, i, j, diff; ! 364: TkWindow *grabWinPtr, *winPtr; ! 365: XEvent *events, *eventPtr, *eventPtr2; ! 366: ! 367: grabWinPtr = dispPtr->grabWinPtr; ! 368: if (grabWinPtr == NULL) { ! 369: return; ! 370: } ! 371: dispPtr->grabWinPtr = NULL; ! 372: dispPtr->buttonWinPtr = NULL; ! 373: if (dispPtr->grabFlags & GRAB_GLOBAL) { ! 374: ungrabRequest = NextRequest(dispPtr->display); ! 375: XUngrabPointer(dispPtr->display, TkCurrentTime(dispPtr)); ! 376: XUngrabKeyboard(dispPtr->display, TkCurrentTime(dispPtr)); ! 377: XSync(dispPtr->display, False); ! 378: } else { ! 379: ungrabRequest = LastKnownRequestProcessed(dispPtr->display); ! 380: if ((dispPtr->ungrabWinPtr != NULL) ! 381: && (dispPtr->ungrabWinPtr->mainPtr != grabWinPtr->mainPtr)) { ! 382: ! 383: /* ! 384: * Don't report entries down into a window of a different ! 385: * application, since it's already seen those entries earlier. ! 386: */ ! 387: ! 388: dispPtr->ungrabWinPtr = NULL; ! 389: } ! 390: MovePointer2(grabWinPtr, dispPtr->ungrabWinPtr, NotifyUngrab); ! 391: } ! 392: ! 393: /* ! 394: * We have to filter all the pending events in a fashion similar to ! 395: * Tk_Grab. As with grabs, the X server generates an Enter-Leave event ! 396: * sequence to move the pointer from the grab window back to its ! 397: * current window. We need to ignore this sequence if the pointer ! 398: * is being moved to a window that's already in the grab tree. ! 399: */ ! 400: ! 401: numEvents = QLength(dispPtr->display); ! 402: if (numEvents == 0) { ! 403: return; ! 404: } ! 405: events = (XEvent *) ckalloc((unsigned) (numEvents * sizeof(XEvent))); ! 406: for (i = 0; i < numEvents; i++) { ! 407: XNextEvent(dispPtr->display, &events[i]); ! 408: } ! 409: inSequence = ignoring = 0; ! 410: for (i = numEvents-1, eventPtr = events; i >= 0; i--, eventPtr++) { ! 411: if (((eventPtr->type != EnterNotify) ! 412: && (eventPtr->type != LeaveNotify)) ! 413: || (eventPtr->xcrossing.mode != NotifyUngrab)) { ! 414: continue; ! 415: } ! 416: diff = eventPtr->xcrossing.serial; ! 417: diff -= ungrabRequest; ! 418: if (!inSequence && (diff >= 0)) { ! 419: ! 420: /* ! 421: * This is the first event of the ungrab sequence. Scan forward ! 422: * looking for the final Enter event in the sequence. Then see ! 423: * if that event's window is in the grab tree. ! 424: */ ! 425: ! 426: inSequence = 1; ! 427: for (j = i, eventPtr2 = eventPtr; j >= 0; j--, eventPtr2++) { ! 428: if (eventPtr2->type == EnterNotify) { ! 429: if (eventPtr2->xcrossing.mode != NotifyUngrab) { ! 430: break; ! 431: } ! 432: if ((eventPtr2->xcrossing.detail != NotifyAncestor) ! 433: && (eventPtr2->xcrossing.detail != NotifyInferior) ! 434: && (eventPtr2->xcrossing.detail ! 435: != NotifyNonlinear)) { ! 436: continue; ! 437: } ! 438: if (XFindContext(dispPtr->display, ! 439: eventPtr2->xcrossing.window, ! 440: tkWindowContext, (void *) &winPtr) == 0) { ! 441: for ( ; winPtr != NULL; winPtr = winPtr->parentPtr) { ! 442: if (winPtr == grabWinPtr) { ! 443: ignoring = 1; ! 444: break; ! 445: } ! 446: } ! 447: } ! 448: break; ! 449: } else if ((eventPtr2->type != LeaveNotify) ! 450: || (eventPtr2->xcrossing.mode != NotifyUngrab)) { ! 451: break; ! 452: } ! 453: } ! 454: } ! 455: if (ignoring) { ! 456: eventPtr->type = 0; ! 457: } ! 458: } ! 459: for (i = numEvents-1, eventPtr = &events[i]; i >= 0; i--, eventPtr--) { ! 460: if (eventPtr->type != 0) { ! 461: XPutBackEvent(dispPtr->display, eventPtr); ! 462: } ! 463: } ! 464: ckfree((char *) events); ! 465: } ! 466: ! 467: /* ! 468: *---------------------------------------------------------------------- ! 469: * ! 470: * TkPointerEvent -- ! 471: * ! 472: * This procedure is called for each pointer-related event, before ! 473: * the event has been processed. It does various things to make ! 474: * grabs work correctly. ! 475: * ! 476: * Results: ! 477: * If the return value is 1 it means the event should be processed ! 478: * (event handlers should be invoked). If the return value is 0 ! 479: * it means the event should be ignored in order to make grabs ! 480: * work correctly. Note: the event may be modified by this procedure. ! 481: * ! 482: * Side effects: ! 483: * Grab state information may be updated. ! 484: * ! 485: *---------------------------------------------------------------------- ! 486: */ ! 487: ! 488: int ! 489: TkPointerEvent(eventPtr, winPtr) ! 490: register XEvent *eventPtr; /* Pointer to the event. */ ! 491: TkWindow *winPtr; /* Tk's information for window ! 492: * where event was reported. */ ! 493: { ! 494: register TkWindow *winPtr2; ! 495: TkDisplay *dispPtr = winPtr->dispPtr; ! 496: int outsideGrabTree = 0; ! 497: int originalFlags; ! 498: int appGrabbed = 0; /* Non-zero means event is being ! 499: * reported to an application that is ! 500: * affected by the grab. */ ! 501: #define ALL_BUTTONS \ ! 502: (Button1Mask|Button2Mask|Button3Mask|Button4Mask|Button5Mask) ! 503: static unsigned int state[] = { ! 504: Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask ! 505: }; ! 506: ! 507: /* ! 508: * Don't do any filtering on events generated by the event-sharing code. ! 509: */ ! 510: ! 511: if (eventPtr == tkShareEventPtr) { ! 512: return 1; ! 513: } ! 514: ! 515: /* ! 516: * If a grab is in effect, see if the event is being reported to ! 517: * a window in the grab tree. Also see if the event is being reported ! 518: * to an application that is affected by the grab. ! 519: */ ! 520: ! 521: if (dispPtr->grabWinPtr != NULL) { ! 522: if ((winPtr->mainPtr == dispPtr->grabWinPtr->mainPtr) ! 523: || (dispPtr->grabFlags & GRAB_GLOBAL)) { ! 524: appGrabbed = 1; ! 525: } ! 526: for (winPtr2 = winPtr; winPtr2 != dispPtr->grabWinPtr; ! 527: winPtr2 = winPtr2->parentPtr) { ! 528: if (winPtr2 == NULL) { ! 529: outsideGrabTree = 1; ! 530: break; ! 531: } ! 532: } ! 533: } ! 534: ! 535: originalFlags = dispPtr->grabFlags; ! 536: dispPtr->grabFlags &= ~GRAB_BUTTON_RELEASE; ! 537: if ((eventPtr->type == EnterNotify) || (eventPtr->type == LeaveNotify)) { ! 538: if ((eventPtr->type == EnterNotify) ! 539: && (eventPtr->xcrossing.detail != NotifyVirtual) ! 540: && (eventPtr->xcrossing.detail != NotifyNonlinearVirtual)) { ! 541: if ((dispPtr->grabWinPtr == NULL) ! 542: || (dispPtr->grabWinPtr->mainPtr == winPtr->mainPtr)) { ! 543: dispPtr->ungrabWinPtr = winPtr; ! 544: } ! 545: dispPtr->serverWinPtr = winPtr; ! 546: } else { ! 547: dispPtr->serverWinPtr = NULL; ! 548: } ! 549: if (dispPtr->grabWinPtr != NULL) { ! 550: if (eventPtr->xcrossing.mode == NotifyNormal) { ! 551: /* ! 552: * When a grab is active, X continues to report enter and ! 553: * leave events for windows outside the tree of the grab ! 554: * window. Detect these events and ignore them. ! 555: */ ! 556: ! 557: if (outsideGrabTree && appGrabbed) { ! 558: return 0; ! 559: } ! 560: ! 561: /* ! 562: * Make buttons have the same grab-like behavior inside a grab ! 563: * as they do outside a grab: do this by ignoring enter and ! 564: * leave events except for the window in which the button was ! 565: * pressed. ! 566: */ ! 567: ! 568: if ((dispPtr->buttonWinPtr != NULL) ! 569: && (winPtr != dispPtr->buttonWinPtr)) { ! 570: return 0; ! 571: } ! 572: } else if (eventPtr->xcrossing.mode == NotifyUngrab) { ! 573: /* ! 574: * Keep the GRAB_BUTTON_RELEASE flag on if it used to be on. ! 575: */ ! 576: ! 577: dispPtr->grabFlags = originalFlags; ! 578: if (outsideGrabTree && appGrabbed ! 579: && (dispPtr->grabFlags & GRAB_BUTTON_RELEASE)) { ! 580: /* ! 581: * The only way we get here is if a button was pressed, ! 582: * then moved to a different window and released. Enter ! 583: * and leave events were deferred while the button was ! 584: * down, but now we're getting them to move the pointer ! 585: * back to the right window, and this particular event ! 586: * is for a window outside the grab tree. Ignore it. ! 587: */ ! 588: ! 589: return 0; ! 590: } ! 591: } ! 592: } ! 593: ! 594: /* ! 595: * Keep track of the window containing the mouse, in order to ! 596: * detect various bogus event sequences. ! 597: */ ! 598: ! 599: dispPtr->pointerWinPtr = dispPtr->serverWinPtr; ! 600: return 1; ! 601: } ! 602: if ((dispPtr->grabWinPtr == NULL) || !appGrabbed) { ! 603: return 1; ! 604: } ! 605: ! 606: if (eventPtr->type == MotionNotify) { ! 607: /* ! 608: * When grabs are active, X reports motion events relative to the ! 609: * window under the pointer. Instead, it should report the events ! 610: * relative to the window the button went down in, if there is a ! 611: * button down. Otherwise, if the pointer window is outside the ! 612: * subtree of the grab window, the events should be reported ! 613: * relative to the grab window. Otherwise, the event should be ! 614: * reported to the pointer window. ! 615: */ ! 616: ! 617: winPtr2 = winPtr; ! 618: if (dispPtr->buttonWinPtr != NULL) { ! 619: winPtr2 = dispPtr->buttonWinPtr; ! 620: } else if (outsideGrabTree || (dispPtr->serverWinPtr == NULL)) { ! 621: winPtr2 = dispPtr->grabWinPtr; ! 622: } ! 623: if (winPtr2 != winPtr) { ! 624: XEvent newEvent; ! 625: ! 626: newEvent = *eventPtr; ! 627: ChangeEventWindow(&newEvent, winPtr2); ! 628: XPutBackEvent(winPtr2->display, &newEvent); ! 629: return 0; ! 630: } ! 631: return 1; ! 632: } ! 633: ! 634: /* ! 635: * Process ButtonPress and ButtonRelease events: ! 636: * 1. Keep track of whether a button is down and what window it ! 637: * went down in. ! 638: * 2. If the first button goes down outside the grab tree, pretend ! 639: * it went down in the grab window. Note: it's important to ! 640: * redirect events to the grab window like this in order to make ! 641: * things like menus work, where button presses outside the ! 642: * grabbed menu need to be seen. An application can always ! 643: * ignore the events if they occur outside its window. ! 644: * 3. If a button press or release occurs outside the window where ! 645: * the first button was pressed, retarget the event so it's reported ! 646: * to the window where the first button was pressed. ! 647: * 4. If the last button is released in a window different than where ! 648: * the first button was pressed, generate Enter/Leave events to ! 649: * move the mouse from the button window to its current window. ! 650: * 5. If the grab is set at a time when a button is already down, or ! 651: * if the window where the button was pressed was deleted, then ! 652: * dispPtr->buttonWinPtr will stay NULL. Just forget about the ! 653: * auto-grab for the button press; events will go to whatever ! 654: * window contains the pointer. If this window isn't in the grab ! 655: * tree then redirect events to the grab window. ! 656: */ ! 657: ! 658: if ((eventPtr->type == ButtonPress) || (eventPtr->type == ButtonRelease)) { ! 659: winPtr2 = dispPtr->buttonWinPtr; ! 660: if (winPtr2 == NULL) { ! 661: if (outsideGrabTree) { ! 662: winPtr2 = dispPtr->grabWinPtr; /* Note 5. */ ! 663: } else { ! 664: winPtr2 = winPtr; /* Note 5. */ ! 665: } ! 666: } ! 667: if (eventPtr->type == ButtonPress) { ! 668: if ((eventPtr->xbutton.state & ALL_BUTTONS) == 0) { ! 669: if (outsideGrabTree) { ! 670: XEvent newEvent; ! 671: ! 672: newEvent = *eventPtr; ! 673: ChangeEventWindow(&newEvent, dispPtr->grabWinPtr); ! 674: XPutBackEvent(dispPtr->display, &newEvent); ! 675: return 0; /* Note 2. */ ! 676: } ! 677: dispPtr->buttonWinPtr = winPtr; ! 678: return 1; ! 679: } ! 680: } else { ! 681: if ((eventPtr->xbutton.state & ALL_BUTTONS) ! 682: == state[eventPtr->xbutton.button - Button1]) { ! 683: if ((dispPtr->buttonWinPtr != winPtr) ! 684: && (dispPtr->buttonWinPtr != NULL)) { ! 685: XEvent newEvent; /* Note 4. */ ! 686: ! 687: /* ! 688: * If the button release is made with pointer outside ! 689: * all applications, X reports it relative to the grab ! 690: * window. Change the current window to NULL to ! 691: * reflect that the pointer's outside everything. Do ! 692: * the same if the pointer's in a window that's not ! 693: * part of the grab tree. ! 694: */ ! 695: ! 696: if (outsideGrabTree || (dispPtr->serverWinPtr == NULL)) { ! 697: winPtr = NULL; ! 698: } ! 699: newEvent = *eventPtr; ! 700: newEvent.xcrossing.mode = NotifyUngrab; ! 701: newEvent.xcrossing.focus = False; ! 702: newEvent.xcrossing.state = ! 703: eventPtr->xbutton.state & ~ALL_BUTTONS; ! 704: MovePointer(&newEvent, dispPtr->buttonWinPtr, winPtr); ! 705: } ! 706: dispPtr->buttonWinPtr = NULL; ! 707: dispPtr->grabFlags |= GRAB_BUTTON_RELEASE; ! 708: } ! 709: } ! 710: if (winPtr2 != winPtr) { ! 711: XEvent newEvent; ! 712: ! 713: newEvent = *eventPtr; ! 714: ChangeEventWindow(&newEvent, winPtr2); ! 715: XPutBackEvent(dispPtr->display, &newEvent); ! 716: return 0; /* Note 3. */ ! 717: } ! 718: } ! 719: ! 720: return 1; ! 721: } ! 722: ! 723: /* ! 724: *---------------------------------------------------------------------- ! 725: * ! 726: * ChangeEventWindow -- ! 727: * ! 728: * Given an event and a new window to which the event should be ! 729: * retargeted, modify fields of the event so that the event is ! 730: * properly retargeted to the new window. ! 731: * ! 732: * Results: ! 733: * The following fields of eventPtr are modified: window, ! 734: * subwindow, x, y, same_screen. ! 735: * ! 736: * Side effects: ! 737: * None. ! 738: * ! 739: *---------------------------------------------------------------------- ! 740: */ ! 741: ! 742: static void ! 743: ChangeEventWindow(eventPtr, winPtr) ! 744: register XEvent *eventPtr; /* Event to retarget. Must have ! 745: * type ButtonPress, ButtonRelease, KeyPress, ! 746: * KeyRelease, MotionNotify, EnterNotify, ! 747: * or LeaveNotify. */ ! 748: TkWindow *winPtr; /* New target window for event. */ ! 749: { ! 750: int x, y, sameScreen, bd; ! 751: register TkWindow *childPtr; ! 752: ! 753: eventPtr->xmotion.window = Tk_WindowId(winPtr); ! 754: if (eventPtr->xmotion.root == ! 755: RootWindow(winPtr->display, winPtr->screenNum)) { ! 756: Tk_GetRootCoords((Tk_Window) winPtr, &x, &y); ! 757: eventPtr->xmotion.x = eventPtr->xmotion.x_root - x; ! 758: eventPtr->xmotion.y = eventPtr->xmotion.y_root - y; ! 759: eventPtr->xmotion.subwindow = None; ! 760: for (childPtr = winPtr->childList; childPtr != NULL; ! 761: childPtr = childPtr->nextPtr) { ! 762: if (childPtr->flags & TK_TOP_LEVEL) { ! 763: continue; ! 764: } ! 765: x = eventPtr->xmotion.x - childPtr->changes.x; ! 766: y = eventPtr->xmotion.y - childPtr->changes.y; ! 767: bd = childPtr->changes.border_width; ! 768: if ((x >= -bd) && (y >= -bd) ! 769: && (x < (childPtr->changes.width + bd)) ! 770: && (y < (childPtr->changes.width + bd))) { ! 771: eventPtr->xmotion.subwindow = childPtr->window; ! 772: } ! 773: } ! 774: sameScreen = 1; ! 775: } else { ! 776: eventPtr->xmotion.x = 0; ! 777: eventPtr->xmotion.y = 0; ! 778: eventPtr->xmotion.subwindow = None; ! 779: sameScreen = 0; ! 780: } ! 781: if (eventPtr->type == MotionNotify) { ! 782: eventPtr->xmotion.same_screen = sameScreen; ! 783: } else { ! 784: eventPtr->xbutton.same_screen = sameScreen; ! 785: } ! 786: } ! 787: ! 788: /* ! 789: *---------------------------------------------------------------------- ! 790: * ! 791: * MovePointer -- ! 792: * ! 793: * This procedure synthesizes EnterNotify and LeaveNotify events ! 794: * to correctly transfer the pointer from one window to another. ! 795: * ! 796: * Results: ! 797: * None. ! 798: * ! 799: * Side effects: ! 800: * Synthesized events may be pushed back onto the event queue. ! 801: * The event pointed to by eventPtr is modified. ! 802: * ! 803: *---------------------------------------------------------------------- ! 804: */ ! 805: ! 806: static void ! 807: MovePointer(eventPtr, sourcePtr, destPtr) ! 808: XEvent *eventPtr; /* A template X event. Must have all fields ! 809: * properly set for EnterNotify and LeaveNotify ! 810: * events except window, subwindow, x, y, ! 811: * detail, and same_screen. (x_root and y_root ! 812: * must be valid, even though x and y needn't ! 813: * be valid). */ ! 814: TkWindow *sourcePtr; /* Window currently containing pointer (NULL ! 815: * means it's not one managed by this ! 816: * process). */ ! 817: TkWindow *destPtr; /* Window that is to end up containing the ! 818: * pointer (NULL means it's not one managed ! 819: * by this process). */ ! 820: { ! 821: TkDisplay *dispPtr; ! 822: register TkWindow *ancestorPtr; /* Lowest ancestor shared between ! 823: * sourcePtr and destPtr, or ! 824: * sourcePtr's top-level window if no ! 825: * shared ancestor. */ ! 826: register TkWindow *winPtr; ! 827: int upLevels, downLevels, i, j; ! 828: ! 829: /* ! 830: * There are four possible cases to deal with: ! 831: * ! 832: * 1. SourcePtr and destPtr are the same. There's nothing to do in ! 833: * this case. ! 834: * 2. SourcePtr is an ancestor of destPtr in the same top-level ! 835: * window. Must generate events down the window tree from source ! 836: * to dest. ! 837: * 3. DestPtr is an ancestor of sourcePtr in the same top-level ! 838: * window. Must generate events up the window tree from sourcePtr ! 839: * to destPtr. ! 840: * 4. All other cases. Must first generate events up the window tree ! 841: * from sourcePtr to its top-level, then down from destPtr's ! 842: * top-level to destPtr. This form is called "non-linear." ! 843: * ! 844: * The code below separates these four cases and decides how many levels ! 845: * up and down events have to be generated for. ! 846: */ ! 847: ! 848: if (sourcePtr == destPtr) { ! 849: return; ! 850: } ! 851: ! 852: /* ! 853: * Mark destPtr and all of its ancestors with a special flag bit. ! 854: */ ! 855: ! 856: if (destPtr != NULL) { ! 857: dispPtr = destPtr->dispPtr; ! 858: for (winPtr = destPtr; ; winPtr = winPtr->parentPtr) { ! 859: winPtr->flags |= TK_GRAB_FLAG; ! 860: if (winPtr->flags & TK_TOP_LEVEL) { ! 861: break; ! 862: } ! 863: } ! 864: } else { ! 865: dispPtr = sourcePtr->dispPtr; ! 866: } ! 867: ! 868: /* ! 869: * Search upwards from sourcePtr until an ancestor of destPtr is ! 870: * found or a top-level window is reached. Remember if we pass out ! 871: * of the grab tree along the way, since this means we'll have to ! 872: * skip some of the events that would otherwise be generated. ! 873: */ ! 874: ! 875: ancestorPtr = sourcePtr; ! 876: upLevels = 0; ! 877: if (sourcePtr != NULL) { ! 878: for (; ; upLevels++, ancestorPtr = ancestorPtr->parentPtr) { ! 879: if (ancestorPtr->flags & TK_GRAB_FLAG) { ! 880: break; ! 881: } ! 882: if (ancestorPtr->flags & TK_TOP_LEVEL) { ! 883: upLevels++; ! 884: break; ! 885: } ! 886: } ! 887: } ! 888: ! 889: /* ! 890: * Search upwards from destPtr again, clearing the flag bits and ! 891: * remembering how many levels up we had to go. ! 892: */ ! 893: ! 894: if (destPtr == NULL) { ! 895: downLevels = 0; ! 896: } else { ! 897: downLevels = -1; ! 898: for (i = 0, winPtr = destPtr; ; i++, winPtr = winPtr->parentPtr) { ! 899: winPtr->flags &= ~TK_GRAB_FLAG; ! 900: if (winPtr == ancestorPtr) { ! 901: downLevels = i; ! 902: } ! 903: if (winPtr->flags & TK_TOP_LEVEL) { ! 904: if (downLevels == -1) { ! 905: downLevels = i+1; ! 906: } ! 907: break; ! 908: } ! 909: } ! 910: } ! 911: ! 912: /* ! 913: * Generate enter/leave events and push them back onto the event ! 914: * queue. This has to be done backwards, since the last event ! 915: * pushed will be the first one processed. ! 916: */ ! 917: ! 918: #define PUSH_EVENT(w, t, d) \ ! 919: if (w->window != None) { \ ! 920: eventPtr->type = t; \ ! 921: eventPtr->xcrossing.detail = d; \ ! 922: ChangeEventWindow(eventPtr, w); \ ! 923: XPutBackEvent(w->display, eventPtr); \ ! 924: } ! 925: ! 926: if (downLevels == 0) { ! 927: ! 928: /* ! 929: * SourcePtr is an inferior of destPtr. ! 930: */ ! 931: ! 932: if (destPtr != NULL) { ! 933: PUSH_EVENT(destPtr, EnterNotify, NotifyInferior); ! 934: } ! 935: for (i = upLevels-1; i > 0; i--) { ! 936: for (winPtr = sourcePtr, j = 0; j < i; ! 937: winPtr = winPtr->parentPtr, j++) { ! 938: if (winPtr == dispPtr->grabWinPtr) { ! 939: goto nextIteration; ! 940: } ! 941: } ! 942: PUSH_EVENT(winPtr, LeaveNotify, NotifyVirtual); ! 943: nextIteration: continue; ! 944: } ! 945: PUSH_EVENT(sourcePtr, LeaveNotify, NotifyAncestor); ! 946: } else if (upLevels == 0) { ! 947: ! 948: /* ! 949: * DestPtr is an inferior of sourcePtr. ! 950: */ ! 951: ! 952: if (destPtr != NULL) { ! 953: PUSH_EVENT(destPtr, EnterNotify, NotifyAncestor); ! 954: } ! 955: for (winPtr = destPtr->parentPtr, i = downLevels-1; i > 0; ! 956: winPtr = winPtr->parentPtr, i--) { ! 957: PUSH_EVENT(winPtr, EnterNotify, NotifyVirtual); ! 958: } ! 959: if (sourcePtr != NULL) { ! 960: PUSH_EVENT(sourcePtr, LeaveNotify, NotifyInferior); ! 961: } ! 962: } else { ! 963: ! 964: /* ! 965: * Non-linear: neither window is an inferior of the other. ! 966: */ ! 967: ! 968: if (destPtr != NULL) { ! 969: PUSH_EVENT(destPtr, EnterNotify, NotifyNonlinear); ! 970: } ! 971: if (destPtr != dispPtr->grabWinPtr) { ! 972: for (winPtr = destPtr->parentPtr, i = downLevels-1; i > 0; ! 973: winPtr = winPtr->parentPtr, i--) { ! 974: PUSH_EVENT(winPtr, EnterNotify, NotifyNonlinearVirtual); ! 975: if (winPtr == dispPtr->grabWinPtr) { ! 976: break; ! 977: } ! 978: } ! 979: } ! 980: for (i = upLevels-1; i > 0; i--) { ! 981: for (winPtr = sourcePtr, j = 0; j < i; ! 982: winPtr = winPtr->parentPtr, j++) { ! 983: if (winPtr == dispPtr->grabWinPtr) { ! 984: goto nextWindow; ! 985: } ! 986: } ! 987: PUSH_EVENT(winPtr, LeaveNotify, NotifyNonlinearVirtual); ! 988: nextWindow: continue; ! 989: } ! 990: PUSH_EVENT(sourcePtr, LeaveNotify, NotifyNonlinear); ! 991: } ! 992: } ! 993: ! 994: /* ! 995: *---------------------------------------------------------------------- ! 996: * ! 997: * MovePointer2 -- ! 998: * ! 999: * This procedure synthesizes EnterNotify and LeaveNotify events ! 1000: * to correctly transfer the pointer from one window to another. ! 1001: * It is different from MovePointer in that no template X event ! 1002: * needs to be supplied; this procedure generates the template ! 1003: * event and calls MovePointer. ! 1004: * ! 1005: * Results: ! 1006: * None. ! 1007: * ! 1008: * Side effects: ! 1009: * Synthesized events may be pushed back onto the event queue. ! 1010: * ! 1011: *---------------------------------------------------------------------- ! 1012: */ ! 1013: ! 1014: static void ! 1015: MovePointer2(sourcePtr, destPtr, mode) ! 1016: TkWindow *sourcePtr; /* Window currently containing pointer (NULL ! 1017: * means it's not one managed by this ! 1018: * process). */ ! 1019: TkWindow *destPtr; /* Window that is to end up containing the ! 1020: * pointer (NULL means it's not one managed ! 1021: * by this process). */ ! 1022: int mode; /* Mode for enter/leave events, such as ! 1023: * NotifyNormal or NotifyUngrab. */ ! 1024: { ! 1025: XEvent event; ! 1026: Window dummy1, dummy2; ! 1027: int dummy3, dummy4; ! 1028: TkWindow *winPtr; ! 1029: ! 1030: winPtr = sourcePtr; ! 1031: if ((winPtr == NULL) || (winPtr->window == None)) { ! 1032: winPtr = destPtr; ! 1033: if ((winPtr == NULL) || (winPtr->window == None)) { ! 1034: return; ! 1035: } ! 1036: } ! 1037: ! 1038: event.xcrossing.serial = LastKnownRequestProcessed(winPtr->display); ! 1039: event.xcrossing.send_event = False; ! 1040: event.xcrossing.display = winPtr->display; ! 1041: event.xcrossing.root = RootWindow(winPtr->display, winPtr->screenNum); ! 1042: event.xcrossing.time = TkCurrentTime(winPtr->dispPtr); ! 1043: XQueryPointer(winPtr->display, winPtr->window, &dummy1, &dummy2, ! 1044: &event.xcrossing.x_root, &event.xcrossing.y_root, ! 1045: &dummy3, &dummy4, &event.xcrossing.state); ! 1046: event.xcrossing.mode = mode; ! 1047: event.xcrossing.focus = False; ! 1048: MovePointer(&event, sourcePtr, destPtr); ! 1049: } ! 1050: ! 1051: /* ! 1052: *---------------------------------------------------------------------- ! 1053: * ! 1054: * TkGrabDeadWindow -- ! 1055: * ! 1056: * This procedure is invoked whenever a window is deleted, so that ! 1057: * grab-related cleanup can be performed. ! 1058: * ! 1059: * Results: ! 1060: * None. ! 1061: * ! 1062: * Side effects: ! 1063: * Various cleanups happen, such as generating events to move the ! 1064: * pointer back to its "natural" window as if an ungrab had been ! 1065: * done. See the code. ! 1066: * ! 1067: *---------------------------------------------------------------------- ! 1068: */ ! 1069: ! 1070: void ! 1071: TkGrabDeadWindow(winPtr) ! 1072: register TkWindow *winPtr; /* Window that is in the process ! 1073: * of being deleted. */ ! 1074: { ! 1075: TkDisplay *dispPtr = winPtr->dispPtr; ! 1076: ! 1077: if (dispPtr->grabWinPtr == winPtr) { ! 1078: dispPtr->grabWinPtr = NULL; ! 1079: if (!(dispPtr->grabFlags & GRAB_GLOBAL)) { ! 1080: /* ! 1081: * Must generate enter/leave events to move back to the window ! 1082: * that contains the mouse pointer. We needn't filter events ! 1083: * here like we do in Tk_Ungrab because there are no children ! 1084: * of the grab window left in existence. ! 1085: */ ! 1086: ! 1087: movePointerBack: ! 1088: if ((dispPtr->ungrabWinPtr != NULL) ! 1089: && (dispPtr->ungrabWinPtr->mainPtr != winPtr->mainPtr)) { ! 1090: dispPtr->ungrabWinPtr = NULL; ! 1091: } ! 1092: MovePointer2(winPtr, dispPtr->ungrabWinPtr, NotifyUngrab); ! 1093: } ! 1094: } else if (dispPtr->buttonWinPtr == winPtr) { ! 1095: /* ! 1096: * The window in which a button was pressed was deleted. Simulate ! 1097: * dropping the button auto-grab by generating Enter and Leave ! 1098: * events to move the pointer back to the window it's really on ! 1099: * top of. ! 1100: */ ! 1101: ! 1102: dispPtr->buttonWinPtr = NULL; ! 1103: goto movePointerBack; ! 1104: } ! 1105: if (dispPtr->ungrabWinPtr == winPtr) { ! 1106: dispPtr->ungrabWinPtr = NULL; ! 1107: } ! 1108: if (dispPtr->pointerWinPtr == winPtr) { ! 1109: dispPtr->pointerWinPtr = NULL; ! 1110: } ! 1111: if (dispPtr->serverWinPtr == winPtr) { ! 1112: dispPtr->serverWinPtr = NULL; ! 1113: } ! 1114: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.