1596 lines
48 KiB
C
1596 lines
48 KiB
C
/*
|
||
* tkGrab.c --
|
||
*
|
||
* This file provides functions that implement grabs for Tk.
|
||
*
|
||
* Copyright (c) 1992-1994 The Regents of the University of California.
|
||
* Copyright (c) 1994-1997 Sun Microsystems, Inc.
|
||
*
|
||
* See the file "license.terms" for information on usage and redistribution of
|
||
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||
*/
|
||
|
||
#include "tkInt.h"
|
||
|
||
#ifdef _WIN32
|
||
#include "tkWinInt.h"
|
||
#elif !defined(MAC_OSX_TK)
|
||
#include "tkUnixInt.h"
|
||
#endif
|
||
|
||
/*
|
||
* The grab state machine has four states: ungrabbed, button pressed, grabbed,
|
||
* and button pressed while grabbed. In addition, there are three pieces of
|
||
* grab state information: the current grab window, the current restrict
|
||
* window, and whether the mouse is captured.
|
||
*
|
||
* The current grab window specifies the point in the Tk window heirarchy
|
||
* above which pointer events will not be reported. Any window within the
|
||
* subtree below the grab window will continue to receive events as normal.
|
||
* Events outside of the grab tree will be reported to the grab window.
|
||
*
|
||
* If the current restrict window is set, then all pointer events will be
|
||
* reported only to the restrict window. The restrict window is normally set
|
||
* during an automatic button grab.
|
||
*
|
||
* The mouse capture state specifies whether the window system will report
|
||
* mouse events outside of any Tk toplevels. This is set during a global grab
|
||
* or an automatic button grab.
|
||
*
|
||
* The transitions between different states is given in the following table:
|
||
*
|
||
* Event\State U B G GB
|
||
* ----------- -- -- -- --
|
||
* FirstPress B B GB GB
|
||
* Press B B G GB
|
||
* Release U B G GB
|
||
* LastRelease U U G G
|
||
* Grab G G G G
|
||
* Ungrab U B U U
|
||
*
|
||
* Note: U=Ungrabbed, B=Button, G=Grabbed, GB=Grab and Button
|
||
*
|
||
* In addition, the following conditions are always true:
|
||
*
|
||
* State\Variable Grab Restrict Capture
|
||
* -------------- ---- -------- -------
|
||
* Ungrabbed 0 0 0
|
||
* Button 0 1 1
|
||
* Grabbed 1 0 b/g
|
||
* Grab and Button 1 1 1
|
||
*
|
||
* Note: 0 means variable is set to NULL, 1 means variable is set to some
|
||
* window, b/g means the variable is set to a window if a button is currently
|
||
* down or a global grab is in effect.
|
||
*
|
||
* The final complication to all of this is enter and leave events. In order
|
||
* to correctly handle all of the various cases, Tk cannot rely on X
|
||
* enter/leave events in all situations. The following describes the correct
|
||
* sequence of enter and leave events that should be observed by Tk scripts:
|
||
*
|
||
* Event(state) Enter/Leave From -> To
|
||
* ------------ ----------------------
|
||
* LastRelease(B | GB): restrict window -> anc(grab window, event window)
|
||
* Grab(U | B): event window -> anc(grab window, event window)
|
||
* Grab(G): anc(old grab window, event window) ->
|
||
* anc(new grab window, event window)
|
||
* Grab(GB): restrict window -> anc(new grab window, event window)
|
||
* Ungrab(G): anc(grab window, event window) -> event window
|
||
* Ungrab(GB): restrict window -> event window
|
||
*
|
||
* Note: anc(x,y) returns the least ancestor of y that is in the tree of x,
|
||
* terminating at toplevels.
|
||
*/
|
||
|
||
/*
|
||
* The following structure is used to pass information to GrabRestrictProc
|
||
* from EatGrabEvents.
|
||
*/
|
||
|
||
typedef struct {
|
||
Display *display; /* Display from which to discard events. */
|
||
unsigned int serial; /* Serial number with which to compare. */
|
||
} GrabInfo;
|
||
|
||
/*
|
||
* 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_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_TEMP_GLOBAL 4
|
||
|
||
/*
|
||
* The following structure is a Tcl_Event that triggers a change in the
|
||
* grabWinPtr field of a display. This event guarantees that the change occurs
|
||
* in the proper order relative to enter and leave events.
|
||
*/
|
||
|
||
typedef struct NewGrabWinEvent {
|
||
Tcl_Event header; /* Standard information for all Tcl events. */
|
||
TkDisplay *dispPtr; /* Display whose grab window is to change. */
|
||
Window grabWindow; /* New grab window for display. This is
|
||
* recorded instead of a (TkWindow *) because
|
||
* it will allow us to detect cases where the
|
||
* window is destroyed before this event is
|
||
* processed. */
|
||
} NewGrabWinEvent;
|
||
|
||
/*
|
||
* 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_GRAB_EVENT_MAGIC ((Bool) 0x147321ac)
|
||
|
||
/*
|
||
* 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 const unsigned int buttonStates[] = {
|
||
Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask
|
||
};
|
||
|
||
/*
|
||
* Forward declarations for functions declared later in this file:
|
||
*/
|
||
|
||
static void EatGrabEvents(TkDisplay *dispPtr, unsigned int serial);
|
||
static TkWindow * FindCommonAncestor(TkWindow *winPtr1,
|
||
TkWindow *winPtr2, int *countPtr1, int *countPtr2);
|
||
static Tk_RestrictProc GrabRestrictProc;
|
||
static int GrabWinEventProc(Tcl_Event *evPtr, int flags);
|
||
static void MovePointer2(TkWindow *sourcePtr, TkWindow *destPtr,
|
||
int mode, int leaveEvents, int EnterEvents);
|
||
static void QueueGrabWindowChange(TkDisplay *dispPtr,
|
||
TkWindow *grabWinPtr);
|
||
static void ReleaseButtonGrab(TkDisplay *dispPtr);
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* Tk_GrabObjCmd --
|
||
*
|
||
* This function 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_GrabObjCmd(
|
||
ClientData clientData, /* Main window associated with interpreter. */
|
||
Tcl_Interp *interp, /* Current interpreter. */
|
||
int objc, /* Number of arguments. */
|
||
Tcl_Obj *const objv[]) /* Argument objects. */
|
||
{
|
||
int globalGrab;
|
||
Tk_Window tkwin;
|
||
TkDisplay *dispPtr;
|
||
const char *arg;
|
||
int index;
|
||
int len;
|
||
static const char *const optionStrings[] = {
|
||
"current", "release", "set", "status", NULL
|
||
};
|
||
static const char *const flagStrings[] = {
|
||
"-global", NULL
|
||
};
|
||
enum options {
|
||
GRABCMD_CURRENT, GRABCMD_RELEASE, GRABCMD_SET, GRABCMD_STATUS
|
||
};
|
||
|
||
if (objc < 2) {
|
||
/*
|
||
* Can't use Tcl_WrongNumArgs here because we want the message to
|
||
* read:
|
||
* wrong # args: should be "cmd ?-global? window" or "cmd option
|
||
* ?arg ...?"
|
||
* We can fake it with Tcl_WrongNumArgs if we assume the command name
|
||
* is "grab", but if it has been aliased, the message will be
|
||
* incorrect.
|
||
*/
|
||
|
||
Tcl_WrongNumArgs(interp, 1, objv, "?-global? window");
|
||
Tcl_AppendResult(interp, " or \"", Tcl_GetString(objv[0]),
|
||
" option ?arg ...?\"", NULL);
|
||
/* This API not exposed:
|
||
*
|
||
((Interp *) interp)->flags |= INTERP_ALTERNATE_WRONG_ARGS;
|
||
Tcl_WrongNumArgs(interp, 1, objv, "option ?arg ...?");
|
||
*/
|
||
return TCL_ERROR;
|
||
}
|
||
|
||
/*
|
||
* First check for a window name or "-global" as the first argument.
|
||
*/
|
||
|
||
arg = Tcl_GetStringFromObj(objv[1], &len);
|
||
if (arg[0] == '.') {
|
||
/* [grab window] */
|
||
if (objc != 2) {
|
||
Tcl_WrongNumArgs(interp, 1, objv, "?-global? window");
|
||
return TCL_ERROR;
|
||
}
|
||
tkwin = Tk_NameToWindow(interp, arg, clientData);
|
||
if (tkwin == NULL) {
|
||
return TCL_ERROR;
|
||
}
|
||
return Tk_Grab(interp, tkwin, 0);
|
||
} else if (arg[0] == '-' && len > 1) {
|
||
if (Tcl_GetIndexFromObj(interp, objv[1], flagStrings, "option", 0,
|
||
&index) != TCL_OK) {
|
||
return TCL_ERROR;
|
||
}
|
||
|
||
/* [grab -global window] */
|
||
if (objc != 3) {
|
||
Tcl_WrongNumArgs(interp, 1, objv, "?-global? window");
|
||
return TCL_ERROR;
|
||
}
|
||
tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[2]), clientData);
|
||
if (tkwin == NULL) {
|
||
return TCL_ERROR;
|
||
}
|
||
return Tk_Grab(interp, tkwin, 1);
|
||
}
|
||
|
||
/*
|
||
* First argument is not a window name and not "-global", find out which
|
||
* option it is.
|
||
*/
|
||
|
||
if (Tcl_GetIndexFromObj(interp, objv[1], optionStrings, "option", 0,
|
||
&index) != TCL_OK) {
|
||
return TCL_ERROR;
|
||
}
|
||
|
||
switch ((enum options) index) {
|
||
case GRABCMD_CURRENT:
|
||
/* [grab current ?window?] */
|
||
if (objc > 3) {
|
||
Tcl_WrongNumArgs(interp, 1, objv, "current ?window?");
|
||
return TCL_ERROR;
|
||
}
|
||
if (objc == 3) {
|
||
tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[2]),
|
||
clientData);
|
||
if (tkwin == NULL) {
|
||
return TCL_ERROR;
|
||
}
|
||
dispPtr = ((TkWindow *) tkwin)->dispPtr;
|
||
if (dispPtr->eventualGrabWinPtr != NULL) {
|
||
Tcl_SetObjResult(interp, TkNewWindowObj((Tk_Window)
|
||
dispPtr->eventualGrabWinPtr));
|
||
}
|
||
} else {
|
||
Tcl_Obj *resultObj = Tcl_NewObj();
|
||
|
||
for (dispPtr = TkGetDisplayList(); dispPtr != NULL;
|
||
dispPtr = dispPtr->nextPtr) {
|
||
if (dispPtr->eventualGrabWinPtr != NULL) {
|
||
Tcl_ListObjAppendElement(NULL, resultObj, TkNewWindowObj(
|
||
(Tk_Window) dispPtr->eventualGrabWinPtr));
|
||
}
|
||
}
|
||
Tcl_SetObjResult(interp, resultObj);
|
||
}
|
||
return TCL_OK;
|
||
|
||
case GRABCMD_RELEASE:
|
||
/* [grab release window] */
|
||
if (objc != 3) {
|
||
Tcl_WrongNumArgs(interp, 1, objv, "release window");
|
||
return TCL_ERROR;
|
||
}
|
||
tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[2]), clientData);
|
||
if (tkwin == NULL) {
|
||
Tcl_ResetResult(interp);
|
||
} else {
|
||
Tk_Ungrab(tkwin);
|
||
}
|
||
break;
|
||
|
||
case GRABCMD_SET:
|
||
/* [grab set ?-global? window] */
|
||
if ((objc != 3) && (objc != 4)) {
|
||
Tcl_WrongNumArgs(interp, 1, objv, "set ?-global? window");
|
||
return TCL_ERROR;
|
||
}
|
||
if (objc == 3) {
|
||
globalGrab = 0;
|
||
tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[2]),
|
||
clientData);
|
||
} else {
|
||
globalGrab = 1;
|
||
|
||
/*
|
||
* We could just test the argument by hand instead of using
|
||
* Tcl_GetIndexFromObj; the benefit of using the function is that
|
||
* it sets up the error message for us, so we are certain to be
|
||
* consistant with the rest of Tcl.
|
||
*/
|
||
|
||
if (Tcl_GetIndexFromObj(interp, objv[2], flagStrings, "option",
|
||
0, &index) != TCL_OK) {
|
||
return TCL_ERROR;
|
||
}
|
||
tkwin = Tk_NameToWindow(interp, Tcl_GetString(objv[3]),
|
||
clientData);
|
||
}
|
||
if (tkwin == NULL) {
|
||
return TCL_ERROR;
|
||
}
|
||
return Tk_Grab(interp, tkwin, globalGrab);
|
||
|
||
case GRABCMD_STATUS: {
|
||
/* [grab status window] */
|
||
TkWindow *winPtr;
|
||
const char *statusString;
|
||
|
||
if (objc != 3) {
|
||
Tcl_WrongNumArgs(interp, 1, objv, "status window");
|
||
return TCL_ERROR;
|
||
}
|
||
winPtr = (TkWindow *) Tk_NameToWindow(interp, Tcl_GetString(objv[2]),
|
||
clientData);
|
||
if (winPtr == NULL) {
|
||
return TCL_ERROR;
|
||
}
|
||
dispPtr = winPtr->dispPtr;
|
||
if (dispPtr->eventualGrabWinPtr != winPtr) {
|
||
statusString = "none";
|
||
} else if (dispPtr->grabFlags & GRAB_GLOBAL) {
|
||
statusString = "global";
|
||
} else {
|
||
statusString = "local";
|
||
}
|
||
Tcl_SetObjResult(interp, Tcl_NewStringObj(statusString, -1));
|
||
break;
|
||
}
|
||
}
|
||
|
||
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 the
|
||
* interp's 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(
|
||
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, numTries;
|
||
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) {
|
||
goto alreadyGrabbed;
|
||
}
|
||
Tk_Ungrab((Tk_Window) dispPtr->eventualGrabWinPtr);
|
||
}
|
||
|
||
Tk_MakeWindowExist(tkwin);
|
||
#ifndef MAC_OSX_TK
|
||
if (!grabGlobal)
|
||
#else
|
||
if (0)
|
||
#endif /* MAC_OSX_TK */
|
||
{
|
||
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) {
|
||
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);
|
||
|
||
/*
|
||
* Another tricky point: there are races with some window managers
|
||
* that can cause grabs to fail because the window manager hasn't
|
||
* released its grab quickly enough. To work around this problem,
|
||
* retry a few times after AlreadyGrabbed errors to give the grab
|
||
* release enough time to register with the server.
|
||
*/
|
||
|
||
grabResult = 0; /* Needed only to prevent gcc compiler
|
||
* warnings. */
|
||
for (numTries = 0; numTries < 10; numTries++) {
|
||
grabResult = XGrabPointer(dispPtr->display, winPtr->window,
|
||
True, ButtonPressMask|ButtonReleaseMask|ButtonMotionMask
|
||
|PointerMotionMask, GrabModeAsync, GrabModeAsync, None,
|
||
None, CurrentTime);
|
||
if (grabResult != AlreadyGrabbed) {
|
||
break;
|
||
}
|
||
Tcl_Sleep(100);
|
||
}
|
||
if (grabResult != 0) {
|
||
goto grabError;
|
||
}
|
||
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;
|
||
|
||
grabError:
|
||
if (grabResult == GrabNotViewable) {
|
||
Tcl_SetObjResult(interp, Tcl_NewStringObj(
|
||
"grab failed: window not viewable", -1));
|
||
Tcl_SetErrorCode(interp, "TK", "GRAB", "UNVIEWABLE", NULL);
|
||
} else if (grabResult == AlreadyGrabbed) {
|
||
alreadyGrabbed:
|
||
Tcl_SetObjResult(interp, Tcl_NewStringObj(
|
||
"grab failed: another application has grab", -1));
|
||
Tcl_SetErrorCode(interp, "TK", "GRAB", "GRABBED", NULL);
|
||
} else if (grabResult == GrabFrozen) {
|
||
Tcl_SetObjResult(interp, Tcl_NewStringObj(
|
||
"grab failed: keyboard or pointer frozen", -1));
|
||
Tcl_SetErrorCode(interp, "TK", "GRAB", "FROZEN", NULL);
|
||
} else if (grabResult == GrabInvalidTime) {
|
||
Tcl_SetObjResult(interp, Tcl_NewStringObj(
|
||
"grab failed: invalid time", -1));
|
||
Tcl_SetErrorCode(interp, "TK", "GRAB", "BAD_TIME", NULL);
|
||
} else {
|
||
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
|
||
"grab failed for unknown reason (code %d)", grabResult));
|
||
Tcl_SetErrorCode(interp, "TK", "GRAB", "UNKNOWN", NULL);
|
||
}
|
||
return TCL_ERROR;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* 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(
|
||
Tk_Window tkwin) /* Window whose grab should be released. */
|
||
{
|
||
TkDisplay *dispPtr;
|
||
TkWindow *grabWinPtr, *winPtr;
|
||
unsigned int serial;
|
||
|
||
grabWinPtr = (TkWindow *) tkwin;
|
||
dispPtr = grabWinPtr->dispPtr;
|
||
if (grabWinPtr != dispPtr->eventualGrabWinPtr) {
|
||
return;
|
||
}
|
||
ReleaseButtonGrab(dispPtr);
|
||
QueueGrabWindowChange(dispPtr, 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 function 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(
|
||
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 function 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 function 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(
|
||
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. */
|
||
|
||
/*
|
||
* Collect information about the grab (if any).
|
||
*/
|
||
|
||
switch (TkGrabState(winPtr)) {
|
||
case TK_GRAB_IN_TREE:
|
||
appGrabbed = 1;
|
||
break;
|
||
case TK_GRAB_ANCESTOR:
|
||
appGrabbed = 1;
|
||
outsideGrabTree = 1;
|
||
ancestorOfGrab = 1;
|
||
break;
|
||
case TK_GRAB_EXCLUDED:
|
||
appGrabbed = 1;
|
||
outsideGrabTree = 1;
|
||
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_GRAB_EVENT_MAGIC) {
|
||
if ((eventPtr->type == LeaveNotify) &&
|
||
(winPtr->flags & TK_TOP_HIERARCHY)) {
|
||
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) {
|
||
TkChangeEventWindow(eventPtr, winPtr2);
|
||
Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_HEAD);
|
||
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)) {
|
||
if (outsideGrabTree) {
|
||
TkChangeEventWindow(eventPtr, dispPtr->grabWinPtr);
|
||
Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_HEAD);
|
||
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) {
|
||
TkChangeEventWindow(eventPtr, winPtr2);
|
||
Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_HEAD);
|
||
return 0; /* Note 3. */
|
||
}
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* TkChangeEventWindow --
|
||
*
|
||
* 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.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
TkChangeEventWindow(
|
||
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_HIERARCHY) {
|
||
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.height + 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;
|
||
}
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* TkInOutEvents --
|
||
*
|
||
* This function synthesizes EnterNotify and LeaveNotify events to
|
||
* correctly transfer the pointer from one window to another. It can also
|
||
* be used to generate FocusIn and FocusOut events to move the input
|
||
* focus.
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side effects:
|
||
* Synthesized events may be pushed back onto the event queue. The event
|
||
* pointed to by eventPtr is modified.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
void
|
||
TkInOutEvents(
|
||
XEvent *eventPtr, /* A template X event. Must have all fields
|
||
* properly set except for type, window,
|
||
* subwindow, x, y, detail, and same_screen.
|
||
* (Not all of these fields are valid for
|
||
* FocusIn/FocusOut events; x_root and y_root
|
||
* must be valid for Enter/Leave events, even
|
||
* though x and y needn't be valid). */
|
||
TkWindow *sourcePtr, /* Window that used to have the pointer or
|
||
* focus (NULL means it was not in a window
|
||
* managed by this process). */
|
||
TkWindow *destPtr, /* Window that is to end up with the pointer
|
||
* or focus (NULL means it's not one managed
|
||
* by this process). */
|
||
int leaveType, /* Type of events to generate for windows
|
||
* being left (LeaveNotify or FocusOut). 0
|
||
* means don't generate leave events. */
|
||
int enterType, /* Type of events to generate for windows
|
||
* being entered (EnterNotify or FocusIn). 0
|
||
* means don't generate enter events. */
|
||
Tcl_QueuePosition position) /* Position at which events are added to the
|
||
* system event queue. */
|
||
{
|
||
register TkWindow *winPtr;
|
||
int upLevels, downLevels, i, j, focus;
|
||
|
||
/*
|
||
* 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;
|
||
}
|
||
if ((leaveType == FocusOut) || (enterType == FocusIn)) {
|
||
focus = 1;
|
||
} else {
|
||
focus = 0;
|
||
}
|
||
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; \
|
||
if (focus) { \
|
||
eventPtr->xfocus.window = w->window; \
|
||
eventPtr->xfocus.detail = d; \
|
||
} else { \
|
||
eventPtr->xcrossing.detail = d; \
|
||
TkChangeEventWindow(eventPtr, w); \
|
||
} \
|
||
Tk_QueueWindowEvent(eventPtr, position); \
|
||
}
|
||
|
||
if (downLevels == 0) {
|
||
/*
|
||
* SourcePtr is an inferior of destPtr.
|
||
*/
|
||
|
||
if (leaveType != 0) {
|
||
QUEUE(sourcePtr, leaveType, NotifyAncestor);
|
||
for (winPtr = sourcePtr->parentPtr, i = upLevels-1; i > 0;
|
||
winPtr = winPtr->parentPtr, i--) {
|
||
QUEUE(winPtr, leaveType, NotifyVirtual);
|
||
}
|
||
}
|
||
if ((enterType != 0) && (destPtr != NULL)) {
|
||
QUEUE(destPtr, enterType, NotifyInferior);
|
||
}
|
||
} else if (upLevels == 0) {
|
||
/*
|
||
* DestPtr is an inferior of sourcePtr.
|
||
*/
|
||
|
||
if ((leaveType != 0) && (sourcePtr != NULL)) {
|
||
QUEUE(sourcePtr, leaveType, NotifyInferior);
|
||
}
|
||
if (enterType != 0) {
|
||
for (i = downLevels-1; i > 0; i--) {
|
||
for (winPtr = destPtr->parentPtr, j = 1; j < i;
|
||
winPtr = winPtr->parentPtr, j++) {
|
||
/* empty */
|
||
}
|
||
QUEUE(winPtr, enterType, NotifyVirtual);
|
||
}
|
||
if (destPtr != NULL) {
|
||
QUEUE(destPtr, enterType, NotifyAncestor);
|
||
}
|
||
}
|
||
} else {
|
||
/*
|
||
* Non-linear: neither window is an inferior of the other.
|
||
*/
|
||
|
||
if (leaveType != 0) {
|
||
QUEUE(sourcePtr, leaveType, NotifyNonlinear);
|
||
for (winPtr = sourcePtr->parentPtr, i = upLevels-1; i > 0;
|
||
winPtr = winPtr->parentPtr, i--) {
|
||
QUEUE(winPtr, leaveType, NotifyNonlinearVirtual);
|
||
}
|
||
}
|
||
if (enterType != 0) {
|
||
for (i = downLevels-1; i > 0; i--) {
|
||
for (winPtr = destPtr->parentPtr, j = 1; j < i;
|
||
winPtr = winPtr->parentPtr, j++) {
|
||
}
|
||
QUEUE(winPtr, enterType, NotifyNonlinearVirtual);
|
||
}
|
||
if (destPtr != NULL) {
|
||
QUEUE(destPtr, enterType, NotifyNonlinear);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* MovePointer2 --
|
||
*
|
||
* This function synthesizes EnterNotify and LeaveNotify events to
|
||
* correctly transfer the pointer from one window to another. It is
|
||
* different from TkInOutEvents in that no template X event needs to be
|
||
* supplied; this function generates the template event and calls
|
||
* TkInOutEvents.
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side effects:
|
||
* Synthesized events may be pushed back onto the event queue.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
static void
|
||
MovePointer2(
|
||
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_GRAB_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;
|
||
TkInOutEvents(&event, sourcePtr, destPtr, (leaveEvents) ? LeaveNotify : 0,
|
||
(enterEvents) ? EnterNotify : 0, TCL_QUEUE_MARK);
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* TkGrabDeadWindow --
|
||
*
|
||
* This function 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(
|
||
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_HIERARCHY) {
|
||
dispPtr->serverWinPtr = NULL;
|
||
} else {
|
||
dispPtr->serverWinPtr = winPtr->parentPtr;
|
||
}
|
||
}
|
||
if (dispPtr->grabWinPtr == winPtr) {
|
||
dispPtr->grabWinPtr = NULL;
|
||
}
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* EatGrabEvents --
|
||
*
|
||
* This function 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 and are not generated by the grab module.
|
||
*
|
||
* Results:
|
||
* None.
|
||
*
|
||
* Side effects:
|
||
* DispPtr's display gets sync-ed, and some of the events get removed
|
||
* from the Tk event queue.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
static void
|
||
EatGrabEvents(
|
||
TkDisplay *dispPtr, /* Display from which to consume events. */
|
||
unsigned int serial) /* Only discard events that have a serial
|
||
* number at least this great. */
|
||
{
|
||
Tk_RestrictProc *prevProc;
|
||
GrabInfo info;
|
||
ClientData prevArg;
|
||
|
||
info.display = dispPtr->display;
|
||
info.serial = serial;
|
||
TkpSync(info.display);
|
||
prevProc = Tk_RestrictEvents(GrabRestrictProc, &info, &prevArg);
|
||
while (Tcl_ServiceEvent(TCL_WINDOW_EVENTS)) {
|
||
/* EMPTY */
|
||
}
|
||
Tk_RestrictEvents(prevProc, prevArg, &prevArg);
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* GrabRestrictProc --
|
||
*
|
||
* A Tk_RestrictProc used by EatGrabEvents to eliminate any Enter, Leave,
|
||
* FocusIn, or FocusOut events in the event queue for a display that has
|
||
* mode NotifyGrab or NotifyUngrab and have a serial number no less than
|
||
* a given value.
|
||
*
|
||
* Results:
|
||
* Returns either TK_DISCARD_EVENT or TK_DEFER_EVENT.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
static Tk_RestrictAction
|
||
GrabRestrictProc(
|
||
ClientData arg,
|
||
XEvent *eventPtr)
|
||
{
|
||
GrabInfo *info = arg;
|
||
int mode, diff;
|
||
|
||
/*
|
||
* 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 - info->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 ((info->display != eventPtr->xany.display) || (mode == NotifyNormal)
|
||
|| (diff < 0)) {
|
||
return TK_DEFER_EVENT;
|
||
} else {
|
||
return TK_DISCARD_EVENT;
|
||
}
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* QueueGrabWindowChange --
|
||
*
|
||
* This function queues a special event in the Tcl event queue, which
|
||
* will cause the "grabWinPtr" field for the display to get modified when
|
||
* the event is processed. This 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 GrabWinEventProc) when
|
||
* the event is removed from the grab event queue.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
static void
|
||
QueueGrabWindowChange(
|
||
TkDisplay *dispPtr, /* Display on which to change the grab
|
||
* window. */
|
||
TkWindow *grabWinPtr) /* Window that is to become the new grab
|
||
* window (may be NULL). */
|
||
{
|
||
NewGrabWinEvent *grabEvPtr;
|
||
|
||
grabEvPtr = ckalloc(sizeof(NewGrabWinEvent));
|
||
grabEvPtr->header.proc = GrabWinEventProc;
|
||
grabEvPtr->dispPtr = dispPtr;
|
||
if (grabWinPtr == NULL) {
|
||
grabEvPtr->grabWindow = None;
|
||
} else {
|
||
grabEvPtr->grabWindow = grabWinPtr->window;
|
||
}
|
||
Tcl_QueueEvent(&grabEvPtr->header, TCL_QUEUE_MARK);
|
||
dispPtr->eventualGrabWinPtr = grabWinPtr;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* GrabWinEventProc --
|
||
*
|
||
* This function is invoked as a handler for Tcl_Events of type
|
||
* NewGrabWinEvent. It updates the current grab window field in a
|
||
* display.
|
||
*
|
||
* Results:
|
||
* Returns 1 if the event was processed, 0 if it should be deferred for
|
||
* processing later.
|
||
*
|
||
* Side effects:
|
||
* The grabWinPtr field is modified in the display associated with the
|
||
* event.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
static int
|
||
GrabWinEventProc(
|
||
Tcl_Event *evPtr, /* Event of type NewGrabWinEvent. */
|
||
int flags) /* Flags argument to Tk_DoOneEvent: indicates
|
||
* what kinds of events are being processed
|
||
* right now. */
|
||
{
|
||
NewGrabWinEvent *grabEvPtr = (NewGrabWinEvent *) evPtr;
|
||
|
||
grabEvPtr->dispPtr->grabWinPtr = (TkWindow *) Tk_IdToWindow(
|
||
grabEvPtr->dispPtr->display, grabEvPtr->grabWindow);
|
||
return 1;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* FindCommonAncestor --
|
||
*
|
||
* Given two windows, this function 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(
|
||
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 != NULL; winPtr = winPtr->parentPtr) {
|
||
winPtr->flags |= TK_GRAB_FLAG;
|
||
if (winPtr->flags & TK_TOP_HIERARCHY) {
|
||
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 (; winPtr != NULL; count2++, winPtr = winPtr->parentPtr) {
|
||
if (winPtr->flags & TK_GRAB_FLAG) {
|
||
ancestorPtr = winPtr;
|
||
break;
|
||
}
|
||
if (winPtr->flags & TK_TOP_HIERARCHY) {
|
||
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; winPtr != NULL;
|
||
i++, winPtr = winPtr->parentPtr) {
|
||
winPtr->flags &= ~TK_GRAB_FLAG;
|
||
if (winPtr == ancestorPtr) {
|
||
count1 = i;
|
||
}
|
||
if (winPtr->flags & TK_TOP_HIERARCHY) {
|
||
if (count1 == -1) {
|
||
count1 = i+1;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
*countPtr1 = count1;
|
||
*countPtr2 = count2;
|
||
return ancestorPtr;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* TkPositionInTree --
|
||
*
|
||
* Compute where the given window is relative to a particular subtree of
|
||
* the window hierarchy.
|
||
*
|
||
* Results:
|
||
* Returns TK_GRAB_IN_TREE if the window is contained in the subtree.
|
||
* Returns TK_GRAB_ANCESTOR if the window is an ancestor of the subtree,
|
||
* in the same toplevel. Otherwise it returns TK_GRAB_EXCLUDED.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
int
|
||
TkPositionInTree(
|
||
TkWindow *winPtr, /* Window to be checked. */
|
||
TkWindow *treePtr) /* Root of tree to compare against. */
|
||
{
|
||
TkWindow *winPtr2;
|
||
|
||
for (winPtr2 = winPtr; winPtr2 != treePtr;
|
||
winPtr2 = winPtr2->parentPtr) {
|
||
if (winPtr2 == NULL) {
|
||
for (winPtr2 = treePtr; winPtr2 != NULL;
|
||
winPtr2 = winPtr2->parentPtr) {
|
||
if (winPtr2 == winPtr) {
|
||
return TK_GRAB_ANCESTOR;
|
||
}
|
||
if (winPtr2->flags & TK_TOP_HIERARCHY) {
|
||
break;
|
||
}
|
||
}
|
||
return TK_GRAB_EXCLUDED;
|
||
}
|
||
}
|
||
return TK_GRAB_IN_TREE;
|
||
}
|
||
|
||
/*
|
||
*----------------------------------------------------------------------
|
||
*
|
||
* TkGrabState --
|
||
*
|
||
* Given a window, this function returns a value that indicates the grab
|
||
* state of the application relative to the window.
|
||
*
|
||
* Results:
|
||
* The return value is one of three things:
|
||
* TK_GRAB_NONE - no grab is in effect.
|
||
* TK_GRAB_IN_TREE - there is a grab in effect, and winPtr is in
|
||
* the grabbed subtree.
|
||
* TK_GRAB_ANCESTOR - there is a grab in effect; winPtr is an
|
||
* ancestor of the grabbed window, in the same
|
||
* toplevel.
|
||
* TK_GRAB_EXCLUDED - there is a grab in effect; winPtr is outside
|
||
* the tree of the grab and is not an ancestor of
|
||
* the grabbed window in the same toplevel.
|
||
*
|
||
* Side effects:
|
||
* None.
|
||
*
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
|
||
int
|
||
TkGrabState(
|
||
TkWindow *winPtr) /* Window for which grab information is
|
||
* needed. */
|
||
{
|
||
TkWindow *grabWinPtr = winPtr->dispPtr->grabWinPtr;
|
||
|
||
if (grabWinPtr == NULL) {
|
||
return TK_GRAB_NONE;
|
||
}
|
||
if ((winPtr->mainPtr != grabWinPtr->mainPtr)
|
||
&& !(winPtr->dispPtr->grabFlags & GRAB_GLOBAL)) {
|
||
return TK_GRAB_NONE;
|
||
}
|
||
|
||
return TkPositionInTree(winPtr, grabWinPtr);
|
||
}
|
||
|
||
/*
|
||
* Local Variables:
|
||
* mode: c
|
||
* c-basic-offset: 4
|
||
* fill-column: 78
|
||
* End:
|
||
*/
|