1. /*

  2.  * @(#)DefaultFocusManager.java	1.15 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package javax.swing;

  8. 

  9. import java.awt.event.KeyEvent;

  10. import java.awt.Component;

  11. import java.awt.Container;

  12. import java.awt.event.ActionEvent;

  13. import java.awt.Window;

  14. import java.awt.Dialog;

  15. import java.awt.Rectangle;

  16. import java.util.Stack;

  17. 

  18. /**

  19.  * Default swing focus manager implementation.

  20.  *

  21.  * @version 1.15 11/29/01

  22.  * @author Arnaud Weber

  23.  */

  24. public class DefaultFocusManager extends FocusManager {

  25. 

  26.     /** This method is called by JComponents when a key event occurs.

  27.      *  JComponent gives key events to the focus manager

  28.      *  first, then to key listeners, then to the keyboard UI dispatcher.

  29.      *  This method should look at the key event and change the focused

  30.      *  component if the key event matches the receiver's focus manager

  31.      *  hot keys. For example the default focus manager will change the

  32.      *  focus if the key event matches TAB or Shift + TAB.

  33.      *  The focus manager should call consume() on <b>anEvent</b> if 

  34.      *  <code>anEvent</code> has been processed. 

  35.      *  <code>focusedComponent</code> is the component that currently has

  36.      *  the focus.

  37.      *  Note: FocusManager will receive KEY_PRESSED, KEY_RELEASED and KEY_TYPED

  38.      *  key events. If one event is consumed, all other events type should be consumed.

  39.      */

  40.     Stack history = new Stack();

  41. 

  42.     public void processKeyEvent(Component focusedComponent,KeyEvent anEvent) {

  43.         if(anEvent.getKeyCode() == KeyEvent.VK_TAB || anEvent.getKeyChar() == '\t') {

  44.             /** If the focused component manages focus, let it do so

  45.              *  if control is not pressed 

  46.              */

  47.             if(focusedComponent instanceof JComponent) {

  48.                 JComponent fc = (JComponent) focusedComponent;

  49.                 if(fc.isManagingFocus()) {

  50. 		     int isctrl = (anEvent.getModifiers() &

  51. 				   ActionEvent.CTRL_MASK);

  52.                      if ((isctrl != ActionEvent.CTRL_MASK) ||

  53. 			 (anEvent.getKeyCode() == KeyEvent.VK_I))

  54.                         return;

  55.                 }

  56.             }

  57. 

  58.             /** If this is not a key press, consume and return **/

  59.             if(anEvent.getID() != KeyEvent.KEY_PRESSED){

  60.                 anEvent.consume();

  61.                 return;

  62.             }

  63. 

  64. //	    System.out.println("\n\n******TAB pressed in processKeyEvent");

  65.             if((anEvent.getModifiers() & ActionEvent.SHIFT_MASK) == ActionEvent.SHIFT_MASK) 

  66.                 focusPreviousComponent(focusedComponent);

  67.             else

  68.                 focusNextComponent(focusedComponent);

  69.             anEvent.consume();

  70.         }

  71.     }

  72. 

  73.     /** Cause the focus manager to set the focus on the next focusable component **/

  74.     public void focusNextComponent(Component aComponent) {

  75.         if(aComponent instanceof JComponent) {

  76.             JComponent fc  = (JComponent) aComponent;

  77.             Component nc;

  78.             Container  root = getFocusRoot(fc);

  79. 	    if (!history.empty() && history.peek() != aComponent) {

  80. 	        history.removeAllElements();

  81. 	    }

  82.             if(root != null) {

  83.                 nc = getFocusableComponentAfter(fc,root,true);

  84.                 if(nc != null) {

  85. 		    if (history.empty() || history.peek() == aComponent) {

  86. 		      history.push(nc);

  87. 		    }

  88.                     if(nc instanceof JComponent)

  89.                         ((JComponent)nc).grabFocus();

  90.                     else

  91.                         nc.requestFocus();

  92.                 }

  93.             }

  94.         }

  95.     }

  96. 

  97.     /** Cause the focus manager to set the focus on the previous focusable component **/

  98.     public void focusPreviousComponent(Component aComponent) {

  99. 

  100.         if(aComponent instanceof JComponent) {

  101.             JComponent fc  = (JComponent) aComponent;

  102.             Component nc;

  103.             Container root = getFocusRoot(fc);

  104. 

  105. 	    if (!history.empty() && history.peek() == aComponent) {

  106. 	       history.pop();

  107. 	      if (!history.empty()) {

  108. 		nc = (Component) history.peek();

  109. 		if (nc instanceof JComponent)

  110. 		  ((JComponent)nc).grabFocus();

  111. 		else

  112. 		  nc.requestFocus();

  113. 		return;

  114. 	      }

  115. 	    }

  116. 	    

  117. 	    history.removeAllElements();

  118. 

  119. 	    if(root != null) {

  120.                 nc = getFocusableComponentAfter(fc,root,false);

  121.                 if(nc != null) {

  122. 		    if(nc instanceof JComponent)

  123. 		      ((JComponent)nc).grabFocus();

  124. 		    else

  125. 		      nc.requestFocus();

  126.                 }

  127. 	    }

  128.         }

  129.     }

  130. 

  131.     Container getFocusRoot(Component c) {

  132.         Container p;

  133.         for(p = c.getParent() ; p != null ; p = p.getParent()) {

  134.             if(((p instanceof JComponent) && ((JComponent)p).isFocusCycleRoot()) ||

  135.                (p instanceof Window) || (p instanceof Dialog))

  136.                 return p;

  137.         }

  138.         return null;

  139.     }

  140. 

  141.     private Component getFocusableComponentAfter(Component focusedComponent,

  142.                                                  Container rootContainer,

  143.                                                  boolean moveForward) {

  144.         Component nextComponent;

  145.         Component initialComponent;

  146. 

  147.         nextComponent = initialComponent = focusedComponent;

  148.         do {

  149. 	    if(moveForward) {

  150. 	      

  151.                 nextComponent = getNextComponent(nextComponent,rootContainer,true);

  152. 	    } else

  153.                 nextComponent = getPreviousComponent(nextComponent,rootContainer);

  154.             if(nextComponent == null)

  155.                 break;

  156.             if(nextComponent == initialComponent)

  157.                 break;

  158.         } while(!(nextComponent.isVisible() && 

  159.                   nextComponent.isFocusTraversable() && 

  160.                   nextComponent.isEnabled()));

  161. 

  162.         return nextComponent;

  163.     }

  164. 

  165.    private Component getNextComponent(Component component,

  166.                                       Container root,

  167.                                       boolean canGoDown) {

  168.        Component nsv = null;

  169.        

  170.        if(canGoDown && component.isVisible() &&

  171.           ( !(component instanceof JComponent) ||

  172.             !(((JComponent)component).isManagingFocus()) ) &&

  173.           ((component instanceof Container) && ((Container)component).getComponentCount() > 0)) {

  174.            return getFirstComponent((Container)component);

  175.        } else {

  176.            Container parent = component.getParent();

  177.            nsv = getComponentAfter(parent,component);

  178.            if(nsv != null)

  179.                return nsv;

  180.            if(parent == root)

  181.                return root;

  182.            else 

  183.                return getNextComponent(parent,root,false);

  184.        }

  185.    }

  186. 

  187.     private Component getPreviousComponent(Component component,Container root) {

  188.         Container parent = component.getParent();

  189. 

  190.         if(component == root)

  191.             return getDeepestLastComponent(root);

  192.         else {

  193.             Component nsv = getComponentBefore(parent,component);

  194.             if(nsv != null)

  195.                 return getDeepestLastComponent(nsv);

  196.             else

  197.                 return parent;

  198.         }

  199.     }

  200. 

  201.     private Component getDeepestLastComponent(Component component) {

  202. 

  203.         if(component.isVisible() &&

  204.             (((component instanceof JComponent)          && 

  205.              !((JComponent)component).isManagingFocus()) ||

  206.             !(component instanceof JComponent))         && 

  207.            ((component instanceof Container) && ((Container)component).getComponentCount() > 0)) {

  208.             return getDeepestLastComponent(getLastComponent((Container) component));

  209.         } else

  210.             return component;

  211.     }

  212.     

  213.     /** Return the first component that should receive the focus **/

  214.     public Component getFirstComponent(Container aContainer) {

  215.         Component orderedChildren[] = childrenTabOrder(aContainer);

  216.         if(orderedChildren.length > 0)

  217.             return orderedChildren[0];

  218.         else

  219.             return null;

  220.     }

  221. 

  222.     /** Return the last component that should receive the focus **/

  223.     public Component getLastComponent(Container aContainer) {

  224.         Component orderedChildren[] = childrenTabOrder(aContainer);

  225.         if(orderedChildren.length > 0)

  226.             return orderedChildren[orderedChildren.length - 1];

  227.         else

  228.             return null;

  229.     }

  230. 

  231.     /** Return the component that should receive the focus before aComponent **/

  232.     public Component getComponentBefore(Container aContainer,Component aComponent) {

  233.         Component comp;

  234.         if ((comp = inverseGetNextFocusable(aContainer, aComponent)) != null)

  235.             return comp;

  236. 	return tabOrderPreviousComponent(aContainer, aComponent);

  237.     }

  238. 

  239.     /** Return the component the should receive the focus after aComponent **/

  240.     public Component getComponentAfter(Container aContainer,Component aComponent) {

  241.       Component nc;

  242.       if ((aComponent instanceof JComponent) &&

  243. 	  (nc = ((JComponent)aComponent).getNextFocusableComponent()) != null){

  244. 	  return nc;

  245.       }

  246.       return tabOrderNextComponent(aContainer, aComponent);

  247.     }

  248. 

  249.     

  250.     /** Return true if <code>a</code> should be before <code>b</code> in the

  251.      * "tab" order. Override this method if you want to change the automatic

  252.      * "tab" order. 

  253.      * The default implementation will order tab to give a left to right, top

  254.      * down order. Override this method if another order is required.

  255.      */

  256.     public boolean compareTabOrder(Component a,Component b) {

  257.         Rectangle bounds;

  258.         int ay,by;

  259.         int ax,bx;

  260.         if(a instanceof JComponent) {

  261.             ay = ((JComponent)a).getY();

  262.             ax = ((JComponent)a).getX();

  263.         } else {

  264.             bounds = a.getBounds();

  265.             ay = bounds.y;

  266.             ax = bounds.x;

  267.         }

  268. 

  269.         if(b instanceof JComponent) {

  270.             by = ((JComponent)b).getY();

  271.             bx = ((JComponent)b).getX();

  272.         } else {

  273.             bounds = b.getBounds();

  274.             by = bounds.y;

  275.             bx = bounds.x;

  276.         }

  277. 

  278.         if(Math.abs(ay - by) < 10) {

  279.             return (ax < bx);

  280.         }

  281.         return (ay < by);

  282.     }

  283. 

  284.     /** Return the component after comp according to compareTabOrder. If

  285.      * comp is the last component according to that order, return null.

  286.      */

  287. 	

  288.     private Component tabOrderNextComponent(Container cont, Component cmp) {

  289.         Component orderedChildren[] = childrenTabOrder(cont);

  290.         int i;

  291. 	int c = orderedChildren.length;

  292. 

  293.         /* since cmp is a child of cont, we know cont has at least one child */

  294. 	if (c == 1) return null;

  295. 

  296.         for(i=0; i < c - 1 ; i++) 

  297.             if(orderedChildren[i] == cmp)

  298.                 return orderedChildren[i+1];

  299.         return null;

  300.     }

  301. 

  302. 

  303.     /** Return the component before comp according to compareTabOrder. If

  304.      * comp is the first component according to that order, return null.

  305.      */

  306. 

  307.     private Component tabOrderPreviousComponent(Container cont, Component cmp) {

  308.         Component orderedChildren[] = childrenTabOrder(cont);

  309.         int i;

  310. 	int c = orderedChildren.length;

  311. 

  312.         /* since cmp is a child of cont, we know cont has at least one child */

  313. 	if (c==1) return null;

  314. 

  315.         for(i=1; i < c ; i++) 

  316.             if(orderedChildren[i] == cmp)

  317.                 return orderedChildren[i-1];

  318.         return null;

  319.    }

  320. 

  321.     /** If there is a child c of Cont such that

  322.      * c.getNextFocusableComponent == comp, return that component.

  323.      * Otherwise, return null.

  324.      */

  325. 

  326.    private Component inverseGetNextFocusable(Container cont, Component comp) {

  327.       Component children[] = cont.getComponents();

  328.       int i;

  329.       int c;

  330. 

  331.         for(i=0,c = children.length ; i < c ; i++) {

  332.             if((children[i] instanceof JComponent) &&

  333. 	       (((JComponent)children[i]).getNextFocusableComponent()) == comp)

  334. 	      return children[i];

  335. 	}

  336. 	return null;

  337.     }

  338. 

  339.     Component[] childrenTabOrder(Container co) {

  340.         Component children[] = co.getComponents();

  341.         Component tmp;

  342.         int i,j,c;

  343. 

  344.         /** Get the tab order from the geometry **/

  345.         for(i=0,c = children.length ; i < c ; i++) {

  346.             for(j=i ; j < c ; j++) {

  347.                 if(i==j)

  348.                     continue;

  349.                 if(compareTabOrder(children[j],children[i])) {

  350.                     tmp = children[i];

  351.                     children[i] = children[j];

  352.                     children[j] = tmp;

  353.                 }                    

  354.             }

  355.         }

  356. 	return children;

  357.     }

  358.   

  359.   void clearHistory() {

  360.     history.removeAllElements();

  361.   }

  362. 

  363. }