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    }