< prev index next >

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

Print this page

        

@@ -49,40 +49,40 @@
 
 import jdk.internal.misc.SharedSecrets;
 import jdk.internal.misc.JavaSecurityAccess;
 
 /**
- * <code>EventQueue</code> is a platform-independent class
+ * {@code EventQueue} is a platform-independent class
  * that queues events, both from the underlying peer classes
  * and from trusted application classes.
  * <p>
  * It encapsulates asynchronous event dispatch machinery which
  * extracts events from the queue and dispatches them by calling
  * {@link #dispatchEvent(AWTEvent) dispatchEvent(AWTEvent)} method
- * on this <code>EventQueue</code> with the event to be dispatched
+ * on this {@code EventQueue} with the event to be dispatched
  * as an argument.  The particular behavior of this machinery is
  * implementation-dependent.  The only requirements are that events
  * which were actually enqueued to this queue (note that events
- * being posted to the <code>EventQueue</code> can be coalesced)
+ * being posted to the {@code EventQueue} can be coalesced)
  * are dispatched:
  * <dl>
  *   <dt> Sequentially.
  *   <dd> That is, it is not permitted that several events from
  *        this queue are dispatched simultaneously.
  *   <dt> In the same order as they are enqueued.
- *   <dd> That is, if <code>AWTEvent</code>&nbsp;A is enqueued
- *        to the <code>EventQueue</code> before
- *        <code>AWTEvent</code>&nbsp;B then event B will not be
+ *   <dd> That is, if {@code AWTEvent}&nbsp;A is enqueued
+ *        to the {@code EventQueue} before
+ *        {@code AWTEvent}&nbsp;B then event B will not be
  *        dispatched before event A.
  * </dl>
  * <p>
  * Some browsers partition applets in different code bases into
  * separate contexts, and establish walls between these contexts.
- * In such a scenario, there will be one <code>EventQueue</code>
+ * In such a scenario, there will be one {@code EventQueue}
  * per context. Other browsers place all applets into the same
  * context, implying that there will be only a single, global
- * <code>EventQueue</code> for all applets. This behavior is
+ * {@code EventQueue} for all applets. This behavior is
  * implementation-dependent.  Consult your browser's documentation
  * for more information.
  * <p>
  * For information on the threading issues of the event dispatch
  * machinery, see <a href="doc-files/AWTThreadIssues.html#Autoshutdown"

@@ -249,31 +249,31 @@
         pushPopLock = (Lock)appContext.get(AppContext.EVENT_QUEUE_LOCK_KEY);
         pushPopCond = (Condition)appContext.get(AppContext.EVENT_QUEUE_COND_KEY);
     }
 
     /**
-     * Posts a 1.1-style event to the <code>EventQueue</code>.
+     * Posts a 1.1-style event to the {@code EventQueue}.
      * If there is an existing event on the queue with the same ID
-     * and event source, the source <code>Component</code>'s
-     * <code>coalesceEvents</code> method will be called.
+     * and event source, the source {@code Component}'s
+     * {@code coalesceEvents} method will be called.
      *
-     * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
+     * @param theEvent an instance of {@code java.awt.AWTEvent},
      *          or a subclass of it
-     * @throws NullPointerException if <code>theEvent</code> is <code>null</code>
+     * @throws NullPointerException if {@code theEvent} is {@code null}
      */
     public void postEvent(AWTEvent theEvent) {
         SunToolkit.flushPendingEvents(appContext);
         postEventPrivate(theEvent);
     }
 
     /**
-     * Posts a 1.1-style event to the <code>EventQueue</code>.
+     * Posts a 1.1-style event to the {@code EventQueue}.
      * If there is an existing event on the queue with the same ID
-     * and event source, the source <code>Component</code>'s
-     * <code>coalesceEvents</code> method will be called.
+     * and event source, the source {@code Component}'s
+     * {@code coalesceEvents} method will be called.
      *
-     * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
+     * @param theEvent an instance of {@code java.awt.AWTEvent},
      *          or a subclass of it
      */
     private final void postEventPrivate(AWTEvent theEvent) {
         theEvent.isPosted = true;
         pushPopLock.lock();

@@ -318,11 +318,11 @@
 
     /**
      * Posts the event to the internal Queue of specified priority,
      * coalescing as appropriate.
      *
-     * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
+     * @param theEvent an instance of {@code java.awt.AWTEvent},
      *          or a subclass of it
      * @param priority  the desired priority of the event
      */
     private void postEvent(AWTEvent theEvent, int priority) {
         if (coalesceEvent(theEvent, priority)) {

@@ -530,14 +530,14 @@
 
         return true;
     }
 
     /**
-     * Removes an event from the <code>EventQueue</code> and
+     * Removes an event from the {@code EventQueue} and
      * returns it.  This method will block until an event has
      * been posted by another thread.
-     * @return the next <code>AWTEvent</code>
+     * @return the next {@code AWTEvent}
      * @exception InterruptedException
      *            if any thread has interrupted this thread
      */
     public AWTEvent getNextEvent() throws InterruptedException {
         do {

@@ -615,11 +615,11 @@
             }
         } while(true);
     }
 
     /**
-     * Returns the first event on the <code>EventQueue</code>
+     * Returns the first event on the {@code EventQueue}
      * without removing it.
      * @return the first event
      */
     public AWTEvent peekEvent() {
         pushPopLock.lock();

@@ -637,11 +637,11 @@
     }
 
     /**
      * Returns the first event with the specified id, if any.
      * @param id the id of the type of event desired
-     * @return the first event of the specified id or <code>null</code>
+     * @return the first event of the specified id or {@code null}
      *    if there is no such event
      */
     public AWTEvent peekEvent(int id) {
         pushPopLock.lock();
         try {

@@ -694,13 +694,13 @@
      *     <td>Other</td>
      *     <td>No action (ignored)</td>
      * </tr>
      * </table>
      *
-     * @param event an instance of <code>java.awt.AWTEvent</code>,
+     * @param event an instance of {@code java.awt.AWTEvent},
      *          or a subclass of it
-     * @throws NullPointerException if <code>event</code> is <code>null</code>
+     * @throws NullPointerException if {@code event} is {@code null}
      * @since           1.2
      */
     protected void dispatchEvent(final AWTEvent event) {
         final Object src = event.getSource();
         final PrivilegedAction<Void> action = new PrivilegedAction<Void>() {

@@ -775,27 +775,27 @@
         }
     }
 
     /**
      * Returns the timestamp of the most recent event that had a timestamp, and
-     * that was dispatched from the <code>EventQueue</code> associated with the
+     * that was dispatched from the {@code EventQueue} associated with the
      * calling thread. If an event with a timestamp is currently being
      * dispatched, its timestamp will be returned. If no events have yet
      * been dispatched, the EventQueue's initialization time will be
      * returned instead.In the current version of
-     * the JDK, only <code>InputEvent</code>s,
-     * <code>ActionEvent</code>s, and <code>InvocationEvent</code>s have
+     * the JDK, only {@code InputEvent}s,
+     * {@code ActionEvent}s, and {@code InvocationEvent}s have
      * timestamps; however, future versions of the JDK may add timestamps to
      * additional event types. Note that this method should only be invoked
      * from an application's {@link #isDispatchThread event dispatching thread}.
      * If this method is
      * invoked from another thread, the current system time (as reported by
-     * <code>System.currentTimeMillis()</code>) will be returned instead.
+     * {@code System.currentTimeMillis()}) will be returned instead.
      *
-     * @return the timestamp of the last <code>InputEvent</code>,
-     *         <code>ActionEvent</code>, or <code>InvocationEvent</code> to be
-     *         dispatched, or <code>System.currentTimeMillis()</code> if this
+     * @return the timestamp of the last {@code InputEvent},
+     *         {@code ActionEvent}, or {@code InvocationEvent} to be
+     *         dispatched, or {@code System.currentTimeMillis()} if this
      *         method is invoked on a thread other than an event dispatching
      *         thread
      * @see java.awt.event.InputEvent#getWhen
      * @see java.awt.event.ActionEvent#getWhen
      * @see java.awt.event.InvocationEvent#getWhen

@@ -829,11 +829,11 @@
         }
     }
 
     /**
      * Returns the event currently being dispatched by the
-     * <code>EventQueue</code> associated with the calling thread. This is
+     * {@code EventQueue} associated with the calling thread. This is
      * useful if a method needs access to the event, but was not designed to
      * receive a reference to it as an argument. Note that this method should
      * only be invoked from an application's event dispatching thread. If this
      * method is invoked from another thread, null will be returned.
      *

@@ -854,18 +854,18 @@
             pushPopLock.unlock();
         }
     }
 
     /**
-     * Replaces the existing <code>EventQueue</code> with the specified one.
-     * Any pending events are transferred to the new <code>EventQueue</code>
+     * Replaces the existing {@code EventQueue} with the specified one.
+     * Any pending events are transferred to the new {@code EventQueue}
      * for processing by it.
      *
-     * @param newEventQueue an <code>EventQueue</code>
+     * @param newEventQueue an {@code EventQueue}
      *          (or subclass thereof) instance to be use
      * @see      java.awt.EventQueue#pop
-     * @throws NullPointerException if <code>newEventQueue</code> is <code>null</code>
+     * @throws NullPointerException if {@code newEventQueue} is {@code null}
      * @since           1.2
      */
     public void push(EventQueue newEventQueue) {
         if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
             getEventLog().fine("EventQueue.push(" + newEventQueue + ")");

@@ -919,19 +919,19 @@
             pushPopLock.unlock();
         }
     }
 
     /**
-     * Stops dispatching events using this <code>EventQueue</code>.
+     * Stops dispatching events using this {@code EventQueue}.
      * Any pending events are transferred to the previous
-     * <code>EventQueue</code> for processing.
+     * {@code EventQueue} for processing.
      * <p>
      * Warning: To avoid deadlock, do not declare this method
      * synchronized in a subclass.
      *
      * @exception EmptyStackException if no previous push was made
-     *  on this <code>EventQueue</code>
+     *  on this {@code EventQueue}
      * @see      java.awt.EventQueue#push
      * @since           1.2
      */
     protected void pop() throws EmptyStackException {
         if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {

@@ -1120,14 +1120,14 @@
             pushPopLock.unlock();
         }
     }
 
     /*
-     * Gets the <code>EventDispatchThread</code> for this
-     * <code>EventQueue</code>.
+     * Gets the {@code EventDispatchThread} for this
+     * {@code EventQueue}.
      * @return the event dispatch thread associated with this event queue
-     *         or <code>null</code> if this event queue doesn't have a
+     *         or {@code null} if this event queue doesn't have a
      *         working thread associated with it
      * @see    java.awt.EventQueue#initDispatchThread
      * @see    java.awt.EventQueue#detachDispatchThread
      */
     final EventDispatchThread getDispatchThread() {

@@ -1139,19 +1139,19 @@
         }
     }
 
     /*
      * Removes any pending events for the specified source object.
-     * If removeAllEvents parameter is <code>true</code> then all
+     * If removeAllEvents parameter is {@code true} then all
      * events for the specified source object are removed, if it
-     * is <code>false</code> then <code>SequencedEvent</code>, <code>SentEvent</code>,
-     * <code>FocusEvent</code>, <code>WindowEvent</code>, <code>KeyEvent</code>,
-     * and <code>InputMethodEvent</code> are kept in the queue, but all other
+     * is {@code false} then {@code SequencedEvent}, {@code SentEvent},
+     * {@code FocusEvent}, {@code WindowEvent}, {@code KeyEvent},
+     * and {@code InputMethodEvent} are kept in the queue, but all other
      * events are removed.
      *
      * This method is normally called by the source's
-     * <code>removeNotify</code> method.
+     * {@code removeNotify} method.
      */
     final void removeSourceEvents(Object source, boolean removeAllEvents) {
         SunToolkit.flushPendingEvents(appContext);
         pushPopLock.lock();
         try {

@@ -1247,16 +1247,16 @@
             pushPopLock.unlock();
         }
     }
 
     /**
-     * Causes <code>runnable</code> to have its <code>run</code>
+     * Causes {@code runnable} to have its {@code run}
      * method called in the {@link #isDispatchThread dispatch thread} of
      * {@link Toolkit#getSystemEventQueue the system EventQueue}.
      * This will happen after all pending events are processed.
      *
-     * @param runnable  the <code>Runnable</code> whose <code>run</code>
+     * @param runnable  the {@code Runnable} whose {@code run}
      *                  method should be executed
      *                  asynchronously in the
      *                  {@link #isDispatchThread event dispatch thread}
      *                  of {@link Toolkit#getSystemEventQueue the system EventQueue}
      * @see             #invokeAndWait

@@ -1268,27 +1268,27 @@
         Toolkit.getEventQueue().postEvent(
             new InvocationEvent(Toolkit.getDefaultToolkit(), runnable));
     }
 
     /**
-     * Causes <code>runnable</code> to have its <code>run</code>
+     * Causes {@code runnable} to have its {@code run}
      * method called in the {@link #isDispatchThread dispatch thread} of
      * {@link Toolkit#getSystemEventQueue the system EventQueue}.
      * This will happen after all pending events are processed.
      * The call blocks until this has happened.  This method
      * will throw an Error if called from the
      * {@link #isDispatchThread event dispatcher thread}.
      *
-     * @param runnable  the <code>Runnable</code> whose <code>run</code>
+     * @param runnable  the {@code Runnable} whose {@code run}
      *                  method should be executed
      *                  synchronously in the
      *                  {@link #isDispatchThread event dispatch thread}
      *                  of {@link Toolkit#getSystemEventQueue the system EventQueue}
      * @exception       InterruptedException  if any thread has
      *                  interrupted this thread
      * @exception       InvocationTargetException  if an throwable is thrown
-     *                  when running <code>runnable</code>
+     *                  when running {@code runnable}
      * @see             #invokeLater
      * @see             Toolkit#getSystemEventQueue
      * @see             #isDispatchThread
      * @since           1.2
      */
< prev index next >