< prev index next >

src/java.desktop/share/classes/java/awt/KeyboardFocusManager.java

Print this page

        

@@ -371,20 +371,20 @@
     private PropertyChangeSupport changeSupport;
 
     /**
      * This KeyboardFocusManager's KeyEventDispatcher chain. The List does not
      * include this KeyboardFocusManager unless it was explicitly re-registered
-     * via a call to <code>addKeyEventDispatcher</code>. If no other
+     * via a call to {@code addKeyEventDispatcher}. If no other
      * KeyEventDispatchers are registered, this field may be null or refer to
      * a List of length 0.
      */
     private java.util.LinkedList<KeyEventDispatcher> keyEventDispatchers;
 
     /**
      * This KeyboardFocusManager's KeyEventPostProcessor chain. The List does
      * not include this KeyboardFocusManager unless it was explicitly
-     * re-registered via a call to <code>addKeyEventPostProcessor</code>.
+     * re-registered via a call to {@code addKeyEventPostProcessor}.
      * If no other KeyEventPostProcessors are registered, this field may be
      * null or refer to a List of length 0.
      */
     private java.util.LinkedList<KeyEventPostProcessor> keyEventPostProcessors;
 

@@ -512,12 +512,12 @@
      * owner. In addition, KeyEventDispatchers may retarget or consume
      * KeyEvents before they reach the focus owner.
      * <p>
      * This method does not actually set the focus to the specified Component.
      * It merely stores the value to be subsequently returned by
-     * <code>getFocusOwner()</code>. Use <code>Component.requestFocus()</code>
-     * or <code>Component.requestFocusInWindow()</code> to change the focus
+     * {@code getFocusOwner()}. Use {@code Component.requestFocus()}
+     * or {@code Component.requestFocusInWindow()} to change the focus
      * owner, subject to platform limitations.
      *
      * @param focusOwner the focus owner
      * @see #getFocusOwner
      * @see #getGlobalFocusOwner

@@ -603,11 +603,11 @@
      * Clears the global focus owner at both the Java and native levels. If
      * there exists a focus owner, that Component will receive a permanent
      * FOCUS_LOST event. After this operation completes, the native windowing
      * system will discard all user-generated KeyEvents until the user selects
      * a new Component to receive focus, or a Component is given focus
-     * explicitly via a call to <code>requestFocus()</code>. This operation
+     * explicitly via a call to {@code requestFocus()}. This operation
      * does not change the focused or active Windows.
      * <p>
      * If a SecurityManager is installed, the calling thread must be granted
      * the "replaceKeyboardFocusManager" AWTPermission. If this permission is
      * not granted, this method will throw a SecurityException, and the current

@@ -727,13 +727,13 @@
      * the permanent focus owner will again be the focus owner when the
      * temporary focus change ends.
      * <p>
      * This method does not actually set the focus to the specified Component.
      * It merely stores the value to be subsequently returned by
-     * <code>getPermanentFocusOwner()</code>. Use
-     * <code>Component.requestFocus()</code> or
-     * <code>Component.requestFocusInWindow()</code> to change the focus owner,
+     * {@code getPermanentFocusOwner()}. Use
+     * {@code Component.requestFocus()} or
+     * {@code Component.requestFocusInWindow()} to change the focus owner,
      * subject to platform limitations.
      *
      * @param permanentFocusOwner the permanent focus owner
      * @see #getPermanentFocusOwner
      * @see #getGlobalPermanentFocusOwner

@@ -830,13 +830,13 @@
      * contains the focus owner. The operation will be cancelled if the
      * specified Window to focus is not a focusable Window.
      * <p>
      * This method does not actually change the focused Window as far as the
      * native windowing system is concerned. It merely stores the value to be
