/* * tkGrab.c -- * * This file provides procedures that implement grabs for Tk. * * Copyright (c) 1992-1993 The Regents of the University of California. * All rights reserved. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #ifndef lint static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkGrab.c,v 1.34 93/10/23 16:21:43 ouster Exp $ SPRITE (Berkeley)"; #endif #include "tkConfig.h" #include "tkInt.h" /* * This module is ridiculously complicated... sorry about that. The * problem is that the grabs provided by the X server aren't very * useful, so this module tries to create a more useful form of grab * using the X server's rudimentary facilities. This requires us to * suppress some of the events coming from the X server and generate * many additional events. Managing the events is hard because of the * asynchronous way that the event queue is processed. The current * solution uses an extra "grab event queue" for each display, where * we put the event that we synthesize here. Events in this queue * are processed before any events in the normal X queue. The grab * event queue is needed (rather than just pushing events back on the * X queue) so that we can keep a clear boundary between the events * we've synthesized and those coming from the server, so that we can * add new events after all the other synthesized events but before * those from the server. */ /* * One of the following structures is kept for each event in the * grab queue maintained by this module. */ struct TkGrabEvent { XEvent event; /* Event to process. */ struct TkGrabEvent *nextPtr; /* Next event in list, or NULL for * end of list. */ }; /* * Bit definitions for grabFlags field of TkDisplay structures: * * GRAB_GLOBAL 1 means this is a global grab (we grabbed via * the server so all applications are locked out). * 0 means this is a local grab that affects * only this application. * GRAB_TRIGGER_QUEUED 1 means that there are events in the grab * queue for this display and a fake event has * been pushed to cause the events on the grab * queue to be processed before any events on * the regular X event queue. * GRAB_TEMP_GLOBAL 1 means we've temporarily grabbed via the * server because a button is down and we want * to make sure that we get the button-up * event. The grab will be released when the * last mouse button goes up. */ #define GRAB_GLOBAL 1 #define GRAB_TRIGGER_QUEUED 2 #define GRAB_TEMP_GLOBAL 4 /* * The following magic value is stored in the "send_event" field of * EnterNotify and LeaveNotify events that are generated in this * file. This allows us to separate "real" events coming from the * server from those that we generated. */ #define GENERATED_EVENT_MAGIC ((Bool) 0x147321ac) /* * The following magic value stored in the "send_event" field of * an event identifies it as a special dummy event to trigger a * change in the grabWinPtr field of a display. The "window" * field of the event actually contains a (TkWindow *) value to * put in grabWinPtr. */ #define GRAB_WINDOW_EVENT_MAGIC ((Bool) 0x347321ab) /* * Mask that selects any of the state bits corresponding to buttons, * plus masks that select individual buttons' bits: */ #define ALL_BUTTONS \ (Button1Mask|Button2Mask|Button3Mask|Button4Mask|Button5Mask) static unsigned int buttonStates[] = { Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask }; /* * Forward declarations for procedures declared later in this file: */ static void ChangeEventWindow _ANSI_ARGS_((XEvent *eventPtr, TkWindow *winPtr)); static void EatGrabEvents _ANSI_ARGS_((TkDisplay *dispPtr, unsigned int serial)); static TkWindow * FindCommonAncestor _ANSI_ARGS_((TkWindow *winPtr1, TkWindow *winPtr2, int *countPtr1, int *countPtr2)); static void MovePointer _ANSI_ARGS_((XEvent *eventPtr, TkWindow *sourcePtr, TkWindow *destPtr, int leaveEvents, int EnterEvents)); static void MovePointer2 _ANSI_ARGS_((TkWindow *sourcePtr, TkWindow *destPtr, int mode, int leaveEvents, int EnterEvents)); static void PushTriggerEvent _ANSI_ARGS_((TkDisplay *dispPtr)); static void QueueGrabWindowChange _ANSI_ARGS_((TkDisplay *dispPtr, TkWindow *grabWinPtr)); static void ReleaseButtonGrab _ANSI_ARGS_((TkDisplay *dispPtr)); /* *---------------------------------------------------------------------- * * Tk_GrabCmd -- * * This procedure is invoked to process the "grab" Tcl command. * See the user documentation for details on what it does. * * Results: * A standard Tcl result. * * Side effects: * See the user documentation. * *---------------------------------------------------------------------- */ /* ARGSUSED */ int Tk_GrabCmd(clientData, interp, argc, argv) ClientData clientData; /* Main window associated with * interpreter. */ Tcl_Interp *interp; /* Current interpreter. */ int argc; /* Number of arguments. */ char **argv; /* Argument strings. */ { int globalGrab; Tk_Window tkwin; TkDisplay *dispPtr; int length; char c; if (argc < 2) { badArgs: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " ?-global? window\" or \"", argv[0], " option ?arg arg ...?\"", (char *) NULL); return TCL_ERROR; } c = argv[1][0]; length = strlen(argv[1]); if (c == '.') { if (argc != 2) { goto badArgs; } tkwin = Tk_NameToWindow(interp, argv[1], (Tk_Window) clientData); if (tkwin == NULL) { return TCL_ERROR; } return Tk_Grab(interp, tkwin, 0); } else if ((c == '-') && (strncmp(argv[1], "-global", length) == 0) && (length >= 2)) { if (argc != 3) { goto badArgs; } tkwin = Tk_NameToWindow(interp, argv[2], (Tk_Window) clientData); if (tkwin == NULL) { return TCL_ERROR; } return Tk_Grab(interp, tkwin, 1); } else if ((c == 'c') && (strncmp(argv[1], "current", length) == 0)) { if (argc > 3) { Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " current ?window?\"", (char *) NULL); return TCL_ERROR; } if (argc == 3) { tkwin = Tk_NameToWindow(interp, argv[2], (Tk_Window) clientData); if (tkwin == NULL) { return TCL_ERROR; } dispPtr = ((TkWindow *) tkwin)->dispPtr; if (dispPtr->eventualGrabWinPtr != NULL) { interp->result = dispPtr->eventualGrabWinPtr->pathName; } } else { for (dispPtr = tkDisplayList; dispPtr != NULL; dispPtr = dispPtr->nextPtr) { if (dispPtr->eventualGrabWinPtr != NULL) { Tcl_AppendElement(interp, dispPtr->eventualGrabWinPtr->pathName); } } } return TCL_OK; } else if ((c == 'r') && (strncmp(argv[1], "release", length) == 0)) { if (argc != 3) { Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " release window\"", (char *) NULL); return TCL_ERROR; } tkwin = Tk_NameToWindow(interp, argv[2], (Tk_Window) clientData); if (tkwin == NULL) { Tcl_ResetResult(interp); } else { Tk_Ungrab(tkwin); } } else if ((c == 's') && (strncmp(argv[1], "set", length) == 0) && (length >= 2)) { if (argc > 4) { Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " set ?-global? window\"", (char *) NULL); return TCL_ERROR; } if (argc == 3) { globalGrab = 0; tkwin = Tk_NameToWindow(interp, argv[2], (Tk_Window) clientData); } else { globalGrab = 1; length = strlen(argv[2]); if ((strncmp(argv[2], "-global", length) != 0) || (length < 2)) { Tcl_AppendResult(interp, "bad argument \"", argv[2], "\": must be \"", argv[0], " set ?-global? window\"", (char *) NULL); return TCL_ERROR; } tkwin = Tk_NameToWindow(interp, argv[3], (Tk_Window) clientData); } if (tkwin == NULL) { return TCL_ERROR; } return Tk_Grab(interp, tkwin, globalGrab); } else if ((c == 's') && (strncmp(argv[1], "status", length) == 0) && (length >= 2)) { TkWindow *winPtr; if (argc != 3) { Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " status window\"", (char *) NULL); return TCL_ERROR; } winPtr = (TkWindow *) Tk_NameToWindow(interp, argv[2], (Tk_Window) clientData); if (winPtr == NULL) { return TCL_ERROR; } dispPtr = winPtr->dispPtr; if (dispPtr->eventualGrabWinPtr != winPtr) { interp->result = "none"; } else if (dispPtr->grabFlags & GRAB_GLOBAL) { interp->result = "global"; } else { interp->result = "local"; } } else { Tcl_AppendResult(interp, "unknown or ambiguous option \"", argv[1], "\": must be current, release, set, or status", (char *) NULL); return TCL_ERROR; } return TCL_OK; } /* *---------------------------------------------------------------------- * * Tk_Grab -- * * Grabs the pointer and keyboard, so that mouse-related events are * only reported relative to a given window and its descendants. * * Results: * A standard Tcl result is returned. TCL_OK is the normal return * value; if the grab could not be set then TCL_ERROR is returned * and interp->result will hold an error message. * * Side effects: * Once this call completes successfully, no window outside the * tree rooted at tkwin will receive pointer- or keyboard-related * events until the next call to Tk_Ungrab. If a previous grab was * in effect within this application, then it is replaced with a new * one. * *---------------------------------------------------------------------- */ int Tk_Grab(interp, tkwin, grabGlobal) Tcl_Interp *interp; /* Used for error reporting. */ Tk_Window tkwin; /* Window on whose behalf the pointer * is to be grabbed. */ int grabGlobal; /* Non-zero means issue a grab to the * server so that no other application * gets mouse or keyboard events. * Zero means the grab only applies * within this application. */ { int grabResult; TkWindow *winPtr = (TkWindow *) tkwin; TkDisplay *dispPtr = winPtr->dispPtr; TkWindow *winPtr2; unsigned int serial; ReleaseButtonGrab(dispPtr); if (dispPtr->eventualGrabWinPtr != NULL) { if ((dispPtr->eventualGrabWinPtr == winPtr) && (grabGlobal == ((dispPtr->grabFlags & GRAB_GLOBAL) != 0))) { return TCL_OK; } if (dispPtr->eventualGrabWinPtr->mainPtr != winPtr->mainPtr) { alreadyGrabbed: interp->result = "grab failed: another application has grab"; return TCL_ERROR; } Tk_Ungrab(tkwin); } Tk_MakeWindowExist(tkwin); if (!grabGlobal) { Window dummy1, dummy2; int dummy3, dummy4, dummy5, dummy6; unsigned int state; /* * Local grab. However, if any mouse buttons are down, turn * it into a global grab temporarily, until the last button * goes up. This does two things: (a) it makes sure that we * see the button-up event; and (b) it allows us to track mouse * motion among all of the windows of this application. */ dispPtr->grabFlags &= ~(GRAB_GLOBAL|GRAB_TEMP_GLOBAL); XQueryPointer(dispPtr->display, winPtr->window, &dummy1, &dummy2, &dummy3, &dummy4, &dummy5, &dummy6, &state); if ((state & ALL_BUTTONS) != 0) { dispPtr->grabFlags |= GRAB_TEMP_GLOBAL; goto setGlobalGrab; } } else { dispPtr->grabFlags |= GRAB_GLOBAL; setGlobalGrab: /* * Tricky point: must ungrab before grabbing. This is needed * in case there is a button auto-grab already in effect. If * there is, and the mouse has moved to a different window, X * won't generate enter and leave events to move the mouse if * we grab without ungrabbing. */ XUngrabPointer(dispPtr->display, CurrentTime); serial = NextRequest(dispPtr->display); grabResult = XGrabPointer(dispPtr->display, winPtr->window, True, ButtonPressMask|ButtonReleaseMask|ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); if (grabResult != 0) { grabError: if (grabResult == GrabNotViewable) { interp->result = "grab failed: window not viewable"; } else if (grabResult == AlreadyGrabbed) { goto alreadyGrabbed; } else if (grabResult == GrabFrozen) { interp->result = "grab failed: keyboard or pointer frozen"; } else if (grabResult == GrabInvalidTime) { interp->result = "grab failed: invalid time"; } else { char msg[100]; sprintf(msg, "grab failed for unknown reason (code %d)", grabResult); Tcl_AppendResult(interp, msg, (char *) NULL); } return TCL_ERROR; } grabResult = XGrabKeyboard(dispPtr->display, Tk_WindowId(tkwin), False, GrabModeAsync, GrabModeAsync, CurrentTime); if (grabResult != 0) { XUngrabPointer(dispPtr->display, CurrentTime); goto grabError; } /* * Eat up any grab-related events generated by the server for the * grab. There are several reasons for doing this: * * 1. We have to synthesize the events for local grabs anyway, since * the server doesn't participate in them. * 2. The server doesn't always generate the right events for global * grabs (e.g. it generates events even if the current window is * in the grab tree, which we don't want). * 3. We want all the grab-related events to be processed immediately * (before other events that are already queued); events coming * from the server will be in the wrong place, but events we * synthesize here will go to the front of the queue. */ EatGrabEvents(dispPtr, serial); } /* * Synthesize leave events to move the pointer from its current window * up to the lowest ancestor that it has in common with the grab window. * However, only do this if the pointer is outside the grab window's * subtree but inside the grab window's application. */ if ((dispPtr->serverWinPtr != NULL) && (dispPtr->serverWinPtr->mainPtr == winPtr->mainPtr)) { for (winPtr2 = dispPtr->serverWinPtr; ; winPtr2 = winPtr2->parentPtr) { if (winPtr2 == winPtr) { break; } if (winPtr2 == NULL) { MovePointer2(dispPtr->serverWinPtr, winPtr, NotifyGrab, 1, 0); break; } } } QueueGrabWindowChange(dispPtr, winPtr); return TCL_OK; } /* *---------------------------------------------------------------------- * * Tk_Ungrab -- * * Releases a grab on the mouse pointer and keyboard, if there * is one set on the specified window. * * Results: * None. * * Side effects: * Pointer and keyboard events will start being delivered to other * windows again. * *---------------------------------------------------------------------- */ void Tk_Ungrab(tkwin) Tk_Window tkwin; /* Window that identifies display * for grab to be released. */ { TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr; TkWindow *grabWinPtr, *winPtr; unsigned int serial; grabWinPtr = (TkWindow *) tkwin; dispPtr = grabWinPtr->dispPtr; if (grabWinPtr != dispPtr->eventualGrabWinPtr) { return; } ReleaseButtonGrab(dispPtr); QueueGrabWindowChange(dispPtr, (TkWindow *) NULL); if (dispPtr->grabFlags & (GRAB_GLOBAL|GRAB_TEMP_GLOBAL)) { dispPtr->grabFlags &= ~(GRAB_GLOBAL|GRAB_TEMP_GLOBAL); serial = NextRequest(dispPtr->display); XUngrabPointer(dispPtr->display, CurrentTime); XUngrabKeyboard(dispPtr->display, CurrentTime); EatGrabEvents(dispPtr, serial); } /* * Generate events to move the pointer back to the window where it * really is. Some notes: * 1. As with grabs, only do this if the "real" window is not a * descendant of the grab window, since in this case the pointer * is already where it's supposed to be. * 2. If the "real" window is in some other application then don't * generate any events at all, since everything's already been * reported correctly. * 3. Only generate enter events. Don't generate leave events, * because we never told the lower-level windows that they * had the pointer in the first place. */ for (winPtr = dispPtr->serverWinPtr; ; winPtr = winPtr->parentPtr) { if (winPtr == grabWinPtr) { break; } if (winPtr == NULL) { if ((dispPtr->serverWinPtr == NULL) || (dispPtr->serverWinPtr->mainPtr == grabWinPtr->mainPtr)) { MovePointer2(grabWinPtr, dispPtr->serverWinPtr, NotifyUngrab, 0, 1); } break; } } } /* *---------------------------------------------------------------------- * * ReleaseButtonGrab -- * * This procedure is called to release a simulated button grab, if * there is one in effect. A button grab is present whenever * dispPtr->buttonWinPtr is non-NULL or when the GRAB_TEMP_GLOBAL * flag is set. * * Results: * None. * * Side effects: * DispPtr->buttonWinPtr is reset to NULL, and enter and leave * events are generated if necessary to move the pointer from * the button grab window to its current window. * *---------------------------------------------------------------------- */ static void ReleaseButtonGrab(dispPtr) register TkDisplay *dispPtr; /* Display whose button grab is to be * released. */ { unsigned int serial; if (dispPtr->buttonWinPtr != NULL) { if (dispPtr->buttonWinPtr != dispPtr->serverWinPtr) { MovePointer2(dispPtr->buttonWinPtr, dispPtr->serverWinPtr, NotifyUngrab, 1, 1); } dispPtr->buttonWinPtr = NULL; } if (dispPtr->grabFlags & GRAB_TEMP_GLOBAL) { dispPtr->grabFlags &= ~GRAB_TEMP_GLOBAL; serial = NextRequest(dispPtr->display); XUngrabPointer(dispPtr->display, CurrentTime); XUngrabKeyboard(dispPtr->display, CurrentTime); EatGrabEvents(dispPtr, serial); } } /* *---------------------------------------------------------------------- * * TkPointerEvent -- * * This procedure is called for each pointer-related event, before * the event has been processed. It does various things to make * grabs work correctly. * * Results: * If the return value is 1 it means the event should be processed * (event handlers should be invoked). If the return value is 0 * it means the event should be ignored in order to make grabs * work correctly. In some cases this procedure modifies the event. * * Side effects: * Grab state information may be updated. New events may also be * pushed back onto the event queue to replace or augment the * one passed in here. * *---------------------------------------------------------------------- */ int TkPointerEvent(eventPtr, winPtr) register XEvent *eventPtr; /* Pointer to the event. */ TkWindow *winPtr; /* Tk's information for window * where event was reported. */ { register TkWindow *winPtr2; TkDisplay *dispPtr = winPtr->dispPtr; unsigned int serial; int outsideGrabTree = 0; int ancestorOfGrab = 0; int appGrabbed = 0; /* Non-zero means event is being * reported to an application that is * affected by the grab. */ /* * If a grab is in effect, see if the event is being reported to * a window in the grab tree or to an ancestor of the grab window * within its same top-level window. Also see if the event is * being reported to an application that is affected by the grab. */ if (dispPtr->grabWinPtr != NULL) { if ((winPtr->mainPtr == dispPtr->grabWinPtr->mainPtr) || (dispPtr->grabFlags & GRAB_GLOBAL)) { appGrabbed = 1; } for (winPtr2 = winPtr; winPtr2 != dispPtr->grabWinPtr; winPtr2 = winPtr2->parentPtr) { if (winPtr2 == NULL) { outsideGrabTree = 1; for (winPtr2 = dispPtr->grabWinPtr; ; winPtr2 = winPtr2->parentPtr) { if (winPtr2 == winPtr) { ancestorOfGrab = 1; } if (winPtr2->flags & TK_TOP_LEVEL) { break; } } break; } } } if ((eventPtr->type == EnterNotify) || (eventPtr->type == LeaveNotify)) { /* * Keep track of what window the mouse is *really* over. * Any events that we generate have a special send_event value, * which is detected below and used to ignore the event for * purposes of setting serverWinPtr. */ if (eventPtr->xcrossing.send_event != GENERATED_EVENT_MAGIC) { if ((eventPtr->type == LeaveNotify) && (winPtr->flags & TK_TOP_LEVEL)) { dispPtr->serverWinPtr = NULL; } else { dispPtr->serverWinPtr = winPtr; } } /* * When a grab is active, X continues to report enter and leave * events for windows outside the tree of the grab window: * 1. Detect these events and ignore them except for * windows above the grab window. * 2. Allow Enter and Leave events to pass through the * windows above the grab window, but never let them * end up with the pointer *in* one of those windows. */ if (dispPtr->grabWinPtr != NULL) { if (outsideGrabTree && appGrabbed) { if (!ancestorOfGrab) { return 0; } switch (eventPtr->xcrossing.detail) { case NotifyInferior: return 0; case NotifyAncestor: eventPtr->xcrossing.detail = NotifyVirtual; break; case NotifyNonlinear: eventPtr->xcrossing.detail = NotifyNonlinearVirtual; break; } } /* * Make buttons have the same grab-like behavior inside a grab * as they do outside a grab: do this by ignoring enter and * leave events except for the window in which the button was * pressed. */ if ((dispPtr->buttonWinPtr != NULL) && (winPtr != dispPtr->buttonWinPtr)) { return 0; } } return 1; } if (!appGrabbed) { return 1; } if (eventPtr->type == MotionNotify) { /* * When grabs are active, X reports motion events relative to the * window under the pointer. Instead, it should report the events * relative to the window the button went down in, if there is a * button down. Otherwise, if the pointer window is outside the * subtree of the grab window, the events should be reported * relative to the grab window. Otherwise, the event should be * reported to the pointer window. */ winPtr2 = winPtr; if (dispPtr->buttonWinPtr != NULL) { winPtr2 = dispPtr->buttonWinPtr; } else if (outsideGrabTree || (dispPtr->serverWinPtr == NULL)) { winPtr2 = dispPtr->grabWinPtr; } if (winPtr2 != winPtr) { XEvent newEvent; newEvent = *eventPtr; ChangeEventWindow(&newEvent, winPtr2); XPutBackEvent(winPtr2->display, &newEvent); return 0; } return 1; } /* * Process ButtonPress and ButtonRelease events: * 1. Keep track of whether a button is down and what window it * went down in. * 2. If the first button goes down outside the grab tree, pretend * it went down in the grab window. Note: it's important to * redirect events to the grab window like this in order to make * things like menus work, where button presses outside the * grabbed menu need to be seen. An application can always * ignore the events if they occur outside its window. * 3. If a button press or release occurs outside the window where * the first button was pressed, retarget the event so it's reported * to the window where the first button was pressed. * 4. If the last button is released in a window different than where * the first button was pressed, generate Enter/Leave events to * move the mouse from the button window to its current window. * 5. If the grab is set at a time when a button is already down, or * if the window where the button was pressed was deleted, then * dispPtr->buttonWinPtr will stay NULL. Just forget about the * auto-grab for the button press; events will go to whatever * window contains the pointer. If this window isn't in the grab * tree then redirect events to the grab window. * 6. When a button is pressed during a local grab, the X server sets * a grab of its own, since it doesn't even know about our local * grab. This causes enter and leave events no longer to be * generated in the same way as for global grabs. To eliminate this * problem, set a temporary global grab when the first button goes * down and release it when the last button comes up. */ if ((eventPtr->type == ButtonPress) || (eventPtr->type == ButtonRelease)) { winPtr2 = dispPtr->buttonWinPtr; if (winPtr2 == NULL) { if (outsideGrabTree) { winPtr2 = dispPtr->grabWinPtr; /* Note 5. */ } else { winPtr2 = winPtr; /* Note 5. */ } } if (eventPtr->type == ButtonPress) { if ((eventPtr->xbutton.state & ALL_BUTTONS) == 0) { if (outsideGrabTree) { XEvent newEvent; newEvent = *eventPtr; ChangeEventWindow(&newEvent, dispPtr->grabWinPtr); XPutBackEvent(dispPtr->display, &newEvent); return 0; /* Note 2. */ } if (!(dispPtr->grabFlags & GRAB_GLOBAL)) { /* Note 6. */ serial = NextRequest(dispPtr->display); if (XGrabPointer(dispPtr->display, dispPtr->grabWinPtr->window, True, ButtonPressMask|ButtonReleaseMask|ButtonMotionMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime) == 0) { EatGrabEvents(dispPtr, serial); if (XGrabKeyboard(dispPtr->display, winPtr->window, False, GrabModeAsync, GrabModeAsync, CurrentTime) == 0) { dispPtr->grabFlags |= GRAB_TEMP_GLOBAL; } else { XUngrabPointer(dispPtr->display, CurrentTime); } } } dispPtr->buttonWinPtr = winPtr; return 1; } } else { if ((eventPtr->xbutton.state & ALL_BUTTONS) == buttonStates[eventPtr->xbutton.button - Button1]) { ReleaseButtonGrab(dispPtr); /* Note 4. */ } } if (winPtr2 != winPtr) { XEvent newEvent; newEvent = *eventPtr; ChangeEventWindow(&newEvent, winPtr2); XPutBackEvent(dispPtr->display, &newEvent); return 0; /* Note 3. */ } } return 1; } /* *---------------------------------------------------------------------- * * ChangeEventWindow -- * * Given an event and a new window to which the event should be * retargeted, modify fields of the event so that the event is * properly retargeted to the new window. * * Results: * The following fields of eventPtr are modified: window, * subwindow, x, y, same_screen. * * Side effects: * None. * *---------------------------------------------------------------------- */ static void ChangeEventWindow(eventPtr, winPtr) register XEvent *eventPtr; /* Event to retarget. Must have * type ButtonPress, ButtonRelease, KeyPress, * KeyRelease, MotionNotify, EnterNotify, * or LeaveNotify. */ TkWindow *winPtr; /* New target window for event. */ { int x, y, sameScreen, bd; register TkWindow *childPtr; eventPtr->xmotion.window = Tk_WindowId(winPtr); if (eventPtr->xmotion.root == RootWindow(winPtr->display, winPtr->screenNum)) { Tk_GetRootCoords((Tk_Window) winPtr, &x, &y); eventPtr->xmotion.x = eventPtr->xmotion.x_root - x; eventPtr->xmotion.y = eventPtr->xmotion.y_root - y; eventPtr->xmotion.subwindow = None; for (childPtr = winPtr->childList; childPtr != NULL; childPtr = childPtr->nextPtr) { if (childPtr->flags & TK_TOP_LEVEL) { continue; } x = eventPtr->xmotion.x - childPtr->changes.x; y = eventPtr->xmotion.y - childPtr->changes.y; bd = childPtr->changes.border_width; if ((x >= -bd) && (y >= -bd) && (x < (childPtr->changes.width + bd)) && (y < (childPtr->changes.width + bd))) { eventPtr->xmotion.subwindow = childPtr->window; } } sameScreen = 1; } else { eventPtr->xmotion.x = 0; eventPtr->xmotion.y = 0; eventPtr->xmotion.subwindow = None; sameScreen = 0; } if (eventPtr->type == MotionNotify) { eventPtr->xmotion.same_screen = sameScreen; } else { eventPtr->xbutton.same_screen = sameScreen; } } /* *---------------------------------------------------------------------- * * MovePointer -- * * This procedure synthesizes EnterNotify and LeaveNotify events * to correctly transfer the pointer from one window to another. * * Results: * None. * * Side effects: * Synthesized events may be pushed back onto the event queue. * The event pointed to by eventPtr is modified. * *---------------------------------------------------------------------- */ static void MovePointer(eventPtr, sourcePtr, destPtr, leaveEvents, enterEvents) XEvent *eventPtr; /* A template X event. Must have all fields * properly set for EnterNotify and LeaveNotify * events except window, subwindow, x, y, * detail, and same_screen. (x_root and y_root * must be valid, even though x and y needn't * be valid). */ TkWindow *sourcePtr; /* Window currently containing pointer (NULL * means it's not one managed by this * process). */ TkWindow *destPtr; /* Window that is to end up containing the * pointer (NULL means it's not one managed * by this process). */ int leaveEvents; /* Non-zero means generate leave events for the * windows being left. Zero means don't * generate leave events. */ int enterEvents; /* Non-zero means generate enter events for the * windows being entered. Zero means don't * generate enter events. */ { register TkWindow *winPtr; int upLevels, downLevels, i, j; /* * There are four possible cases to deal with: * * 1. SourcePtr and destPtr are the same. There's nothing to do in * this case. * 2. SourcePtr is an ancestor of destPtr in the same top-level * window. Must generate events down the window tree from source * to dest. * 3. DestPtr is an ancestor of sourcePtr in the same top-level * window. Must generate events up the window tree from sourcePtr * to destPtr. * 4. All other cases. Must first generate events up the window tree * from sourcePtr to its top-level, then down from destPtr's * top-level to destPtr. This form is called "non-linear." * * The call to FindCommonAncestor separates these four cases and decides * how many levels up and down events have to be generated for. */ if (sourcePtr == destPtr) { return; } FindCommonAncestor(sourcePtr, destPtr, &upLevels, &downLevels); /* * Generate enter/leave events and add them to the grab event queue. */ #define QUEUE(w, t, d) \ if (w->window != None) { \ eventPtr->type = t; \ eventPtr->xcrossing.detail = d; \ ChangeEventWindow(eventPtr, w); \ TkQueueEvent(w->dispPtr, eventPtr); \ } if (downLevels == 0) { /* * SourcePtr is an inferior of destPtr. */ if (leaveEvents) { QUEUE(sourcePtr, LeaveNotify, NotifyAncestor); for (winPtr = sourcePtr->parentPtr, i = upLevels-1; i > 0; winPtr = winPtr->parentPtr, i--) { QUEUE(winPtr, LeaveNotify, NotifyVirtual); } } if ((enterEvents) && (destPtr != NULL)) { QUEUE(destPtr, EnterNotify, NotifyInferior); } } else if (upLevels == 0) { /* * DestPtr is an inferior of sourcePtr. */ if ((leaveEvents) && (sourcePtr != NULL)) { QUEUE(sourcePtr, LeaveNotify, NotifyInferior); } if (enterEvents) { for (i = downLevels-1; i > 0; i--) { for (winPtr = destPtr->parentPtr, j = 1; j < i; winPtr = winPtr->parentPtr, j++) { } QUEUE(winPtr, EnterNotify, NotifyVirtual); } if (destPtr != NULL) { QUEUE(destPtr, EnterNotify, NotifyAncestor); } } } else { /* * Non-linear: neither window is an inferior of the other. */ if (leaveEvents) { QUEUE(sourcePtr, LeaveNotify, NotifyNonlinear); for (winPtr = sourcePtr->parentPtr, i = upLevels-1; i > 0; winPtr = winPtr->parentPtr, i--) { QUEUE(winPtr, LeaveNotify, NotifyNonlinearVirtual); } } if (enterEvents) { for (i = downLevels-1; i > 0; i--) { for (winPtr = destPtr->parentPtr, j = 1; j < i; winPtr = winPtr->parentPtr, j++) { } QUEUE(winPtr, EnterNotify, NotifyNonlinearVirtual); } if (destPtr != NULL) { QUEUE(destPtr, EnterNotify, NotifyNonlinear); } } } } /* *---------------------------------------------------------------------- * * TkQueueEvent -- * * This procedure adds an enter or leave event to the end of the * grab queue for dispPtr. * * Results: * None. * * Side effects: * A copy of *eventPtr is added to the grab queue for dispPtr. * It will be processed after all other events on the grab queue * but before any "real" X events (those not coming from the grab * queue). * *---------------------------------------------------------------------- */ void TkQueueEvent(dispPtr, eventPtr) TkDisplay *dispPtr; /* Display for which the event is to be * queued. */ XEvent *eventPtr; /* Event to queue. */ { TkGrabEvent *grabEventPtr; grabEventPtr = (TkGrabEvent *) ckalloc(sizeof(TkGrabEvent)); grabEventPtr->event = *eventPtr; grabEventPtr->nextPtr = NULL; if (dispPtr->firstGrabEventPtr == NULL) { dispPtr->firstGrabEventPtr = grabEventPtr; } else { dispPtr->lastGrabEventPtr->nextPtr = grabEventPtr; } dispPtr->lastGrabEventPtr = grabEventPtr; if (!(dispPtr->grabFlags & GRAB_TRIGGER_QUEUED)) { PushTriggerEvent(dispPtr); } } /* *---------------------------------------------------------------------- * * PushTriggerEvent -- * * This procedure creates a special "trigger" event and pushes it * onto the front of the event queue for winPtr's display. * When Tk_HandleEvent sees this event it will call back to this * module so that we can feed events from the grab queue onto the * front of the event queue. * * Results: * None. * * Side effects: * Causes TkGrabTriggerProc to be called later on when the event * is actually handled. * *---------------------------------------------------------------------- */ static void PushTriggerEvent(dispPtr) TkDisplay *dispPtr; /* Display on whose display a trigger * event is to be pushed back. */ { XEvent event; event.xany.type = -1; event.xany.serial = 0; event.xany.send_event = True; event.xany.display = (Display *) dispPtr; event.xany.window = None; XPutBackEvent(dispPtr->display, &event); dispPtr->grabFlags |= GRAB_TRIGGER_QUEUED; } /* *---------------------------------------------------------------------- * * TkGrabTriggerProc -- * * This procedure is invoked when a trigger event is encountered * by Tk_HandleEvent. * * Results: * None. * * Side effects: * See code below. * *---------------------------------------------------------------------- */ void TkGrabTriggerProc(eventPtr) XEvent *eventPtr; /* Pointer to the trigger event. */ { TkDisplay *dispPtr = (TkDisplay *) eventPtr->xany.display; TkGrabEvent *grabEventPtr; /* * Remove the first event from the grab queue, if there is one. * If there are additional events left on the queue, then push * back a new trigger event so that this procedure will get called * again to process them. */ dispPtr->grabFlags &= ~GRAB_TRIGGER_QUEUED; grabEventPtr = dispPtr->firstGrabEventPtr; if (grabEventPtr == NULL) { return; } dispPtr->firstGrabEventPtr = grabEventPtr->nextPtr; if (dispPtr->firstGrabEventPtr == NULL) { dispPtr->lastGrabEventPtr = NULL; } else { PushTriggerEvent(dispPtr); } /* * If this is a special event to change grabWinPtr, do that; otherwise * call Tk_HandleEvent recursively to process the grab event. In either * case, free up the event when done. */ if (grabEventPtr->event.xany.send_event == GRAB_WINDOW_EVENT_MAGIC) { if (XFindContext(grabEventPtr->event.xany.display, grabEventPtr->event.xany.window, tkWindowContext, (caddr_t *) &dispPtr->grabWinPtr) != 0) { dispPtr->grabWinPtr = NULL; } } else { Tk_HandleEvent(&grabEventPtr->event); } ckfree((char *) grabEventPtr); } /* *---------------------------------------------------------------------- * * MovePointer2 -- * * This procedure synthesizes EnterNotify and LeaveNotify events * to correctly transfer the pointer from one window to another. * It is different from MovePointer in that no template X event * needs to be supplied; this procedure generates the template * event and calls MovePointer. * * Results: * None. * * Side effects: * Synthesized events may be pushed back onto the event queue. * *---------------------------------------------------------------------- */ static void MovePointer2(sourcePtr, destPtr, mode, leaveEvents, enterEvents) TkWindow *sourcePtr; /* Window currently containing pointer (NULL * means it's not one managed by this * process). */ TkWindow *destPtr; /* Window that is to end up containing the * pointer (NULL means it's not one managed * by this process). */ int mode; /* Mode for enter/leave events, such as * NotifyNormal or NotifyUngrab. */ int leaveEvents; /* Non-zero means generate leave events for the * windows being left. Zero means don't * generate leave events. */ int enterEvents; /* Non-zero means generate enter events for the * windows being entered. Zero means don't * generate enter events. */ { XEvent event; Window dummy1, dummy2; int dummy3, dummy4; TkWindow *winPtr; winPtr = sourcePtr; if ((winPtr == NULL) || (winPtr->window == None)) { winPtr = destPtr; if ((winPtr == NULL) || (winPtr->window == None)) { return; } } event.xcrossing.serial = LastKnownRequestProcessed(winPtr->display); event.xcrossing.send_event = GENERATED_EVENT_MAGIC; event.xcrossing.display = winPtr->display; event.xcrossing.root = RootWindow(winPtr->display, winPtr->screenNum); event.xcrossing.time = TkCurrentTime(winPtr->dispPtr); XQueryPointer(winPtr->display, winPtr->window, &dummy1, &dummy2, &event.xcrossing.x_root, &event.xcrossing.y_root, &dummy3, &dummy4, &event.xcrossing.state); event.xcrossing.mode = mode; event.xcrossing.focus = False; MovePointer(&event, sourcePtr, destPtr, leaveEvents, enterEvents); } /* *---------------------------------------------------------------------- * * TkGrabDeadWindow -- * * This procedure is invoked whenever a window is deleted, so that * grab-related cleanup can be performed. * * Results: * None. * * Side effects: * Various cleanups happen, such as generating events to move the * pointer back to its "natural" window as if an ungrab had been * done. See the code. * *---------------------------------------------------------------------- */ void TkGrabDeadWindow(winPtr) register TkWindow *winPtr; /* Window that is in the process * of being deleted. */ { TkDisplay *dispPtr = winPtr->dispPtr; if (dispPtr->eventualGrabWinPtr == winPtr) { /* * Grab window was deleted. Release the grab. */ Tk_Ungrab((Tk_Window) dispPtr->eventualGrabWinPtr); } else if (dispPtr->buttonWinPtr == winPtr) { ReleaseButtonGrab(dispPtr); } if (dispPtr->serverWinPtr == winPtr) { if (winPtr->flags && TK_TOP_LEVEL) { dispPtr->serverWinPtr = NULL; } else { dispPtr->serverWinPtr = winPtr->parentPtr; } } if (dispPtr->grabWinPtr == winPtr) { dispPtr->grabWinPtr = NULL; } } /* *---------------------------------------------------------------------- * * EatGrabEvents -- * * This procedure is called to eliminate any Enter, Leave, * FocusIn, or FocusOut events in the event queue for a * display that have mode NotifyGrab or NotifyUngrab and * have a serial number no less than a given value. * * Results: * None. * * Side effects: * DispPtr's display gets sync-ed, and some of the events get * removed from its queue. Unaffected events are initially * removed from the queue but they are eventually put back again * in the right order. * *---------------------------------------------------------------------- */ static void EatGrabEvents(dispPtr, serial) TkDisplay *dispPtr; /* Display from which to consume events. */ unsigned int serial; /* Only discard events that have a serial * number at least this great. */ { int numEvents, i, diff, mode; XEvent *events, *eventPtr; XSync(dispPtr->display, False); numEvents = QLength(dispPtr->display); if (numEvents == 0) { return; } events = (XEvent *) ckalloc((unsigned) (numEvents * sizeof(XEvent))); for (i = 0; i < numEvents; i++) { XNextEvent(dispPtr->display, &events[i]); } for (i = numEvents-1, eventPtr = &events[i]; i >= 0; i--, eventPtr--) { /* * The diff caculation is trickier than it may seem. Don't forget * that serial numbers can wrap around, so can't compare the two * serial numbers directly. */ diff = eventPtr->xany.serial - serial; if ((eventPtr->type == EnterNotify) || (eventPtr->type == LeaveNotify)) { mode = eventPtr->xcrossing.mode; } else if ((eventPtr->type == FocusIn) || (eventPtr->type == FocusOut)) { mode = eventPtr->xfocus.mode; } else { mode = NotifyNormal; } if ((mode == NotifyNormal) || (diff < 0)) { XPutBackEvent(dispPtr->display, eventPtr); } } ckfree((char *) events); } /* *---------------------------------------------------------------------- * * QueueGrabWindowChange -- * * This procedure queues a special event in the grab event queue * for dispPtr, which will cause the "grabWinPtr" field for the * display to get modified when the event is processed. This * procedure is needed to make sure that the grab window changes * at the proper time relative to grab-related enter and leave * events that are also in the queue. In particular, this approach * works even when multiple grabs and ungrabs happen back-to-back. * * Results: * None. * * Side effects: * DispPtr->grabWinPtr will be modified later (by TkGrabTriggerProc) * when the event is removed from the grab event queue. * *---------------------------------------------------------------------- */ static void QueueGrabWindowChange(dispPtr, grabWinPtr) TkDisplay *dispPtr; /* Display on which to change the grab * window. */ TkWindow *grabWinPtr; /* Window that is to become the new grab * window (may be NULL). */ { XEvent event; event.xany.display = dispPtr->display; event.xany.send_event = GRAB_WINDOW_EVENT_MAGIC; event.xany.window = (grabWinPtr == NULL) ? None : grabWinPtr->window; TkQueueEvent(dispPtr, &event); dispPtr->eventualGrabWinPtr = grabWinPtr; } /* *---------------------------------------------------------------------- * * FindCommonAncestor -- * * Given two windows, this procedure finds their least common * ancestor and also computes how many levels up this ancestor * is from each of the original windows. * * Results: * If the windows are in different applications or top-level * windows, then NULL is returned and *countPtr1 and *countPtr2 * are set to the depths of the two windows in their respective * top-level windows (1 means the window is a top-level, 2 means * its parent is a top-level, and so on). Otherwise, the return * value is a pointer to the common ancestor and the counts are * set to the distance of winPtr1 and winPtr2 from this ancestor * (1 means they're children, 2 means grand-children, etc.). * * Side effects: * None. * *---------------------------------------------------------------------- */ static TkWindow * FindCommonAncestor(winPtr1, winPtr2, countPtr1, countPtr2) TkWindow *winPtr1; /* First window. May be NULL. */ TkWindow *winPtr2; /* Second window. May be NULL. */ int *countPtr1; /* Store nesting level of winPtr1 within * common ancestor here. */ int *countPtr2; /* Store nesting level of winPtr2 within * common ancestor here. */ { register TkWindow *winPtr; TkWindow *ancestorPtr; int count1, count2, i; /* * Mark winPtr1 and all of its ancestors with a special flag bit. */ if (winPtr1 != NULL) { for (winPtr = winPtr1; ; winPtr = winPtr->parentPtr) { winPtr->flags |= TK_GRAB_FLAG; if (winPtr->flags & TK_TOP_LEVEL) { break; } } } /* * Search upwards from winPtr2 until an ancestor of winPtr1 is * found or a top-level window is reached. */ winPtr = winPtr2; count2 = 0; ancestorPtr = NULL; if (winPtr2 != NULL) { for (; ; count2++, winPtr = winPtr->parentPtr) { if (winPtr->flags & TK_GRAB_FLAG) { ancestorPtr = winPtr; break; } if (winPtr->flags & TK_TOP_LEVEL) { count2++; break; } } } /* * Search upwards from winPtr1 again, clearing the flag bits and * remembering how many levels up we had to go. */ if (winPtr1 == NULL) { count1 = 0; } else { count1 = -1; for (i = 0, winPtr = winPtr1; ; i++, winPtr = winPtr->parentPtr) { winPtr->flags &= ~TK_GRAB_FLAG; if (winPtr == ancestorPtr) { count1 = i; } if (winPtr->flags & TK_TOP_LEVEL) { if (count1 == -1) { count1 = i+1; } break; } } } *countPtr1 = count1; *countPtr2 = count2; return ancestorPtr; }