/[dtapublic]/projs/dtats/trunk/shared_source/c_tk_base_7_5_w_mods/tkgrab.c

Diff of /projs/dtats/trunk/shared_source/c_tk_base_7_5_w_mods/tkgrab.c

Parent Directory | Revision Log | View Patch Patch

-revision 69 by dashley,
Sat Nov  5 10:54:17 2016 UTC
+revision 71 by dashley,
Sat Nov  5 11:07:06 2016 UTC
 Line 1
  /* $Header$ */
  /*
   * tkGrab.c --
   *
   *      This file provides procedures 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.
   *
   * RCS: @(#) $Id: tkgrab.c,v 1.1.1.1 2001/06/13 05:01:40 dtashley Exp $
   */
  #include "tkPort.h"
  #include "tkInt.h"
  #if !defined(__WIN32__) && !defined(MAC_TCL)
  #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_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 unsigned int buttonStates[] = {
      Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask
  };
  /*
   * Forward declarations for procedures declared later in this file:
   */
  static void             EatGrabEvents _ANSI_ARGS_((TkDisplay *dispPtr,
                              unsigned int serial));
  static TkWindow *       FindCommonAncestor _ANSI_ARGS_((TkWindow *winPtr1,
                              TkWindow *winPtr2, int *countPtr1,
                              int *countPtr2));
  static Tk_RestrictAction GrabRestrictProc _ANSI_ARGS_((ClientData arg,
                              XEvent *eventPtr));
  static int              GrabWinEventProc _ANSI_ARGS_((Tcl_Event *evPtr,
                              int flags));
  static void             MovePointer2 _ANSI_ARGS_((TkWindow *sourcePtr,
                              TkWindow *destPtr, int mode, int leaveEvents,
                              int EnterEvents));
  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, c;
      Tk_Window tkwin;
      TkDisplay *dispPtr;
      size_t length;
      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) {
                  Tcl_SetResult(interp, dispPtr->eventualGrabWinPtr->pathName,
                          TCL_STATIC);
              }
          } else {
              for (dispPtr = TkGetDisplayList(); 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 != 3) && (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) {
              Tcl_SetResult(interp, "none", TCL_STATIC);
          } else if (dispPtr->grabFlags & GRAB_GLOBAL) {
              Tcl_SetResult(interp, "global", TCL_STATIC);
          } else {
              Tcl_SetResult(interp, "local", TCL_STATIC);
          }
      } 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 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(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, 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) {
              alreadyGrabbed:
              Tcl_SetResult(interp, "grab failed: another application has grab",
                      TCL_STATIC);
              return TCL_ERROR;
          }
          Tk_Ungrab((Tk_Window) dispPtr->eventualGrabWinPtr);
      }
      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);
          /*
           * 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) {
              grabError:
              if (grabResult == GrabNotViewable) {
                  Tcl_SetResult(interp, "grab failed: window not viewable",
                          TCL_STATIC);
              } else if (grabResult == AlreadyGrabbed) {
                  goto alreadyGrabbed;
              } else if (grabResult == GrabFrozen) {
                  Tcl_SetResult(interp,
                          "grab failed: keyboard or pointer frozen", TCL_STATIC);
              } else if (grabResult == GrabInvalidTime) {
                  Tcl_SetResult(interp, "grab failed: invalid time",
                          TCL_STATIC);
              } else {
                  char msg[64 + TCL_INTEGER_SPACE];
                  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 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, (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. */
      /*
       * 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_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) {
              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) == 0) {
                  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(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.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 procedure 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(eventPtr, sourcePtr, destPtr, leaveType, enterType, position)
      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++) {
                  }
                  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 procedure 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 procedure generates the template
   *      event and calls TkInOutEvents.
   *
   * 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;
      TkInOutEvents(&event, sourcePtr, destPtr, (leaveEvents) ? LeaveNotify : 0,
              (enterEvents) ? EnterNotify : 0, TCL_QUEUE_MARK);
  }
  /*
   *----------------------------------------------------------------------
   *
   * 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 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(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. */
  {
      Tk_RestrictProc *oldProc;
      GrabInfo info;
      ClientData oldArg, dummy;
      info.display = dispPtr->display;
      info.serial = serial;
      TkpSync(info.display);
      oldProc = Tk_RestrictEvents(GrabRestrictProc, (ClientData)&info, &oldArg);
      while (Tcl_ServiceEvent(TCL_WINDOW_EVENTS)) {
      }
      Tk_RestrictEvents(oldProc, oldArg, &dummy);
  }
  /*
   *----------------------------------------------------------------------
   *
   * 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(arg, eventPtr)
      ClientData arg;
      XEvent *eventPtr;
  {
      GrabInfo *info = (GrabInfo *) 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 procedure 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(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). */
  {
      NewGrabWinEvent *grabEvPtr;
      grabEvPtr = (NewGrabWinEvent *) 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 procedure 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(evPtr, flags)
      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 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 != NULL; 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 (; winPtr != NULL; 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; winPtr != NULL;
                  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;
  }
  /*
   *----------------------------------------------------------------------
   *
   * 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(winPtr, treePtr)
      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_LEVEL) {
                      break;
                  }
              }
              return TK_GRAB_EXCLUDED;
          }
      }
      return TK_GRAB_IN_TREE;
  }
  /*
   *----------------------------------------------------------------------
   *
   * TkGrabState --
   *
   *      Given a window, this procedure 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(winPtr)
      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);
  }
  /* End of tkgrab.c */

 Legend:



Removed from v.69
 


changed lines


 
Added in v.71
 Legend:



Removed from v.69
 


changed lines


 
Added in v.71
-Removed from v.69
+Added in v.71

dashley@gmail.com	ViewVC Help
Powered by ViewVC 1.1.25