-     * subsequently returned by <code>getFocusedWindow()</code>. Use
-     * <code>Component.requestFocus()</code> or
-     * <code>Component.requestFocusInWindow()</code> to change the focused
+     * subsequently returned by {@code getFocusedWindow()}. Use
+     * {@code Component.requestFocus()} or
+     * {@code Component.requestFocusInWindow()} to change the focused
      * Window, subject to platform limitations.
      *
      * @param focusedWindow the focused Window
      * @see #getFocusedWindow
      * @see #getGlobalFocusedWindow

@@ -936,13 +936,13 @@
      * active Window is always either the focused Window, or the first Frame or
      * Dialog that is an owner of the focused Window.
      * <p>
      * This method does not actually change the active Window as far as the
      * native windowing system is concerned. It merely stores the value to be
-     * subsequently returned by <code>getActiveWindow()</code>. Use
-     * <code>Component.requestFocus()</code> or
-     * <code>Component.requestFocusInWindow()</code>to change the active
+     * subsequently returned by {@code getActiveWindow()}. Use
+     * {@code Component.requestFocus()} or
+     * {@code Component.requestFocusInWindow()} to change the active
      * Window, subject to platform limitations.
      *
      * @param activeWindow the active Window
      * @see #getActiveWindow
      * @see #getGlobalActiveWindow

@@ -1166,20 +1166,20 @@
      * Returns a Set of default focus traversal keys for a given traversal
      * operation. This traversal key Set will be in effect on all Windows that
      * have no such Set of their own explicitly defined. This Set will also be
      * inherited, recursively, by any child Component of those Windows that has
      * no such Set of its own explicitly defined. (See
-     * <code>setDefaultFocusTraversalKeys</code> for a full description of each
+     * {@code setDefaultFocusTraversalKeys} for a full description of each
      * operation.)
      *
      * @param id one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
      *        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
      *        KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
      *        KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
-     * @return the <code>Set</code> of <code>AWTKeyStroke</code>s
-     *         for the specified operation; the <code>Set</code>
-     *         will be unmodifiable, and may be empty; <code>null</code>
+     * @return the {@code Set} of {@code AWTKeyStroke}s
+     *         for the specified operation; the {@code Set}
+     *         will be unmodifiable, and may be empty; {@code null}
      *         will never be returned
      * @see #setDefaultFocusTraversalKeys
      * @see Component#setFocusTraversalKeys
      * @see Component#getFocusTraversalKeys
      * @throws IllegalArgumentException if id is not one of

