Source for javax.swing.FocusManager

   1: /* FocusManager.java --
   2:    Copyright (C) 2002, 2004  Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package javax.swing;
  40: 
  41: import java.awt.AWTEvent;
  42: import java.awt.Component;
  43: import java.awt.Container;
  44: import java.awt.DefaultKeyboardFocusManager;
  45: import java.awt.FocusTraversalPolicy;
  46: import java.awt.KeyEventDispatcher;
  47: import java.awt.KeyEventPostProcessor;
  48: import java.awt.KeyboardFocusManager;
  49: import java.awt.Window;
  50: import java.awt.event.KeyEvent;
  51: import java.beans.PropertyChangeListener;
  52: import java.beans.VetoableChangeListener;
  53: import java.util.Set;
  54: 
  55: /**
  56:  * This class has been obsoleted by the new
  57:  * {@link java.awt.KeyboardFocusManager} and
  58:  * {@link java.awt.DefaultKeyboardFocusManager} API.
  59:  *
  60:  * @author Andrew Selkirk
  61:  */
  62: public abstract class FocusManager
  63:   extends DefaultKeyboardFocusManager
  64: {
  65:   /**
  66:    * A FocusManager that wraps an AWT KeyboardFocusManager and forwards all
  67:    * method calls to it. This is used for compatibility with the new focus
  68:    * system.
  69:    *
  70:    * @author Roman Kennke (kennke@aicas.com)
  71:    */
  72:   private static class WrappingFocusManager
  73:     extends FocusManager
  74:   {
  75:     /**
  76:      * The wrapped KeyboardFocusManager.
  77:      */
  78:     private KeyboardFocusManager wrapped;
  79: 
  80:     /**
  81:      * Creates a new instance of WrappedFocusManager.
  82:      *
  83:      * @param fm the focus manager to wrap
  84:      */
  85:     WrappingFocusManager(KeyboardFocusManager fm)
  86:     {
  87:       wrapped = fm;
  88:     }
  89: 
  90:     /**
  91:      * Wraps {@link DefaultKeyboardFocusManager#dispatchEvent(AWTEvent)}.
  92:      *
  93:      * @param ev the event to dispatch
  94:      *
  95:      * @return <code>true</code> if the event has been dispatched,
  96:      *         <code>false</code> otherwise
  97:      */
  98:     public boolean dispatchEvent(AWTEvent ev)
  99:     {
 100:       return wrapped.dispatchEvent(ev);
 101:     }
 102: 
 103:     /**
 104:      * Wraps {@link DefaultKeyboardFocusManager#dispatchKeyEvent(KeyEvent)}.
 105:      *
 106:      * @param ev the event to dispatch
 107:      *
 108:      * @return <code>true</code> if the event has been dispatched,
 109:      *         <code>false</code> otherwise
 110:      */
 111:     public boolean dispatchKeyEvent(KeyEvent ev)
 112:     {
 113:       return wrapped.dispatchKeyEvent(ev);
 114:     }
 115: 
 116:     /**
 117:      * Wraps {@link DefaultKeyboardFocusManager#downFocusCycle(Container)}.
 118:      *
 119:      * @param c the container
 120:      */
 121:     public void downFocusCycle(Container c)
 122:     {
 123:       wrapped.downFocusCycle(c);
 124:     }
 125: 
 126:     /**
 127:      * Wraps {@link DefaultKeyboardFocusManager#upFocusCycle(Container)}.
 128:      *
 129:      * @param c the container
 130:      */
 131:     public void upFocusCycle(Container c)
 132:     {
 133:       wrapped.upFocusCycle(c);
 134:     }
 135: 
 136:     /**
 137:      * Wraps {@link DefaultKeyboardFocusManager#focusNextComponent(Component)}.
 138:      *
 139:      * @param c the component
 140:      */
 141:     public void focusNextComponent(Component c)
 142:     {
 143:       wrapped.focusNextComponent(c);
 144:     }
 145: 
 146:     /**
 147:      * Wraps
 148:      * {@link DefaultKeyboardFocusManager#focusPreviousComponent(Component)}.
 149:      *
 150:      * @param c the component
 151:      */
 152:     public void focusPreviousComponent(Component c)
 153:     {
 154:       wrapped.focusPreviousComponent(c);
 155:     }
 156: 
 157:     /**
 158:      * Wraps {@link DefaultKeyboardFocusManager#postProcessKeyEvent(KeyEvent)}.
 159:      *
 160:      * @param e the key event
 161:      *
 162:      * @return a boolead
 163:      */
 164:     public boolean postProcessKeyEvent(KeyEvent e)
 165:     {
 166:       return wrapped.postProcessKeyEvent(e);
 167:     }
 168: 
 169:     /**
 170:      * Wraps
 171:      * {@link DefaultKeyboardFocusManager#processKeyEvent(Component, KeyEvent)}.
 172:      *
 173:      * @param c the component
 174:      * @param e the key event
 175:      */
 176:     public void processKeyEvent(Component c, KeyEvent e)
 177:     {
 178:       wrapped.processKeyEvent(c, e);
 179:     }
 180: 
 181:     /**
 182:      * Wraps
 183:      * {@link KeyboardFocusManager#addKeyEventDispatcher(KeyEventDispatcher)}.
 184:      *
 185:      * @param d the dispatcher
 186:      */
 187:     public void addKeyEventDispatcher(KeyEventDispatcher d)
 188:     {
 189:       wrapped.addKeyEventDispatcher(d);
 190:     }
 191: 
 192:     /**
 193:      * Wraps
 194:      * {@link KeyboardFocusManager#addKeyEventPostProcessor(KeyEventPostProcessor)}.
 195:      *
 196:      * @param p the post processor
 197:      */
 198:     public void addKeyEventPostProcessor(KeyEventPostProcessor p)
 199:     {
 200:       wrapped.addKeyEventPostProcessor(p);
 201:     }
 202: 
 203:     /**
 204:      * Wraps {@link KeyboardFocusManager#addPropertyChangeListener(PropertyChangeListener)}.
 205:      *
 206:      * @param l the property change listener
 207:      */
 208:     public void addPropertyChangeListener(PropertyChangeListener l)
 209:     {
 210:       wrapped.addPropertyChangeListener(l);
 211:     }
 212: 
 213:     /**
 214:      * Wraps {@link KeyboardFocusManager#addPropertyChangeListener(String, PropertyChangeListener)}.
 215:      *
 216:      * @param p the property name
 217:      * @param l the property change listener
 218:      */
 219:     public void addPropertyChangeListener(String p, PropertyChangeListener l)
 220:     {
 221:       wrapped.addPropertyChangeListener(p, l);
 222:     }
 223: 
 224:     /**
 225:      * Wraps {@link KeyboardFocusManager#addVetoableChangeListener(String, VetoableChangeListener)}.
 226:      *
 227:      * @param p the property name
 228:      * @param l the vetoable change listener
 229:      */
 230:     public void addVetoableChangeListener(String p, VetoableChangeListener l)
 231:     {
 232:       wrapped.addVetoableChangeListener(p, l);
 233:     }
 234: 
 235:     /**
 236:      * Wraps {@link KeyboardFocusManager#addVetoableChangeListener(VetoableChangeListener)}.
 237:      *
 238:      * @param l the vetoable change listener
 239:      */
 240:     public void addVetoableChangeListener(VetoableChangeListener l)
 241:     {
 242:       wrapped.addVetoableChangeListener(l);
 243:     }
 244: 
 245:     /**
 246:      * Wraps {@link KeyboardFocusManager#clearGlobalFocusOwner()}.
 247:      */
 248:     public void clearGlobalFocusOwner()
 249:     {
 250:       wrapped.clearGlobalFocusOwner();
 251:     }
 252: 
 253:     /**
 254:      * Wraps {@link KeyboardFocusManager#getActiveWindow()}.
 255:      *
 256:      * @return the active window
 257:      */
 258:     public Window getActiveWindow()
 259:     {
 260:       return wrapped.getActiveWindow();
 261:     }
 262: 
 263:     /**
 264:      * Wraps {@link KeyboardFocusManager#getCurrentFocusCycleRoot()}.
 265:      *
 266:      * @return the focus cycle root
 267:      */
 268:     public Container getCurrentFocusCycleRoot()
 269:     {
 270:       return wrapped.getCurrentFocusCycleRoot();
 271:     }
 272: 
 273:     /**
 274:      * Wraps {@link KeyboardFocusManager#getDefaultFocusTraversalKeys(int)}.
 275:      *
 276:      * @param i the ID
 277:      *
 278:      * @return the focus traversal keys
 279:      */
 280:     public Set getDefaultFocusTraversalKeys(int i)
 281:     {
 282:       return wrapped.getDefaultFocusTraversalKeys(i);
 283:     }
 284: 
 285:     /**
 286:      * Wraps {@link KeyboardFocusManager#getDefaultFocusTraversalPolicy()}.
 287:      *
 288:      * @return the focus traversal policy
 289:      */
 290:     public FocusTraversalPolicy getDefaultFocusTraversalPolicy()
 291:     {
 292:       return wrapped.getDefaultFocusTraversalPolicy();
 293:     }
 294: 
 295:     /**
 296:      * Wraps {@link KeyboardFocusManager#getFocusedWindow()}.
 297:      *
 298:      * @return the focused window
 299:      */
 300:     public Window getFocusedWindow()
 301:     {
 302:       return wrapped.getFocusedWindow();
 303:     }
 304: 
 305:     /**
 306:      * Wraps {@link KeyboardFocusManager#getFocusOwner()}.
 307:      *
 308:      * @return the focus owner
 309:      */
 310:     public Component getFocusOwner()
 311:     {
 312:       return wrapped.getFocusOwner();
 313:     }
 314: 
 315:     /**
 316:      * Wraps {@link KeyboardFocusManager#getPermanentFocusOwner()}.
 317:      *
 318:      * @return the focus owner
 319:      */
 320:     public Component getPermanentFocusOwner()
 321:     {
 322:       return wrapped.getPermanentFocusOwner();
 323:     }
 324: 
 325:     /**
 326:      * Wraps {@link KeyboardFocusManager#getPropertyChangeListeners()}.
 327:      *
 328:      * @return the property change listeners
 329:      */
 330:     public PropertyChangeListener[] getPropertyChangeListeners()
 331:     {
 332:       return wrapped.getPropertyChangeListeners();
 333:     }
 334: 
 335:     /**
 336:      * Wraps {@link KeyboardFocusManager#getPropertyChangeListeners(String)}.
 337:      *
 338:      * @param n the property name
 339:      *
 340:      * @return the property change listeners
 341:      */
 342:     public PropertyChangeListener[] getPropertyChangeListeners(String n)
 343:     {
 344:       return wrapped.getPropertyChangeListeners(n);
 345:     }
 346: 
 347:     /**
 348:      * Wraps {@link KeyboardFocusManager#getVetoableChangeListeners()}.
 349:      *
 350:      * @return the vetoable change listeners
 351:      */
 352:     public VetoableChangeListener[] getVetoableChangeListeners()
 353:     {
 354:       return wrapped.getVetoableChangeListeners();
 355:     }
 356: 
 357:     /**
 358:      * Wraps {@link KeyboardFocusManager#getVetoableChangeListeners(String)}.
 359:      *
 360:      * @param n the property name
 361:      *
 362:      * @return the vetoable change listeners
 363:      */
 364:     public VetoableChangeListener[] getVetoableChangeListeners(String n)
 365:     {
 366:       return wrapped.getVetoableChangeListeners(n);
 367:     }
 368: 
 369: 
 370:     /**
 371:      * Wraps
 372:      * {@link KeyboardFocusManager#removeKeyEventDispatcher(KeyEventDispatcher)}.
 373:      *
 374:      * @param d the key event dispatcher to remove
 375:      */
 376:     public void removeKeyEventDispatcher(KeyEventDispatcher d)
 377:     {
 378:       wrapped.removeKeyEventDispatcher(d);
 379:     }
 380: 
 381:     /**
 382:      * Wraps
 383:      * {@link KeyboardFocusManager#removeKeyEventPostProcessor(KeyEventPostProcessor)}.
 384:      *
 385:      * @param p the post processor
 386:      */
 387:     public void removeKeyEventPostProcessor(KeyEventPostProcessor p)
 388:     {
 389:       wrapped.removeKeyEventPostProcessor(p);
 390:     }
 391: 
 392:     /**
 393:      * Wraps
 394:      * {@link KeyboardFocusManager#removePropertyChangeListener(PropertyChangeListener)}.
 395:      *
 396:      * @param l the listener
 397:      */
 398:     public void removePropertyChangeListener(PropertyChangeListener l)
 399:     {
 400:       wrapped.removePropertyChangeListener(l);
 401:     }
 402: 
 403:     /**
 404:      * Wraps
 405:      * {@link KeyboardFocusManager#removePropertyChangeListener(String, PropertyChangeListener)}.
 406:      *
 407:      * @param n the property name
 408:      * @param l the listener
 409:      */
 410:     public void removePropertyChangeListener(String n, PropertyChangeListener l)
 411:     {
 412:       wrapped.removePropertyChangeListener(n, l);
 413:     }
 414: 
 415:     /**
 416:      * Wraps
 417:      * {@link KeyboardFocusManager#removeVetoableChangeListener(VetoableChangeListener)}.
 418:      *
 419:      * @param l the listener
 420:      */
 421:     public void removeVetoableChangeListener(VetoableChangeListener l)
 422:     {
 423:       wrapped.removeVetoableChangeListener(l);
 424:     }
 425: 
 426:     /**
 427:      * Wraps
 428:      * {@link KeyboardFocusManager#removeVetoableChangeListener(String, VetoableChangeListener)}.
 429:      *
 430:      * @param n the property name
 431:      * @param l the listener
 432:      */
 433:     public void removeVetoableChangeListener(String n, VetoableChangeListener l)
 434:     {
 435:       wrapped.removeVetoableChangeListener(n, l);
 436:     }
 437: 
 438:     /**
 439:      * Wraps
 440:      * {@link KeyboardFocusManager#setDefaultFocusTraversalKeys(int, Set)}.
 441:      *
 442:      * @param id the ID
 443:      * @param k the keystrokes
 444:      */
 445:     public void setDefaultFocusTraversalKeys(int id, Set k)
 446:     {
 447:       wrapped.setDefaultFocusTraversalKeys(id, k);
 448:     }
 449: 
 450:     /**
 451:      * Wraps {@link KeyboardFocusManager#setDefaultFocusTraversalPolicy(FocusTraversalPolicy)}.
 452:      *
 453:      * @param p the focus traversal policy
 454:      */
 455:     public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy p)
 456:     {
 457:       wrapped.setDefaultFocusTraversalPolicy(p);
 458:     }
 459: 
 460:     /**
 461:      * Wraps
 462:      * {@link KeyboardFocusManager#setGlobalCurrentFocusCycleRoot(Container)}.
 463:      *
 464:      * @param r the focus cycle root
 465:      */
 466:     public void setGlobalCurrentFocusCycleRoot(Container r)
 467:     {
 468:       wrapped.setGlobalCurrentFocusCycleRoot(r);
 469:     }
 470:   }
 471: 
 472:   /**
 473:    * FOCUS_MANAGER_CLASS_PROPERTY
 474:    */
 475:   public static final String FOCUS_MANAGER_CLASS_PROPERTY =
 476:     "FocusManagerClassName";
 477: 
 478:   /**
 479:    * Constructor FocusManager
 480:    */
 481:   public FocusManager()
 482:   {
 483:     super();
 484:   }
 485: 
 486:   /**
 487:    * getCurrentManager
 488:    * @return FocusManager
 489:    */
 490:   public static FocusManager getCurrentManager()
 491:   {
 492:     KeyboardFocusManager m =
 493:       KeyboardFocusManager.getCurrentKeyboardFocusManager();
 494:     return new WrappingFocusManager(m);
 495:   }
 496: 
 497:   /**
 498:    * setCurrentManager
 499:    * @param manager TODO
 500:    */
 501:   public static void setCurrentManager(FocusManager manager)
 502:   {
 503:     KeyboardFocusManager.setCurrentKeyboardFocusManager(manager);
 504:   }
 505: 
 506:   /**
 507:    * disableSwingFocusManager
 508:    * @deprecated 1.4
 509:    */
 510:   public static void disableSwingFocusManager()
 511:   {
 512:     // TODO
 513:   }
 514: 
 515:   /**
 516:    * isFocusManagerEnabled
 517:    * @return boolean
 518:    * @deprecated 1.4
 519:    */
 520:   public static boolean isFocusManagerEnabled()
 521:   {
 522:     return false; // TODO
 523:   }
 524: }