/[dtapublic]/projs/trunk/shared_source/c_tk_base_7_5_w_mods/tkfocus.c

Diff of /projs/trunk/shared_source/c_tk_base_7_5_w_mods/tkfocus.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$ */
  /*
   * tkFocus.c --
   *
   *      This file contains procedures that manage the input
   *      focus for Tk.
   *
   * Copyright (c) 1990-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: tkfocus.c,v 1.1.1.1 2001/06/13 05:00:25 dtashley Exp $
   */
  #include "tkInt.h"
  #include "tkPort.h"
  /*
   * For each top-level window that has ever received the focus, there
   * is a record of the following type:
   */
  typedef struct TkToplevelFocusInfo {
      TkWindow *topLevelPtr;      /* Information about top-level window. */
      TkWindow *focusWinPtr;      /* The next time the focus comes to this
                                   * top-level, it will be given to this
                                   * window. */
      struct TkToplevelFocusInfo *nextPtr;
                                  /* Next in list of all toplevel focus records
                                   * for a given application. */
  } ToplevelFocusInfo;
  /*
   * One of the following structures exists for each display used by
   * each application.  These are linked together from the TkMainInfo
   * structure.  These structures are needed because it isn't
   * sufficient to store a single piece of focus information in each
   * display or in each application: we need the cross-product.
   * There needs to be separate information for each display, because
   * it's possible to have multiple focus windows active simultaneously
   * on different displays.  There also needs to be separate information
   * for each application, because of embedding: if an embedded
   * application has the focus, its container application also has
   * the focus.  Thus we keep a list of structures for each application:
   * the same display can appear in structures for several applications
   * at once.
   */
  typedef struct TkDisplayFocusInfo {
      TkDisplay *dispPtr;         /* Display that this information pertains
                                   * to. */
      struct TkWindow *focusWinPtr;
                                  /* Window that currently has the focus for
                                   * this application on this display, or NULL
                                   * if none. */
      struct TkWindow *focusOnMapPtr;
                                  /* This points to a toplevel window that is
                                   * supposed to receive the X input focus as
                                   * soon as it is mapped (needed to handle the
                                   * fact that X won't allow the focus on an
                                   * unmapped window).  NULL means no delayed
                                   * focus op in progress for this display. */
      int forceFocus;             /* Associated with focusOnMapPtr:  non-zero
                                   * means claim the focus even if some other
                                   * application currently has it. */
      unsigned long focusSerial;  /* Serial number of last request this
                                   * application made to change the focus on
                                   * this display.  Used to identify stale
                                   * focus notifications coming from the
                                   * X server. */
      struct TkDisplayFocusInfo *nextPtr;
                                  /* Next in list of all display focus
                                   * records for a given application. */
  } DisplayFocusInfo;
  /*
   * The following magic value is stored in the "send_event" field of
   * FocusIn and FocusOut 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) 0x547321ac)
  /*
   * Forward declarations for procedures defined in this file:
   */
  static DisplayFocusInfo *FindDisplayFocusInfo _ANSI_ARGS_((TkMainInfo *mainPtr,
                              TkDisplay *dispPtr));
  static void             FocusMapProc _ANSI_ARGS_((ClientData clientData,
                              XEvent *eventPtr));
  static void             GenerateFocusEvents _ANSI_ARGS_((TkWindow *sourcePtr,
                              TkWindow *destPtr));
  /*
   *--------------------------------------------------------------
   *
   * Tk_FocusObjCmd --
   *
   *      This procedure is invoked to process the "focus" Tcl command.
   *      See the user documentation for details on what it does.
   *
   * Results:
   *      A standard Tcl result.
   *
   * Side effects:
   *      See the user documentation.
   *
   *--------------------------------------------------------------
   */
  int
  Tk_FocusObjCmd(clientData, interp, objc, objv)
      ClientData clientData;      /* Main window associated with
                                   * interpreter. */
      Tcl_Interp *interp;         /* Current interpreter. */
      int objc;                   /* Number of arguments. */
      Tcl_Obj *CONST objv[];      /* Argument objects. */
  {
      static char *focusOptions[] = {"-displayof", "-force", "-lastfor",
                                     (char *) NULL};
      Tk_Window tkwin = (Tk_Window) clientData;
      TkWindow *winPtr = (TkWindow *) clientData;
      TkWindow *newPtr, *focusWinPtr, *topLevelPtr;
      ToplevelFocusInfo *tlFocusPtr;
      char *windowName;
      int index;
      /*
       * If invoked with no arguments, just return the current focus window.
       */
      if (objc == 1) {
          focusWinPtr = TkGetFocusWin(winPtr);
          if (focusWinPtr != NULL) {
              Tcl_SetResult(interp, focusWinPtr->pathName, TCL_STATIC);
          }
          return TCL_OK;
      }
      /*
       * If invoked with a single argument beginning with "." then focus
       * on that window.
       */
      if (objc == 2) {
          windowName = Tcl_GetStringFromObj(objv[1], (int *) NULL);
          /*
           * The empty string case exists for backwards compatibility.
           */
          if (windowName[0] == '\0') {
              return TCL_OK;
          }
          if (windowName[0] == '.') {
              newPtr = (TkWindow *) Tk_NameToWindow(interp, windowName, tkwin);
              if (newPtr == NULL) {
                  return TCL_ERROR;
              }
              if (!(newPtr->flags & TK_ALREADY_DEAD)) {
                  TkSetFocusWin(newPtr, 0);
              }
              return TCL_OK;
          }
      }
      if (Tcl_GetIndexFromObj(interp, objv[1], focusOptions, "option", 0,
              &index) != TCL_OK) {
          return TCL_ERROR;
      }
      if (objc != 3) {
          Tcl_WrongNumArgs(interp, 2, objv, "window");
          return TCL_ERROR;
      }
      switch (index) {
          case 0: {        /* -displayof */
              windowName = Tcl_GetStringFromObj(objv[2], (int *) NULL);
              newPtr = (TkWindow *) Tk_NameToWindow(interp, windowName, tkwin);
              if (newPtr == NULL) {
                  return TCL_ERROR;
              }
              newPtr = TkGetFocusWin(newPtr);
              if (newPtr != NULL) {
                  Tcl_SetResult(interp, newPtr->pathName, TCL_STATIC);
              }
              break;
          }
          case 1: {        /* -force */
              windowName = Tcl_GetStringFromObj(objv[2], (int *) NULL);
              /*
               * The empty string case exists for backwards compatibility.
               */
              if (windowName[0] == '\0') {
                  return TCL_OK;
              }
              newPtr = (TkWindow *) Tk_NameToWindow(interp, windowName, tkwin);
              if (newPtr == NULL) {
                  return TCL_ERROR;
              }
              TkSetFocusWin(newPtr, 1);
              break;
          }
          case 2: {        /* -lastfor */
              windowName = Tcl_GetStringFromObj(objv[2], (int *) NULL);
              newPtr = (TkWindow *) Tk_NameToWindow(interp, windowName, tkwin);
              if (newPtr == NULL) {
                  return TCL_ERROR;
              }
              for (topLevelPtr = newPtr; topLevelPtr != NULL;
                      topLevelPtr = topLevelPtr->parentPtr)  {
                  if (topLevelPtr->flags & TK_TOP_LEVEL) {
                      for (tlFocusPtr = newPtr->mainPtr->tlFocusPtr;
                              tlFocusPtr != NULL;
                              tlFocusPtr = tlFocusPtr->nextPtr) {
                          if (tlFocusPtr->topLevelPtr == topLevelPtr) {
                              Tcl_SetResult(interp,
                                      tlFocusPtr->focusWinPtr->pathName,
                                      TCL_STATIC);
                              return TCL_OK;
                          }
                      }
                      Tcl_SetResult(interp, topLevelPtr->pathName, TCL_STATIC);
                      return TCL_OK;
                  }
              }
              break;
          }
          default: {
              panic("bad const entries to focusOptions in focus command");
          }
      }
      return TCL_OK;
  }
  /*
   *--------------------------------------------------------------
   *
   * TkFocusFilterEvent --
   *
   *      This procedure is invoked by Tk_HandleEvent when it encounters
   *      a FocusIn, FocusOut, Enter, or Leave event.
   *
   * Results:
   *      A return value of 1 means that Tk_HandleEvent should process
   *      the event normally (i.e. event handlers should be invoked).
   *      A return value of 0 means that this event should be ignored.
   *
   * Side effects:
   *      Additional events may be generated, and the focus may switch.
   *
   *--------------------------------------------------------------
   */
  int
  TkFocusFilterEvent(winPtr, eventPtr)
      TkWindow *winPtr;           /* Window that focus event is directed to. */
      XEvent *eventPtr;           /* FocusIn, FocusOut, Enter, or Leave
                                   * event. */
  {
      /*
       * Design notes: the window manager and X server work together to
       * transfer the focus among top-level windows.  This procedure takes
       * care of transferring the focus from a top-level or wrapper window
       * to the actual window within that top-level that has the focus.
       * We do this by synthesizing X events to move the focus around.
       * None of the FocusIn and FocusOut events generated by X are ever
       * used outside of this procedure;  only the synthesized events get
       * through to the rest of the application.  At one point (e.g.
       * Tk4.0b1) Tk used to call X to move the focus from a top-level to
       * one of its descendants, then just pass through the events
       * generated by X. This approach didn't work very well, for a
       * variety of reasons. For example, if X generates the events they
       * go at the back of the event queue, which could cause problems if
       * other things have already happened, such as moving the focus to
       * yet another window.
       */
      ToplevelFocusInfo *tlFocusPtr;
      DisplayFocusInfo *displayFocusPtr;
      TkDisplay *dispPtr = winPtr->dispPtr;
      TkWindow *newFocusPtr;
      int retValue, delta;
      /*
       * If this was a generated event, just turn off the generated
       * flag and pass the event through to Tk bindings.
       */
      if (eventPtr->xfocus.send_event == GENERATED_EVENT_MAGIC) {
          eventPtr->xfocus.send_event = 0;
          return 1;
      }
      /*
       * Check for special events generated by embedded applications to
       * request the input focus.  If this is one of those events, make
       * the change in focus and return without any additional processing
       * of the event (note: the "detail" field of the event indicates
       * whether to claim the focus even if we don't already have it).
       */
      if ((eventPtr->xfocus.mode == EMBEDDED_APP_WANTS_FOCUS)
              && (eventPtr->type == FocusIn)) {
          TkSetFocusWin(winPtr, eventPtr->xfocus.detail);
          return 0;
      }
      /*
       * This was not a generated event.  We'll return 1 (so that the
       * event will be processed) if it's an Enter or Leave event, and
       * 0 (so that the event won't be processed) if it's a FocusIn or
       * FocusOut event.
       */
      retValue = 0;
      displayFocusPtr = FindDisplayFocusInfo(winPtr->mainPtr, winPtr->dispPtr);
      if (eventPtr->type == FocusIn) {
          /*
           * Skip FocusIn events that cause confusion
           * NotifyVirtual and NotifyNonlinearVirtual - Virtual events occur
           *      on windows in between the origin and destination of the
           *      focus change.  For FocusIn we may see this when focus
           *      goes into an embedded child.  We don't care about this,
           *      although we may end up getting a NotifyPointer later.
           * NotifyInferior - focus is coming to us from an embedded child.
           *      When focus is on an embeded focus, we still think we have
           *      the focus, too, so this message doesn't change our state.
           * NotifyPointerRoot - should never happen because this is sent
           *      to the root window.
           *
           * Interesting FocusIn events are
           * NotifyAncestor - focus is coming from our parent, probably the root.
           * NotifyNonlinear - focus is coming from a different branch, probably
           *      another toplevel.
           * NotifyPointer - implicit focus because of the mouse position.
           *      This is only interesting on toplevels, when it means that the
           *      focus has been set to the root window but the mouse is over
           *      this toplevel.  We take the focus implicitly (probably no
           *      window manager)
           */
          if ((eventPtr->xfocus.detail == NotifyVirtual)
                  || (eventPtr->xfocus.detail == NotifyNonlinearVirtual)
                  || (eventPtr->xfocus.detail == NotifyPointerRoot)
                  || (eventPtr->xfocus.detail == NotifyInferior)) {
              return retValue;
          }
      } else if (eventPtr->type == FocusOut) {
          /*
           * Skip FocusOut events that cause confusion.
           * NotifyPointer - the pointer is in us or a child, and we are losing
           *      focus because of an XSetInputFocus.  Other focus events
           *      will set our state properly.
           * NotifyPointerRoot - should never happen because this is sent
           *      to the root window.
           * NotifyInferior - focus leaving us for an embedded child.  We
           *      retain a notion of focus when an embedded child has focus.
           *
           * Interesting events are:
           * NotifyAncestor - focus is going to root.
           * NotifyNonlinear - focus is going to another branch, probably
           *      another toplevel.
           * NotifyVirtual, NotifyNonlinearVirtual - focus is passing through,
           *      and we need to make sure we track this.
           */
          if ((eventPtr->xfocus.detail == NotifyPointer)
                  || (eventPtr->xfocus.detail == NotifyPointerRoot)
                  || (eventPtr->xfocus.detail == NotifyInferior)) {
              return retValue;
          }
      } else {
          retValue = 1;
          if (eventPtr->xcrossing.detail == NotifyInferior) {
              return retValue;
          }
      }
      /*
       * If winPtr isn't a top-level window than just ignore the event.
       */
      winPtr = TkWmFocusToplevel(winPtr);
      if (winPtr == NULL) {
          return retValue;
      }
      /*
       * If there is a grab in effect and this window is outside the
       * grabbed tree, then ignore the event.
       */
      if (TkGrabState(winPtr) == TK_GRAB_EXCLUDED)  {
          return retValue;
      }
      /*
       * It is possible that there were outstanding FocusIn and FocusOut
       * events on their way to us at the time the focus was changed
       * internally with the "focus" command.  If so, these events could
       * potentially cause us to lose the focus (switch it to the window
       * of the last FocusIn event) even though the focus change occurred
       * after those events.  The following code detects this and ignores
       * the stale events.
       *
       * Note: the focusSerial is only generated by TkpChangeFocus,
       * whereas in Tk 4.2 there was always a nop marker generated.
       */
      delta = eventPtr->xfocus.serial - displayFocusPtr->focusSerial;
      if (delta < 0) {
          return retValue;
      }
      /*
       * Find the ToplevelFocusInfo structure for the window, and make a new one
       * if there isn't one already.
       */
      for (tlFocusPtr = winPtr->mainPtr->tlFocusPtr; tlFocusPtr != NULL;
              tlFocusPtr = tlFocusPtr->nextPtr) {
          if (tlFocusPtr->topLevelPtr == winPtr) {
              break;
          }
      }
      if (tlFocusPtr == NULL) {
          tlFocusPtr = (ToplevelFocusInfo *) ckalloc(sizeof(ToplevelFocusInfo));
          tlFocusPtr->topLevelPtr = tlFocusPtr->focusWinPtr = winPtr;
          tlFocusPtr->nextPtr = winPtr->mainPtr->tlFocusPtr;
          winPtr->mainPtr->tlFocusPtr = tlFocusPtr;
      }
      newFocusPtr = tlFocusPtr->focusWinPtr;
      if (eventPtr->type == FocusIn) {
          GenerateFocusEvents(displayFocusPtr->focusWinPtr, newFocusPtr);
          displayFocusPtr->focusWinPtr = newFocusPtr;
          dispPtr->focusPtr = newFocusPtr;
          /*
           * NotifyPointer gets set when the focus has been set to the root window
           * but we have the pointer.  We'll treat this like an implicit
           * focus in event so that upon Leave events we release focus.
           */
          if (!(winPtr->flags & TK_EMBEDDED)) {
              if (eventPtr->xfocus.detail == NotifyPointer) {
                  dispPtr->implicitWinPtr = winPtr;
              } else {
                  dispPtr->implicitWinPtr = NULL;
              }
          }
      } else if (eventPtr->type == FocusOut) {
          GenerateFocusEvents(displayFocusPtr->focusWinPtr, (TkWindow *) NULL);
          /*
           * Reset dispPtr->focusPtr, but only if it currently is the same
           * as this application's focusWinPtr: this check is needed to
           * handle embedded applications in the same process.
           */
          if (dispPtr->focusPtr == displayFocusPtr->focusWinPtr) {
              dispPtr->focusPtr = NULL;
          }
          displayFocusPtr->focusWinPtr = NULL;
      } else if (eventPtr->type == EnterNotify) {
          /*
           * If there is no window manager, or if the window manager isn't
           * moving the focus around (e.g. the disgusting "NoTitleFocus"
           * option has been selected in twm), then we won't get FocusIn
           * or FocusOut events.  Instead, the "focus" field will be set
           * in an Enter event to indicate that we've already got the focus
           * when the mouse enters the window (even though we didn't get
           * a FocusIn event).  Watch for this and grab the focus when it
           * happens.  Note: if this is an embedded application then don't
           * accept the focus implicitly like this;  the container
           * application will give us the focus explicitly if it wants us
           * to have it.
           */
          if (eventPtr->xcrossing.focus &&
                  (displayFocusPtr->focusWinPtr == NULL)
                  && !(winPtr->flags & TK_EMBEDDED)) {
              if (dispPtr->focusDebug) {
                  printf("Focussed implicitly on %s\n",
                          newFocusPtr->pathName);
              }
              GenerateFocusEvents(displayFocusPtr->focusWinPtr, newFocusPtr);
              displayFocusPtr->focusWinPtr = newFocusPtr;
              dispPtr->implicitWinPtr = winPtr;
              dispPtr->focusPtr = newFocusPtr;
          }
      } else if (eventPtr->type == LeaveNotify) {
          /*
           * If the pointer just left a window for which we automatically
           * claimed the focus on enter, move the focus back to the root
           * window, where it was before we claimed it above.  Note:
           * dispPtr->implicitWinPtr may not be the same as
           * displayFocusPtr->focusWinPtr (e.g. because the "focus"
           * command was used to redirect the focus after it arrived at
           * dispPtr->implicitWinPtr)!!  In addition, we generate events
           * because the window manager won't give us a FocusOut event when
           * we focus on the root.
           */
          if ((dispPtr->implicitWinPtr != NULL)
                  && !(winPtr->flags & TK_EMBEDDED)) {
              if (dispPtr->focusDebug) {
                  printf("Defocussed implicit Async\n");
              }
              GenerateFocusEvents(displayFocusPtr->focusWinPtr,
                      (TkWindow *) NULL);
              XSetInputFocus(dispPtr->display, PointerRoot, RevertToPointerRoot,
                      CurrentTime);
              displayFocusPtr->focusWinPtr = NULL;
              dispPtr->implicitWinPtr = NULL;
          }
      }
      return retValue;
  }
  /*
   *----------------------------------------------------------------------
   *
   * TkSetFocusWin --
   *
   *      This procedure is invoked to change the focus window for a
   *      given display in a given application.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Event handlers may be invoked to process the change of
   *      focus.
   *
   *----------------------------------------------------------------------
   */
  void
  TkSetFocusWin(winPtr, force)
      TkWindow *winPtr;           /* Window that is to be the new focus for
                                   * its display and application. */
      int force;                  /* If non-zero, set the X focus to this
                                   * window even if the application doesn't
                                   * currently have the X focus. */
  {
      ToplevelFocusInfo *tlFocusPtr;
      DisplayFocusInfo *displayFocusPtr;
      TkWindow *topLevelPtr;
      int allMapped, serial;
      displayFocusPtr = FindDisplayFocusInfo(winPtr->mainPtr, winPtr->dispPtr);
      /*
       * If force is set, we should make sure we grab the focus regardless
       * of the current focus window since under Windows, we may need to
       * take control away from another application.
       */
      if (winPtr == displayFocusPtr->focusWinPtr && !force) {
          return;
      }
      /*
       * Find the top-level window for winPtr, then find (or create)
       * a record for the top-level.  Also see whether winPtr and all its
       * ancestors are mapped.
       */
      allMapped = 1;
      for (topLevelPtr = winPtr; ; topLevelPtr = topLevelPtr->parentPtr)  {
          if (topLevelPtr == NULL) {
              /*
               * The window is being deleted.  No point in worrying about
               * giving it the focus.
               */
              return;
          }
          if (!(topLevelPtr->flags & TK_MAPPED)) {
              allMapped = 0;
          }
          if (topLevelPtr->flags & TK_TOP_LEVEL) {
              break;
          }
      }
      /*
       * If the new focus window isn't mapped, then we can't focus on it
       * (X will generate an error, for example).  Instead, create an
       * event handler that will set the focus to this window once it gets
       * mapped.  At the same time, delete any old handler that might be
       * around;  it's no longer relevant.
       */
      if (displayFocusPtr->focusOnMapPtr != NULL) {
          Tk_DeleteEventHandler(
                  (Tk_Window) displayFocusPtr->focusOnMapPtr,
                  StructureNotifyMask, FocusMapProc,
                  (ClientData) displayFocusPtr->focusOnMapPtr);
          displayFocusPtr->focusOnMapPtr = NULL;
      }
      if (!allMapped) {
          Tk_CreateEventHandler((Tk_Window) winPtr,
                  VisibilityChangeMask, FocusMapProc,
                  (ClientData) winPtr);
          displayFocusPtr->focusOnMapPtr = winPtr;
          displayFocusPtr->forceFocus = force;
          return;
      }
      for (tlFocusPtr = winPtr->mainPtr->tlFocusPtr; tlFocusPtr != NULL;
              tlFocusPtr = tlFocusPtr->nextPtr) {
          if (tlFocusPtr->topLevelPtr == topLevelPtr) {
              break;
          }
      }
      if (tlFocusPtr == NULL) {
          tlFocusPtr = (ToplevelFocusInfo *) ckalloc(sizeof(ToplevelFocusInfo));
          tlFocusPtr->topLevelPtr = topLevelPtr;
          tlFocusPtr->nextPtr = winPtr->mainPtr->tlFocusPtr;
          winPtr->mainPtr->tlFocusPtr = tlFocusPtr;
      }
      tlFocusPtr->focusWinPtr = winPtr;
      /*
       * Reset the window system's focus window and generate focus events,
       * with two special cases:
       *
       * 1. If the application is embedded and doesn't currently have the
       *    focus, don't set the focus directly.  Instead, see if the
       *    embedding code can claim the focus from the enclosing
       *    container.
       * 2. Otherwise, if the application doesn't currently have the
       *    focus, don't change the window system's focus unless it was
       *    already in this application or "force" was specified.
       */
      if ((topLevelPtr->flags & TK_EMBEDDED)
              && (displayFocusPtr->focusWinPtr == NULL)) {
          TkpClaimFocus(topLevelPtr, force);
      } else if ((displayFocusPtr->focusWinPtr != NULL) || force) {
          /*
           * Generate events to shift focus between Tk windows.
           * We do this regardless of what TkpChangeFocus does with
           * the real X focus so that Tk widgets track focus commands
           * when there is no window manager.  GenerateFocusEvents will
           * set up a serial number marker so we discard focus events
           * that are triggered by the ChangeFocus.
           */
          serial = TkpChangeFocus(TkpGetWrapperWindow(topLevelPtr), force);
          if (serial != 0) {
              displayFocusPtr->focusSerial = serial;
          }
          GenerateFocusEvents(displayFocusPtr->focusWinPtr, winPtr);
          displayFocusPtr->focusWinPtr = winPtr;
          winPtr->dispPtr->focusPtr = winPtr;
      }
  }
  /*
   *----------------------------------------------------------------------
   *
   * TkGetFocusWin --
   *
   *      Given a window, this procedure returns the current focus
   *      window for its application and display.
   *
   * Results:
   *      The return value is a pointer to the window that currently
   *      has the input focus for the specified application and
   *      display, or NULL if none.
   *
   * Side effects:
   *      None.
   *
   *----------------------------------------------------------------------
   */
  TkWindow *
  TkGetFocusWin(winPtr)
      TkWindow *winPtr;           /* Window that selects an application
                                   * and a display. */
  {
      DisplayFocusInfo *displayFocusPtr;
      if (winPtr == NULL) {
          return (TkWindow *) NULL;
      }
      displayFocusPtr = FindDisplayFocusInfo(winPtr->mainPtr, winPtr->dispPtr);
      return displayFocusPtr->focusWinPtr;
  }
  /*
   *----------------------------------------------------------------------
   *
   * TkFocusKeyEvent --
   *
   *      Given a window and a key press or release event that arrived for
   *      the window, use information about the keyboard focus to compute
   *      which window should really get the event.  In addition, update
   *      the event to refer to its new window.
   *
   * Results:
   *      The return value is a pointer to the window that has the input
   *      focus in winPtr's application, or NULL if winPtr's application
   *      doesn't have the input focus.  If a non-NULL value is returned,
   *      eventPtr will be updated to refer properly to the focus window.
   *
   * Side effects:
   *      None.
   *
   *----------------------------------------------------------------------
   */
  TkWindow *
  TkFocusKeyEvent(winPtr, eventPtr)
      TkWindow *winPtr;           /* Window that selects an application
                                   * and a display. */
      XEvent *eventPtr;           /* X event to redirect (should be KeyPress
                                   * or KeyRelease). */
  {
      DisplayFocusInfo *displayFocusPtr;
      TkWindow *focusWinPtr;
      int focusX, focusY, vRootX, vRootY, vRootWidth, vRootHeight;
      displayFocusPtr = FindDisplayFocusInfo(winPtr->mainPtr, winPtr->dispPtr);
      focusWinPtr = displayFocusPtr->focusWinPtr;
      /*
       * The code below is a debugging aid to make sure that dispPtr->focusPtr
       * is kept properly in sync with the "truth", which is the value in
       * displayFocusPtr->focusWinPtr.
       */
  #ifdef TCL_MEM_DEBUG
      if (focusWinPtr != winPtr->dispPtr->focusPtr) {
          printf("TkFocusKeyEvent found dispPtr->focusPtr out of sync:\n");
          printf("expected %s, got %s\n",
                  (focusWinPtr != NULL) ? focusWinPtr->pathName : "??",
                  (winPtr->dispPtr->focusPtr != NULL) ?
                  winPtr->dispPtr->focusPtr->pathName : "??");
      }
  #endif
      if ((focusWinPtr != NULL) && (focusWinPtr->mainPtr == winPtr->mainPtr)) {
          /*
           * Map the x and y coordinates to make sense in the context of
           * the focus window, if possible (make both -1 if the map-from
           * and map-to windows don't share the same screen).
           */
          if ((focusWinPtr->display != winPtr->display)
                  || (focusWinPtr->screenNum != winPtr->screenNum)) {
              eventPtr->xkey.x = -1;
              eventPtr->xkey.y = -1;
          } else {
              Tk_GetVRootGeometry((Tk_Window) focusWinPtr, &vRootX, &vRootY,
                      &vRootWidth, &vRootHeight);
              Tk_GetRootCoords((Tk_Window) focusWinPtr, &focusX, &focusY);
              eventPtr->xkey.x = eventPtr->xkey.x_root - vRootX - focusX;
              eventPtr->xkey.y = eventPtr->xkey.y_root - vRootY - focusY;
          }
          eventPtr->xkey.window = focusWinPtr->window;
          return focusWinPtr;
      }
      /*
       * The event doesn't belong to us.  Perhaps, due to embedding, it
       * really belongs to someone else.  Give the embedding code a chance
       * to redirect the event.
       */
      TkpRedirectKeyEvent(winPtr, eventPtr);
      return (TkWindow *) NULL;
  }
  /*
   *----------------------------------------------------------------------
   *
   * TkFocusDeadWindow --
   *
   *      This procedure is invoked when it is determined that
   *      a window is dead.  It cleans up focus-related information
   *      about the window.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Various things get cleaned up and recycled.
   *
   *----------------------------------------------------------------------
   */
  void
  TkFocusDeadWindow(winPtr)
      register TkWindow *winPtr;          /* Information about the window
                                           * that is being deleted. */
  {
      ToplevelFocusInfo *tlFocusPtr, *prevPtr;
      DisplayFocusInfo *displayFocusPtr;
      TkDisplay *dispPtr = winPtr->dispPtr;
      /*
       * Search for focus records that refer to this window either as
       * the top-level window or the current focus window.
       */
      displayFocusPtr = FindDisplayFocusInfo(winPtr->mainPtr, winPtr->dispPtr);
      for (prevPtr = NULL, tlFocusPtr = winPtr->mainPtr->tlFocusPtr;
              tlFocusPtr != NULL;
              prevPtr = tlFocusPtr, tlFocusPtr = tlFocusPtr->nextPtr) {
          if (winPtr == tlFocusPtr->topLevelPtr) {
              /*
               * The top-level window is the one being deleted: free
               * the focus record and release the focus back to PointerRoot
               * if we acquired it implicitly.
               */
              if (dispPtr->implicitWinPtr == winPtr) {
                  if (dispPtr->focusDebug) {
                      printf("releasing focus to root after %s died\n",
                              tlFocusPtr->topLevelPtr->pathName);
                  }
                  dispPtr->implicitWinPtr = NULL;
                  displayFocusPtr->focusWinPtr = NULL;
                  dispPtr->focusPtr = NULL;
              }
              if (displayFocusPtr->focusWinPtr == tlFocusPtr->focusWinPtr) {
                  displayFocusPtr->focusWinPtr = NULL;
                  dispPtr->focusPtr = NULL;
              }
              if (prevPtr == NULL) {
                  winPtr->mainPtr->tlFocusPtr = tlFocusPtr->nextPtr;
              } else {
                  prevPtr->nextPtr = tlFocusPtr->nextPtr;
              }
              ckfree((char *) tlFocusPtr);
              break;
          } else if (winPtr == tlFocusPtr->focusWinPtr) {
              /*
               * The deleted window had the focus for its top-level:
               * move the focus to the top-level itself.
               */
              tlFocusPtr->focusWinPtr = tlFocusPtr->topLevelPtr;
              if ((displayFocusPtr->focusWinPtr == winPtr)
                      && !(tlFocusPtr->topLevelPtr->flags & TK_ALREADY_DEAD)) {
                  if (dispPtr->focusDebug) {
                      printf("forwarding focus to %s after %s died\n",
                              tlFocusPtr->topLevelPtr->pathName,
                              winPtr->pathName);
                  }
                  GenerateFocusEvents(displayFocusPtr->focusWinPtr,
                          tlFocusPtr->topLevelPtr);
                  displayFocusPtr->focusWinPtr = tlFocusPtr->topLevelPtr;
                  dispPtr->focusPtr = tlFocusPtr->topLevelPtr;
              }
              break;
          }
      }
      if (displayFocusPtr->focusOnMapPtr == winPtr) {
          displayFocusPtr->focusOnMapPtr = NULL;
      }
  }
  /*
   *----------------------------------------------------------------------
   *
   * GenerateFocusEvents --
   *
   *      This procedure is called to create FocusIn and FocusOut events to
   *      move the input focus from one window to another.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      FocusIn and FocusOut events are generated.
   *
   *----------------------------------------------------------------------
   */
  static void
  GenerateFocusEvents(sourcePtr, destPtr)
      TkWindow *sourcePtr;        /* Window that used to have the focus (may
                                   * be NULL). */
      TkWindow *destPtr;          /* New window to have the focus (may be
                                   * NULL). */
  {
      XEvent event;
      TkWindow *winPtr;
      winPtr = sourcePtr;
      if (winPtr == NULL) {
          winPtr = destPtr;
          if (winPtr == NULL) {
              return;
          }
      }
      event.xfocus.serial = LastKnownRequestProcessed(winPtr->display);
      event.xfocus.send_event = GENERATED_EVENT_MAGIC;
      event.xfocus.display = winPtr->display;
      event.xfocus.mode = NotifyNormal;
      TkInOutEvents(&event, sourcePtr, destPtr, FocusOut, FocusIn,
              TCL_QUEUE_MARK);
  }
  /*
   *----------------------------------------------------------------------
   *
   * FocusMapProc --
   *
   *      This procedure is called as an event handler for VisibilityNotify
   *      events, if a window receives the focus at a time when its
   *      toplevel isn't mapped.  The procedure is needed because X
   *      won't allow the focus to be set to an unmapped window;  we
   *      detect when the toplevel is mapped and set the focus to it then.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      If this is a map event, the focus gets set to the toplevel
   *      given by clientData.
   *
   *----------------------------------------------------------------------
   */
  static void
  FocusMapProc(clientData, eventPtr)
      ClientData clientData;      /* Toplevel window. */
      XEvent *eventPtr;           /* Information about event. */
  {
      TkWindow *winPtr = (TkWindow *) clientData;
      DisplayFocusInfo *displayFocusPtr;
      if (eventPtr->type == VisibilityNotify) {
          displayFocusPtr = FindDisplayFocusInfo(winPtr->mainPtr,
                  winPtr->dispPtr);
          if (winPtr->dispPtr->focusDebug) {
              printf("auto-focussing on %s, force %d\n", winPtr->pathName,
                      displayFocusPtr->forceFocus);
          }
          Tk_DeleteEventHandler((Tk_Window) winPtr, VisibilityChangeMask,
                  FocusMapProc, clientData);
          displayFocusPtr->focusOnMapPtr = NULL;
          TkSetFocusWin(winPtr, displayFocusPtr->forceFocus);
      }
  }
  /*
   *----------------------------------------------------------------------
   *
   * FindDisplayFocusInfo --
   *
   *      Given an application and a display, this procedure locate the
   *      focus record for that combination.  If no such record exists,
   *      it creates a new record and initializes it.
   *
   * Results:
   *      The return value is a pointer to the record.
   *
   * Side effects:
   *      A new record will be allocated if there wasn't one already.
   *
   *----------------------------------------------------------------------
   */
  static DisplayFocusInfo *
  FindDisplayFocusInfo(mainPtr, dispPtr)
      TkMainInfo *mainPtr;        /* Record that identifies a particular
                                   * application. */
      TkDisplay *dispPtr;         /* Display whose focus information is
                                   * needed. */
  {
      DisplayFocusInfo *displayFocusPtr;
      for (displayFocusPtr = mainPtr->displayFocusPtr;
              displayFocusPtr != NULL;
              displayFocusPtr = displayFocusPtr->nextPtr) {
          if (displayFocusPtr->dispPtr == dispPtr) {
              return displayFocusPtr;
          }
      }
      /*
       * The record doesn't exist yet.  Make a new one.
       */
      displayFocusPtr = (DisplayFocusInfo *) ckalloc(sizeof(DisplayFocusInfo));
      displayFocusPtr->dispPtr = dispPtr;
      displayFocusPtr->focusWinPtr = NULL;
      displayFocusPtr->focusOnMapPtr = NULL;
      displayFocusPtr->forceFocus = 0;
      displayFocusPtr->focusSerial = 0;
      displayFocusPtr->nextPtr = mainPtr->displayFocusPtr;
      mainPtr->displayFocusPtr = displayFocusPtr;
      return displayFocusPtr;
  }
  /* End of tkfocus.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