@@ -1367,11 +1367,11 @@
     /**
      * Returns an array of all the property change listeners
      * registered on this keyboard focus manager.
      *
      * @return all of this keyboard focus manager's
-     *         <code>PropertyChangeListener</code>s
+     *         {@code PropertyChangeListener}s
      *         or an empty array if no property change
      *         listeners are currently registered
      *
      * @see #addPropertyChangeListener
      * @see #removePropertyChangeListener

@@ -1454,15 +1454,15 @@
             }
         }
     }
 
     /**
-     * Returns an array of all the <code>PropertyChangeListener</code>s
+     * Returns an array of all the {@code PropertyChangeListener}s
      * associated with the named property.
      *
      * @param  propertyName the property name
-     * @return all of the <code>PropertyChangeListener</code>s associated with
+     * @return all of the {@code PropertyChangeListener}s associated with
      *         the named property or an empty array if no such listeners have
      *         been added.
      *
      * @see #addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
      * @see #removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)

@@ -1550,11 +1550,11 @@
     /**
      * Returns an array of all the vetoable change listeners
      * registered on this keyboard focus manager.
      *
      * @return all of this keyboard focus manager's
-     *         <code>VetoableChangeListener</code>s
+     *         {@code VetoableChangeListener}s
      *         or an empty array if no vetoable change
      *         listeners are currently registered
      *
      * @see #addVetoableChangeListener
      * @see #removeVetoableChangeListener

@@ -1624,15 +1624,15 @@
             }
         }
     }
 
     /**
-     * Returns an array of all the <code>VetoableChangeListener</code>s
+     * Returns an array of all the {@code VetoableChangeListener}s
      * associated with the named property.
      *
      * @param  propertyName the property name
-     * @return all of the <code>VetoableChangeListener</code>s associated with
+     * @return all of the {@code VetoableChangeListener}s associated with
      *         the named property or an empty array if no such listeners have
      *         been added.
      *
      * @see #addVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)
      * @see #removeVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)

@@ -1657,12 +1657,12 @@
      *
      * @param propertyName the name of the property that has changed
      * @param oldValue the property's previous value
      * @param newValue the property's new value
      * @throws java.beans.PropertyVetoException if a
-     *         <code>VetoableChangeListener</code> threw
-     *         <code>PropertyVetoException</code>
+     *         {@code VetoableChangeListener} threw
+     *         {@code PropertyVetoException}
      */
     protected void fireVetoableChange(String propertyName, Object oldValue,
                                       Object newValue)
         throws PropertyVetoException
     {

@@ -1681,12 +1681,12 @@
      * Adds a KeyEventDispatcher to this KeyboardFocusManager's dispatcher
      * chain. This KeyboardFocusManager will request that each
      * KeyEventDispatcher dispatch KeyEvents generated by the user before
      * finally dispatching the KeyEvent itself. KeyEventDispatchers will be
      * notified in the order in which they were added. Notifications will halt
-     * as soon as one KeyEventDispatcher returns <code>true</code> from its
-     * <code>dispatchKeyEvent</code> method. There is no limit to the total
+     * as soon as one KeyEventDispatcher returns {@code true} from its
+     * {@code dispatchKeyEvent} method. There is no limit to the total
      * number of KeyEventDispatchers which can be added, nor to the number of
      * times which a particular KeyEventDispatcher instance can be added.
      * <p>
      * If a null dispatcher is specified, no action is taken and no exception
      * is thrown.

@@ -1712,11 +1712,11 @@
 
     /**
      * Removes a KeyEventDispatcher which was previously added to this
      * KeyboardFocusManager's dispatcher chain. This KeyboardFocusManager
      * cannot itself be removed, unless it was explicitly re-registered via a
-     * call to <code>addKeyEventDispatcher</code>.
+     * call to {@code addKeyEventDispatcher}.
      * <p>
      * If a null dispatcher is specified, if the specified dispatcher is not
      * in the dispatcher chain, or if this KeyboardFocusManager is specified
      * without having been explicitly re-registered, no action is taken and no
      * exception is thrown.

@@ -1742,11 +1742,11 @@
 
     /**
      * Returns this KeyboardFocusManager's KeyEventDispatcher chain as a List.
      * The List will not include this KeyboardFocusManager unless it was
      * explicitly re-registered via a call to
-     * <code>addKeyEventDispatcher</code>. If no other KeyEventDispatchers are
+     * {@code addKeyEventDispatcher}. If no other KeyEventDispatchers are
      * registered, implementations are free to return null or a List of length
      * 0. Client code should not assume one behavior over another, nor should
      * it assume that the behavior, once established, will not change.
      *
      * @return a possibly null or empty List of KeyEventDispatchers

@@ -1768,12 +1768,12 @@
      * its target, KeyboardFocusManager will request that each
      * KeyEventPostProcessor perform any necessary post-processing as part
      * of the KeyEvent's final resolution. KeyEventPostProcessors
      * will be notified in the order in which they were added; the current
      * KeyboardFocusManager will be notified last. Notifications will halt
-     * as soon as one KeyEventPostProcessor returns <code>true</code> from its
-     * <code>postProcessKeyEvent</code> method. There is no limit to the
+     * as soon as one KeyEventPostProcessor returns {@code true} from its
+     * {@code postProcessKeyEvent} method. There is no limit to the
      * total number of KeyEventPostProcessors that can be added, nor to the
      * number of times that a particular KeyEventPostProcessor instance can be
      * added.
      * <p>
      * If a null post-processor is specified, no action is taken and no

@@ -1802,11 +1802,11 @@
 
     /**
      * Removes a previously added KeyEventPostProcessor from this
      * KeyboardFocusManager's post-processor chain. This KeyboardFocusManager
      * cannot itself be entirely removed from the chain. Only additional
-     * references added via <code>addKeyEventPostProcessor</code> can be
+     * references added via {@code addKeyEventPostProcessor} can be
      * removed.
      * <p>
      * If a null post-processor is specified, if the specified post-processor
      * is not in the post-processor chain, or if this KeyboardFocusManager is
      * specified without having been explicitly added, no action is taken and

@@ -1833,11 +1833,11 @@
 
 
     /**
      * Returns this KeyboardFocusManager's KeyEventPostProcessor chain as a
      * List. The List will not include this KeyboardFocusManager unless it was
-     * explicitly added via a call to <code>addKeyEventPostProcessor</code>. If
+     * explicitly added via a call to {@code addKeyEventPostProcessor}. If
      * no KeyEventPostProcessors are registered, implementations are free to
      * return null or a List of length 0. Client code should not assume one
      * behavior over another, nor should it assume that the behavior, once
      * established, will not change.
      *

@@ -1922,30 +1922,30 @@
      * It is expected that all KeyboardFocusManagers will dispatch all
      * FocusEvents, all WindowEvents related to focus, and all KeyEvents.
      * These events should be dispatched based on the KeyboardFocusManager's
      * notion of the focus owner and the focused and active Windows, sometimes
      * overriding the source of the specified AWTEvent. Dispatching must be
-     * done using <code>redispatchEvent</code> to prevent the AWT event
+     * done using {@code redispatchEvent} to prevent the AWT event
      * dispatcher from recursively requesting that the KeyboardFocusManager
-     * dispatch the event again. If this method returns <code>false</code>,
+     * dispatch the event again. If this method returns {@code false},
      * then the AWT event dispatcher will attempt to dispatch the event itself.
      *
      * @param e the AWTEvent to be dispatched
-     * @return <code>true</code> if this method dispatched the event;
-     *         <code>false</code> otherwise
+     * @return {@code true} if this method dispatched the event;
+     *         {@code false} otherwise
      * @see #redispatchEvent
      * @see #dispatchKeyEvent
      */
     public abstract boolean dispatchEvent(AWTEvent e);
 
     /**
      * Redispatches an AWTEvent in such a way that the AWT event dispatcher
      * will not recursively request that the KeyboardFocusManager, or any
      * installed KeyEventDispatchers, dispatch the event again. Client
-     * implementations of <code>dispatchEvent</code> and client-defined
-     * KeyEventDispatchers must call <code>redispatchEvent(target, e)</code>
-     * instead of <code>target.dispatchEvent(e)</code> to dispatch an event.
+     * implementations of {@code dispatchEvent} and client-defined
+     * KeyEventDispatchers must call {@code redispatchEvent(target, e)}
+     * instead of {@code target.dispatchEvent(e)} to dispatch an event.
      * <p>
      * This method is intended to be used only by KeyboardFocusManagers and
      * KeyEventDispatchers. It is not for general client use.
      *
      * @param target the Component to which the event should be dispatched

@@ -1958,34 +1958,34 @@
         target.dispatchEvent(e);
         e.focusManagerIsDispatching = false;
     }
 
     /**
-     * Typically this method will be called by <code>dispatchEvent</code> if no
+     * Typically this method will be called by {@code dispatchEvent} if no
      * other KeyEventDispatcher in the dispatcher chain dispatched the
      * KeyEvent, or if no other KeyEventDispatchers are registered. If an
-     * implementation of this method returns <code>false</code>,
-     * <code>dispatchEvent</code> may try to dispatch the KeyEvent itself, or
-     * may simply return <code>false</code>. If <code>true</code> is returned,
-     * <code>dispatchEvent</code> should return <code>true</code> as well.
+     * implementation of this method returns {@code false},
+     * {@code dispatchEvent} may try to dispatch the KeyEvent itself, or
+     * may simply return {@code false}. If {@code true} is returned,
+     * {@code dispatchEvent} should return {@code true} as well.
      *
      * @param e the KeyEvent which the current KeyboardFocusManager has
      *        requested that this KeyEventDispatcher dispatch
-     * @return <code>true</code> if the KeyEvent was dispatched;
-     *         <code>false</code> otherwise
+     * @return {@code true} if the KeyEvent was dispatched;
+     *         {@code false} otherwise
      * @see #dispatchEvent
      */
     public abstract boolean dispatchKeyEvent(KeyEvent e);
 
     /**
-     * This method will be called by <code>dispatchKeyEvent</code>.
+     * This method will be called by {@code dispatchKeyEvent}.
      * By default, this method will handle any unconsumed KeyEvents that
-     * map to an AWT <code>MenuShortcut</code> by consuming the event
+     * map to an AWT {@code MenuShortcut} by consuming the event
      * and activating the shortcut.
      *
      * @param e the KeyEvent to post-process
-     * @return <code>true</code> to indicate that no other
+     * @return {@code true} to indicate that no other
      *         KeyEventPostProcessor will be notified of the KeyEvent.
      * @see #dispatchKeyEvent
      * @see MenuShortcut
      */
     public abstract boolean postProcessKeyEvent(KeyEvent e);

@@ -2013,12 +2013,12 @@
      * determines that this request might be granted by the native windowing
      * system, then the AWT will call this method. It is the responsibility of
      * the KeyboardFocusManager to delay dispatching of KeyEvents with
      * timestamps later than the specified time stamp until the specified
      * Component receives a FOCUS_GAINED event, or the AWT cancels the delay
-     * request by invoking <code>dequeueKeyEvents</code> or
-     * <code>discardKeyEvents</code>.
+     * request by invoking {@code dequeueKeyEvents} or
+     * {@code discardKeyEvents}.
      *
      * @param after timestamp of current event, or the current, system time if
      *        the current event has no timestamp, or the AWT cannot determine
      *        which event is currently being handled
      * @param untilFocused Component which should receive a FOCUS_GAINED event

@@ -2030,34 +2030,34 @@
                                              Component untilFocused);
 
     /**
      * Called by the AWT to notify the KeyboardFocusManager that it should
      * cancel delayed dispatching of KeyEvents. All KeyEvents which were
-     * enqueued because of a call to <code>enqueueKeyEvents</code> with the
+     * enqueued because of a call to {@code enqueueKeyEvents} with the
      * same timestamp and Component should be released for normal dispatching
      * to the current focus owner. If the given timestamp is less than zero,
      * the outstanding enqueue request for the given Component with the <b>
      * oldest</b> timestamp (if any) should be cancelled.
      *
      * @param after the timestamp specified in the call to
-     *        <code>enqueueKeyEvents</code>, or any value &lt; 0
+     *        {@code enqueueKeyEvents}, or any value &lt; 0
      * @param untilFocused the Component specified in the call to
-     *        <code>enqueueKeyEvents</code>
+     *        {@code enqueueKeyEvents}
      * @see #enqueueKeyEvents
      * @see #discardKeyEvents
      */
     protected abstract void dequeueKeyEvents(long after,
                                              Component untilFocused);
 
     /**
      * Called by the AWT to notify the KeyboardFocusManager that it should
      * cancel delayed dispatching of KeyEvents. All KeyEvents which were
-     * enqueued because of one or more calls to <code>enqueueKeyEvents</code>
+     * enqueued because of one or more calls to {@code enqueueKeyEvents}
      * with the same Component should be discarded.
      *
      * @param comp the Component specified in one or more calls to
-     *        <code>enqueueKeyEvents</code>
+     *        {@code enqueueKeyEvents}
      * @see #enqueueKeyEvents
      * @see #dequeueKeyEvents
      */
     protected abstract void discardKeyEvents(Component comp);
 
< prev index next >