< prev index next >
src/java.desktop/share/classes/javax/swing/Timer.java
Print this page
@@ -44,22 +44,22 @@
/**
* Fires one or more {@code ActionEvent}s at specified
* intervals. An example use is an animation object that uses a
- * <code>Timer</code> as the trigger for drawing its frames.
+ * {@code Timer} as the trigger for drawing its frames.
*<p>
* Setting up a timer
- * involves creating a <code>Timer</code> object,
+ * involves creating a {@code Timer} object,
* registering one or more action listeners on it,
* and starting the timer using
- * the <code>start</code> method.
+ * the {@code start} method.
* For example,
* the following code creates and starts a timer
* that fires an action event once per second
- * (as specified by the first argument to the <code>Timer</code> constructor).
- * The second argument to the <code>Timer</code> constructor
+ * (as specified by the first argument to the {@code Timer} constructor).
+ * The second argument to the {@code Timer} constructor
* specifies a listener to receive the timer's action events.
*
*<pre>
* int delay = 1000; //milliseconds
* ActionListener taskPerformer = new ActionListener() {
@@ -73,40 +73,40 @@
* {@code Timers} are constructed by specifying both a delay parameter
* and an {@code ActionListener}. The delay parameter is used
* to set both the initial delay and the delay between event
* firing, in milliseconds. Once the timer has been started,
* it waits for the initial delay before firing its
- * first <code>ActionEvent</code> to registered listeners.
+ * first {@code ActionEvent} to registered listeners.
* After this first event, it continues to fire events
* every time the between-event delay has elapsed, until it
* is stopped.
* <p>
* After construction, the initial delay and the between-event
* delay can be changed independently, and additional
- * <code>ActionListeners</code> may be added.
+ * {@code ActionListeners} may be added.
* <p>
* If you want the timer to fire only the first time and then stop,
- * invoke <code>setRepeats(false)</code> on the timer.
+ * invoke {@code setRepeats(false)} on the timer.
* <p>
- * Although all <code>Timer</code>s perform their waiting
+ * Although all {@code Timer}s perform their waiting
* using a single, shared thread
- * (created by the first <code>Timer</code> object that executes),
- * the action event handlers for <code>Timer</code>s
+ * (created by the first {@code Timer} object that executes),
+ * the action event handlers for {@code Timer}s
* execute on another thread -- the event-dispatching thread.
- * This means that the action handlers for <code>Timer</code>s
+ * This means that the action handlers for {@code Timer}s
* can safely perform operations on Swing components.
* However, it also means that the handlers must execute quickly
* to keep the GUI responsive.
*
* <p>
- * In v 1.3, another <code>Timer</code> class was added
- * to the Java platform: <code>java.util.Timer</code>.
- * Both it and <code>javax.swing.Timer</code>
+ * In v 1.3, another {@code Timer} class was added
+ * to the Java platform: {@code java.util.Timer}.
+ * Both it and {@code javax.swing.Timer}
* provide the same basic functionality,
- * but <code>java.util.Timer</code>
+ * but {@code java.util.Timer}
* is more general and has more features.
- * The <code>javax.swing.Timer</code> has two features
+ * The {@code javax.swing.Timer} has two features
* that can make it a little easier to use with GUIs.
* First, its event handling metaphor is familiar to GUI programmers
* and can make dealing with the event-dispatching thread
* a bit simpler.
* Second, its
@@ -123,12 +123,12 @@
* and several examples of using timers by visiting
* <a href="http://docs.oracle.com/javase/tutorial/uiswing/misc/timer.html"
* target = "_top">How to Use Timers</a>,
* a section in <em>The Java Tutorial.</em>
* For more examples and help in choosing between
- * this <code>Timer</code> class and
- * <code>java.util.Timer</code>,
+ * this {@code Timer} class and
+ * {@code java.util.Timer},
* see
* <a href="http://java.sun.com/products/jfc/tsc/articles/timer/"
* target="_top">Using Timers in Swing Applications</a>,
* an article in <em>The Swing Connection.</em>
* <p>
@@ -136,11 +136,11 @@
* Serialized objects of this class will not be compatible with
* future Swing releases. The current serialization support is
* appropriate for short term storage or RMI between applications running
* the same version of Swing. As of 1.4, support for long term storage
* of all JavaBeans™
- * has been added to the <code>java.beans</code> package.
+ * has been added to the {@code java.beans} package.
* Please see {@link java.beans.XMLEncoder}.
*
* @see java.util.Timer
*
*
@@ -193,15 +193,15 @@
/**
* Creates a {@code Timer} and initializes both the initial delay and
* between-event delay to {@code delay} milliseconds. If {@code delay}
* is less than or equal to zero, the timer fires as soon as it
- * is started. If <code>listener</code> is not <code>null</code>,
+ * is started. If {@code listener} is not {@code null},
* it's registered as an action listener on the timer.
*
* @param delay milliseconds for the initial and between-event delay
- * @param listener an initial listener; can be <code>null</code>
+ * @param listener an initial listener; can be {@code null}
*
* @see #addActionListener
* @see #setInitialDelay
* @see #setRepeats
*/
@@ -259,11 +259,11 @@
return Timer.this;
}
}
/**
- * Adds an action listener to the <code>Timer</code>.
+ * Adds an action listener to the {@code Timer}.
*
* @param listener the listener to add
*
* @see #Timer
*/
@@ -271,11 +271,11 @@
listenerList.add(ActionListener.class, listener);
}
/**
- * Removes the specified action listener from the <code>Timer</code>.
+ * Removes the specified action listener from the {@code Timer}.
*
* @param listener the listener to remove
*/
public void removeActionListener(ActionListener listener) {
listenerList.remove(ActionListener.class, listener);
@@ -284,11 +284,11 @@
/**
* Returns an array of all the action listeners registered
* on this timer.
*
- * @return all of the timer's <code>ActionListener</code>s or an empty
+ * @return all of the timer's {@code ActionListener}s or an empty
* array if no action listeners are currently registered
*
* @see #addActionListener
* @see #removeActionListener
*
@@ -320,18 +320,18 @@
}
/**
* Returns an array of all the objects currently registered as
* <code><em>Foo</em>Listener</code>s
- * upon this <code>Timer</code>.
+ * upon this {@code Timer}.
* <code><em>Foo</em>Listener</code>s
* are registered using the <code>add<em>Foo</em>Listener</code> method.
* <p>
- * You can specify the <code>listenerType</code> argument
+ * You can specify the {@code listenerType} argument
* with a class literal, such as <code><em>Foo</em>Listener.class</code>.
- * For example, you can query a <code>Timer</code>
- * instance <code>t</code>
+ * For example, you can query a {@code Timer}
+ * instance {@code t}
* for its action listeners
* with the following code:
*
* <pre>ActionListener[] als = (ActionListener[])(t.getListeners(ActionListener.class));</pre>
*
@@ -339,19 +339,19 @@
* this method returns an empty array.
*
* @param <T> the type of {@code EventListener} class being requested
* @param listenerType the type of listeners requested;
* this parameter should specify an interface
- * that descends from <code>java.util.EventListener</code>
+ * that descends from {@code java.util.EventListener}
* @return an array of all objects registered as
* <code><em>Foo</em>Listener</code>s
* on this timer,
* or an empty array if no such
* listeners have been added
- * @exception ClassCastException if <code>listenerType</code> doesn't
+ * @exception ClassCastException if {@code listenerType} doesn't
* specify a class or interface that implements
- * <code>java.util.EventListener</code>
+ * {@code java.util.EventListener}
*
* @see #getActionListeners
* @see #addActionListener
* @see #removeActionListener
*
@@ -369,33 +369,33 @@
}
/**
* Enables or disables the timer log. When enabled, a message
- * is posted to <code>System.out</code> whenever the timer goes off.
+ * is posted to {@code System.out} whenever the timer goes off.
*
- * @param flag <code>true</code> to enable logging
+ * @param flag {@code true} to enable logging
* @see #getLogTimers
*/
public static void setLogTimers(boolean flag) {
logTimers = flag;
}
/**
- * Returns <code>true</code> if logging is enabled.
+ * Returns {@code true} if logging is enabled.
*
- * @return <code>true</code> if logging is enabled; otherwise, false
+ * @return {@code true} if logging is enabled; otherwise, false
* @see #setLogTimers
*/
public static boolean getLogTimers() {
return logTimers;
}
/**
- * Sets the <code>Timer</code>'s between-event delay, the number of milliseconds
+ * Sets the {@code Timer}'s between-event delay, the number of milliseconds
* between successive action events. This does not affect the initial delay
* property, which can be set by the {@code setInitialDelay} method.
*
* @param delay the delay in milliseconds
* @see #setInitialDelay
@@ -423,11 +423,11 @@
return delay;
}
/**
- * Sets the <code>Timer</code>'s initial delay, the time
+ * Sets the {@code Timer}'s initial delay, the time
* in milliseconds to wait after the timer is started
* before firing the first event. Upon construction, this
* is set to be the same as the between-event delay,
* but then its value is independent and remains unaffected
* by changes to the between-event delay.
@@ -452,25 +452,25 @@
return initialDelay;
}
/**
- * If <code>flag</code> is <code>false</code>,
- * instructs the <code>Timer</code> to send only one
+ * If {@code flag} is {@code false},
+ * instructs the {@code Timer} to send only one
* action event to its listeners.
*
- * @param flag specify <code>false</code> to make the timer
+ * @param flag specify {@code false} to make the timer
* stop after sending its first action event
*/
public void setRepeats(boolean flag) {
repeats = flag;
}
/**
- * Returns <code>true</code> (the default)
- * if the <code>Timer</code> will send
+ * Returns {@code true} (the default)
+ * if the {@code Timer} will send
* an action event
* to its listeners multiple times.
*
* @return true if the {@code Timer} will send an action event to its
* listeners multiple times
@@ -480,24 +480,24 @@
return repeats;
}
/**
- * Sets whether the <code>Timer</code> coalesces multiple pending
- * <code>ActionEvent</code> firings.
+ * Sets whether the {@code Timer} coalesces multiple pending
+ * {@code ActionEvent} firings.
* A busy application may not be able
- * to keep up with a <code>Timer</code>'s event generation,
+ * to keep up with a {@code Timer}'s event generation,
* causing multiple
* action events to be queued. When processed,
* the application sends these events one after the other, causing the
- * <code>Timer</code>'s listeners to receive a sequence of
+ * {@code Timer}'s listeners to receive a sequence of
* events with no delay between them. Coalescing avoids this situation
* by reducing multiple pending events to a single event.
- * <code>Timer</code>s
+ * {@code Timer}s
* coalesce events by default.
*
- * @param flag specify <code>false</code> to turn off coalescing
+ * @param flag specify {@code false} to turn off coalescing
*/
public void setCoalesce(boolean flag) {
boolean old = coalesce;
coalesce = flag;
if (!old && coalesce) {
@@ -522,12 +522,12 @@
}
/**
* Sets the string that will be delivered as the action command
- * in <code>ActionEvent</code>s fired by this timer.
- * <code>null</code> is an acceptable value.
+ * in {@code ActionEvent}s fired by this timer.
+ * {@code null} is an acceptable value.
*
* @param command the action command
* @since 1.6
*/
public void setActionCommand(String command) {
@@ -535,23 +535,23 @@
}
/**
* Returns the string that will be delivered as the action command
- * in <code>ActionEvent</code>s fired by this timer. May be
- * <code>null</code>, which is also the default.
+ * in {@code ActionEvent}s fired by this timer. May be
+ * {@code null}, which is also the default.
*
* @return the action command used in firing events
* @since 1.6
*/
public String getActionCommand() {
return actionCommand;
}
/**
- * Starts the <code>Timer</code>,
+ * Starts the {@code Timer},
* causing it to start sending action events
* to its listeners.
*
* @see #stop
*/
@@ -570,11 +570,11 @@
return timerQueue().containsTimer(this);
}
/**
- * Stops the <code>Timer</code>,
+ * Stops the {@code Timer},
* causing it to stop sending action events
* to its listeners.
*
* @see #start
*/
@@ -588,11 +588,11 @@
}
}
/**
- * Restarts the <code>Timer</code>,
+ * Restarts the {@code Timer},
* canceling any pending firings and causing
* it to fire with its initial delay.
*/
public void restart() {
getLock().lock();
@@ -606,11 +606,11 @@
/**
* Resets the internal state to indicate this Timer shouldn't notify
* any of its listeners. This does not stop a repeatable Timer from
- * firing again, use <code>stop</code> for that.
+ * firing again, use {@code stop} for that.
*/
void cancelEvent() {
notify.set(false);
}
< prev index next >