001 /* FocusManager.java -- 002 Copyright (C) 2002, 2004 Free Software Foundation, Inc. 003 004 This file is part of GNU Classpath. 005 006 GNU Classpath is free software; you can redistribute it and/or modify 007 it under the terms of the GNU General Public License as published by 008 the Free Software Foundation; either version 2, or (at your option) 009 any later version. 010 011 GNU Classpath is distributed in the hope that it will be useful, but 012 WITHOUT ANY WARRANTY; without even the implied warranty of 013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014 General Public License for more details. 015 016 You should have received a copy of the GNU General Public License 017 along with GNU Classpath; see the file COPYING. If not, write to the 018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 019 02110-1301 USA. 020 021 Linking this library statically or dynamically with other modules is 022 making a combined work based on this library. Thus, the terms and 023 conditions of the GNU General Public License cover the whole 024 combination. 025 026 As a special exception, the copyright holders of this library give you 027 permission to link this library with independent modules to produce an 028 executable, regardless of the license terms of these independent 029 modules, and to copy and distribute the resulting executable under 030 terms of your choice, provided that you also meet, for each linked 031 independent module, the terms and conditions of the license of that 032 module. An independent module is a module which is not derived from 033 or based on this library. If you modify this library, you may extend 034 this exception to your version of the library, but you are not 035 obligated to do so. If you do not wish to do so, delete this 036 exception statement from your version. */ 037 038 039 package javax.swing; 040 041 import java.awt.AWTEvent; 042 import java.awt.Component; 043 import java.awt.Container; 044 import java.awt.DefaultKeyboardFocusManager; 045 import java.awt.FocusTraversalPolicy; 046 import java.awt.KeyEventDispatcher; 047 import java.awt.KeyEventPostProcessor; 048 import java.awt.KeyboardFocusManager; 049 import java.awt.Window; 050 import java.awt.event.KeyEvent; 051 import java.beans.PropertyChangeListener; 052 import java.beans.VetoableChangeListener; 053 import java.util.Set; 054 055 /** 056 * This class has been obsoleted by the new 057 * {@link java.awt.KeyboardFocusManager} and 058 * {@link java.awt.DefaultKeyboardFocusManager} API. 059 * 060 * @author Andrew Selkirk 061 */ 062 public abstract class FocusManager 063 extends DefaultKeyboardFocusManager 064 { 065 /** 066 * A FocusManager that wraps an AWT KeyboardFocusManager and forwards all 067 * method calls to it. This is used for compatibility with the new focus 068 * system. 069 * 070 * @author Roman Kennke (kennke@aicas.com) 071 */ 072 private static class WrappingFocusManager 073 extends FocusManager 074 { 075 /** 076 * The wrapped KeyboardFocusManager. 077 */ 078 private KeyboardFocusManager wrapped; 079 080 /** 081 * Creates a new instance of WrappedFocusManager. 082 * 083 * @param fm the focus manager to wrap 084 */ 085 WrappingFocusManager(KeyboardFocusManager fm) 086 { 087 wrapped = fm; 088 } 089 090 /** 091 * Wraps {@link DefaultKeyboardFocusManager#dispatchEvent(AWTEvent)}. 092 * 093 * @param ev the event to dispatch 094 * 095 * @return <code>true</code> if the event has been dispatched, 096 * <code>false</code> otherwise 097 */ 098 public boolean dispatchEvent(AWTEvent ev) 099 { 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 }