java/awt/EventQueue.java

/* EventQueue.java --
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2005  Free Software Foundation

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package java.awt;

import gnu.java.awt.LowPriorityEvent;
import gnu.java.awt.peer.NativeEventLoopRunningEvent;

import java.awt.event.ActionEvent;
import java.awt.event.InputEvent;
import java.awt.event.InputMethodEvent;
import java.awt.event.InvocationEvent;
import java.awt.event.PaintEvent;
import java.awt.peer.ComponentPeer;
import java.awt.peer.LightweightPeer;
import java.lang.reflect.InvocationTargetException;
import java.util.EmptyStackException;

/* Written using on-line Java 2 Platform Standard Edition v1.3 API
 * Specification, as well as "The Java Class Libraries", 2nd edition
 * (Addison-Wesley, 1998).
 * Status:  Believed complete, but untested.
 */

/**
 * This class manages a queue of <code>AWTEvent</code> objects that
 * are posted to it.  The AWT system uses only one event queue for all
 * events.
 *
 * @author Bryce McKinlay
 * @author Aaron M. Renn (arenn@urbanophile.com)
 */
public class EventQueue
{
  /**
   * Indicates events that are processed with normal priority. This is normally
   * all events except PaintEvents.
   */
  private static final int NORM_PRIORITY = 0;

  /**
   * Indicates events that are processed with lowes priority. This is normally
   * all PaintEvents and LowPriorityEvents.
   */
  private static final int LOW_PRIORITY = 1;

  /**
   * Implements the actual queue. EventQueue has 2 internal queues for
   * different priorities:
   * 1 PaintEvents are always dispatched with low priority.
   * 2. All other events are dispatched with normal priority.
   *
   * This makes sure that the actual painting (output) is performed _after_ all
   * available input has been processed and that the paint regions are
   * coalesced as much as possible.
   */
  private class Queue
  {
    /**
     * The first item in the queue. This is where events are popped from.
     */
    AWTEvent queueHead;

    /**
     * The last item. This is where events are posted to.
     */
    AWTEvent queueTail;
  }

  /**
   * The three internal event queues.
   *
   * @see Queue
   */
  private Queue[] queues;

  private EventQueue next;
  private EventQueue prev;
  private AWTEvent currentEvent;
  private long lastWhen = System.currentTimeMillis();

  private EventDispatchThread dispatchThread = new EventDispatchThread(this);
  private boolean nativeLoopRunning = false;

  private boolean isShutdown ()
  {
    // This is the exact self-shutdown condition specified in J2SE:
    // http://java.sun.com/j2se/1.4.2/docs/api/java/awt/doc-files/AWTThreadIssues.html

    if (nativeLoopRunning)
      return false;

    if (peekEvent() != null)
      return false;

    if (Frame.hasDisplayableFrames())
      return false;

    return true;
  }

  /**
   * Initializes a new instance of <code>EventQueue</code>.
   */
  public EventQueue()
  {
    queues = new Queue[2];
    queues[NORM_PRIORITY] = new Queue();
    queues[LOW_PRIORITY] = new Queue();
  }

  /**
   * Returns the next event in the queue.  This method will block until
   * an event is available or until the thread is interrupted.
   *
   * @return The next event in the queue.
   *
   * @exception InterruptedException If this thread is interrupted while
   * waiting for an event to be posted to the queue.
   */
  public synchronized AWTEvent getNextEvent()
    throws InterruptedException
  {
    if (next != null)
      return next.getNextEvent();

    AWTEvent res = getNextEventImpl(true);

    while (res == null)
      {
        if (isShutdown())
          {
            // Explicitly set dispathThread to null.  If we don't do
            // this, there is a race condition where dispatchThread
            // can be != null even after the event dispatch thread has
            // stopped running.  If that happens, then the
            // dispatchThread == null check in postEventImpl will
            // fail, and a new event dispatch thread will not be
            // created, leaving invokeAndWaits waiting indefinitely.
            dispatchThread = null;

            // Interrupt the event dispatch thread.
            throw new InterruptedException();
          }

        wait();
        res = getNextEventImpl(true);
      }

    return res;
  }

  /**
   * Fetches and possibly removes the next event from the internal queues.
   * This method returns immediately. When all queues are empty, this returns
   * <code>null</code>:
   *
   * @param remove <true> when the event should be removed from the queue,
   *        <code>false</code> otherwise
   *
   * @return the next event or <code>null</code> when all internal queues
   *         are empty
   */
  private AWTEvent getNextEventImpl(boolean remove)
  {
    AWTEvent next = null;
    for (int i = 0; i < queues.length && next == null; i++)
      {
        Queue q = queues[i];
        if (q.queueHead != null)
          {
            // Got an event, remove it.
            next = q.queueHead;
            if (remove)
              {
                // Unlink event from the queue.
                q.queueHead = next.queueNext;
                if (q.queueHead == null)
                  q.queueTail = null;
                next.queueNext = null;
              }
          }
      }
    return next;
  }

  /**
   * Returns the next event in the queue without removing it from the queue.
   * This method will block until an event is available or until the thread
   * is interrupted.
   *
   * @return The next event in the queue.
   * @specnote Does not block. Returns null if there are no events on the
   *            queue.
   */
  public synchronized AWTEvent peekEvent()
  {
    if (next != null)
      return next.peekEvent();

    return getNextEventImpl(false);
  }

  /**
   * Returns the next event in the queue that has the specified id
   * without removing it from the queue.
   * This method will block until an event is available or until the thread
   * is interrupted.
   *
   * @param id The event id to return.
   *
   * @return The next event in the queue.
   *
   * @specnote Does not block. Returns null if there are no matching events
   *            on the queue.
   */
  public synchronized AWTEvent peekEvent(int id)
  {
    if (next != null)
      return next.peekEvent(id);

    AWTEvent evt = null;
    for (int i = 0; i < queues.length && evt == null; i++)
      {
        Queue q = queues[i];
        evt = q.queueHead;
        while (evt != null && evt.id != id)
          evt = evt.queueNext;
        // At this point we either have found an event (evt != null -> exit
        // for loop), or we have found no event (evt == null -> search next
        // internal queue).
      }
    return evt;
  }

  /**
   * Posts a new event to the queue.
   *
   * @param evt The event to post to the queue.
   *
   * @exception NullPointerException If event is null.
   */
  public void postEvent(AWTEvent evt)
  {
    postEventImpl(evt);
  }

  /**
   * Sorts events to their priority and calls
   * {@link #postEventImpl(AWTEvent, int)}.
   *
   * @param evt the event to post
   */
  private synchronized final void postEventImpl(AWTEvent evt)
  {
    int priority = NORM_PRIORITY;
    if (evt instanceof PaintEvent || evt instanceof LowPriorityEvent)
      priority = LOW_PRIORITY;
    // TODO: Maybe let Swing RepaintManager events also be processed with
    // low priority.
    if (evt instanceof NativeEventLoopRunningEvent)
      {
        nativeLoopRunning = ((NativeEventLoopRunningEvent) evt).isRunning();
        notify();
        return;
      }
    postEventImpl(evt, priority);
  }

  /**
   * Actually performs the event posting. This is needed because the
   * RI doesn't use the public postEvent() method when transferring events
   * between event queues in push() and pop().
   *
   * @param evt the event to post
   * @param priority the priority of the event
   */
  private final void postEventImpl(AWTEvent evt, int priority)
  {
    if (evt == null)
      throw new NullPointerException();

    if (next != null)
      {
        next.postEvent(evt);
        return;
      }

    Object source = evt.getSource();

    Queue q = queues[priority];
    if (source instanceof Component)
      {
        // For PaintEvents, ask the ComponentPeer to coalesce the event
        // when the component is heavyweight.
        Component comp = (Component) source;
        ComponentPeer peer = comp.peer;
        if (peer != null && evt instanceof PaintEvent
            && ! (peer instanceof LightweightPeer))
          peer.coalescePaintEvent((PaintEvent) evt);

        // Check for any events already on the queue with the same source
        // and ID.
        AWTEvent previous = null;
        for (AWTEvent qevt = q.queueHead; qevt != null; qevt = qevt.queueNext)
          {
            Object src = qevt.getSource();
            if (qevt.id == evt.id && src == comp)
              {
                // If there are, call coalesceEvents on the source component
                // to see if they can be combined.
                Component srccmp = (Component) src;
                AWTEvent coalescedEvt = srccmp.coalesceEvents(qevt, evt);
                if (coalescedEvt != null)
                  {
                    // Yes. Replace the existing event with the combined event.
                    if (qevt != coalescedEvt)
                      {
                        if (previous != null)
                          {
                            assert previous.queueNext == qevt;
                            previous.queueNext = coalescedEvt;
                          }
                        else
                          {
                            assert q.queueHead == qevt;
                            q.queueHead = coalescedEvt;
                          }
                        coalescedEvt.queueNext = qevt.queueNext;
                        if (q.queueTail == qevt)
                          q.queueTail = coalescedEvt;
                        qevt.queueNext = null;
                      }
                    return;
                  }
              }
            previous = qevt;
          }
      }

    if (q.queueHead == null)
      {
        // We have an empty queue. Set this event both as head and as tail.
        q.queueHead = evt;
        q.queueTail = evt;
      }
    else
      {
        // Note: queueTail should not be null here.
        q.queueTail.queueNext = evt;
        q.queueTail = evt;
      }

    if (dispatchThread == null || !dispatchThread.isAlive())
      {
        dispatchThread = new EventDispatchThread(this);
        dispatchThread.start();
      }

    notify();
  }

  /**
   * Causes runnable to have its run method called in the dispatch thread of the
   * 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 event dispatcher thread.
   *
   * @exception InterruptedException If another thread has interrupted
   * this thread.
   * @exception InvocationTargetException If an exception is thrown when running
   * runnable.
   *
   * @since 1.2
   */
  public static void invokeAndWait(Runnable runnable)
    throws InterruptedException, InvocationTargetException
  {
    if (isDispatchThread ())
      throw new Error("Can't call invokeAndWait from event dispatch thread");

    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
    Object notifyObject = new Object();

    InvocationEvent ie =
      new InvocationEvent(eq, runnable, notifyObject, true);

    synchronized (notifyObject)
      {
        eq.postEvent(ie);
        notifyObject.wait();
      }

    Exception exception;

    if ((exception = ie.getException()) != null)
      throw new InvocationTargetException(exception);
  }

  /**
   * This arranges for runnable to have its run method called in the
   * dispatch thread of the EventQueue.  This will happen after all
   * pending events are processed.
   *
   * @since 1.2
   */
  public static void invokeLater(Runnable runnable)
  {
    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();

    InvocationEvent ie =
      new InvocationEvent(eq, runnable, null, false);

    eq.postEvent(ie);
  }

  /**
   * Return true if the current thread is the current AWT event dispatch
   * thread.
   */
  public static boolean isDispatchThread()
  {
    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();

    /* Find last EventQueue in chain */
    while (eq.next != null)
      eq = eq.next;

    return (Thread.currentThread() == eq.dispatchThread);
  }

  /**
   * Return the event currently being dispatched by the event
   * dispatch thread.  If the current thread is not the event
   * dispatch thread, this method returns null.
   *
   * @since 1.4
   */
  public static AWTEvent getCurrentEvent()
  {
    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
    Thread ct = Thread.currentThread();

    /* Find out if this thread is the dispatch thread for any of the
       EventQueues in the chain */
    while (ct != eq.dispatchThread)
      {
        // Try next EventQueue, if any
        if (eq.next == null)
           return null;  // Not an event dispatch thread
        eq = eq.next;
      }

    return eq.currentEvent;
  }

  /**
   * Allows a custom EventQueue implementation to replace this one.
   * All pending events are transferred to the new queue. Calls to postEvent,
   * getNextEvent, and peekEvent and others are forwarded to the pushed queue
   * until it is removed with a pop().
   *
   * @exception NullPointerException if newEventQueue is null.
   */
  public synchronized void push(EventQueue newEventQueue)
  {
    if (newEventQueue == null)
      throw new NullPointerException ();

    /* Make sure we are at the top of the stack because callers can
       only get a reference to the one at the bottom using
       Toolkit.getDefaultToolkit().getSystemEventQueue() */
    if (next != null)
      {
        next.push (newEventQueue);
        return;
      }

    /* Make sure we have a live dispatch thread to drive the queue */
    if (dispatchThread == null)
      dispatchThread = new EventDispatchThread(this);

    synchronized (newEventQueue)
      {
        // The RI transfers the events without calling the new eventqueue's
        // push(), but using getNextEvent().
        while (peekEvent() != null)
          {
            try
              {
                newEventQueue.postEventImpl(getNextEvent());
              }
            catch (InterruptedException ex)
              {
                // What should we do with this?
                ex.printStackTrace();
              }
          }
        newEventQueue.prev = this;
      }

    next = newEventQueue;
  }

  /** Transfer any pending events from this queue back to the parent queue that
    * was previously push()ed. Event dispatch from this queue is suspended.
    *
    * @exception EmptyStackException If no previous push was made on this
    * EventQueue.
    */
  protected void pop() throws EmptyStackException
  {
    /* The order is important here, we must get the prev lock first,
       or deadlock could occur as callers usually get here following
       prev's next pointer, and thus obtain prev's lock before trying
       to get this lock. */
    EventQueue previous = prev;
    if (previous == null)
      throw new EmptyStackException();
    synchronized (previous)
      {
        synchronized (this)
          {
            EventQueue nextQueue = next;
            if (nextQueue != null)
              {
                nextQueue.pop();
              }
            else
              {
                previous.next = null;

                // The RI transfers the events without calling the new eventqueue's
                // push(), so this should be OK and most effective.
                while (peekEvent() != null)
                  {
                    try
                      {
                        previous.postEventImpl(getNextEvent());
                      }
                    catch (InterruptedException ex)
                      {
                        // What should we do with this?
                        ex.printStackTrace();
                      }
                  }
                prev = null;
                // Tell our EventDispatchThread that it can end
                // execution.
                if (dispatchThread != null)
                  {
                    dispatchThread.interrupt();
                    dispatchThread = null;
                  }
              }
          }
      }
  }

  /**
   * Dispatches an event. The manner in which the event is dispatched depends
   * upon the type of the event and the type of the event's source object.
   *
   * @exception NullPointerException If event is null.
   */
  protected void dispatchEvent(AWTEvent evt)
  {
    currentEvent = evt;

    if (evt instanceof InputEvent)
      lastWhen = ((InputEvent) evt).getWhen();
    else if (evt instanceof ActionEvent)
      lastWhen = ((ActionEvent) evt).getWhen();
    else if (evt instanceof InvocationEvent)
      lastWhen = ((InvocationEvent) evt).getWhen();

    if (evt instanceof ActiveEvent)
      {
        ActiveEvent active_evt = (ActiveEvent) evt;
        active_evt.dispatch();
      }
    else
      {
        Object source = evt.getSource();

        if (source instanceof Component)
          {
            Component srccmp = (Component) source;
            srccmp.dispatchEvent(evt);
          }
        else if (source instanceof MenuComponent)
          {
            MenuComponent srccmp = (MenuComponent) source;
            srccmp.dispatchEvent(evt);
          }
      }
  }

  /**
   * Returns the timestamp of the most recent event that had a timestamp, or
   * the initialization time of the event queue if no events have been fired.
   * At present, only <code>InputEvent</code>s, <code>ActionEvent</code>s,
   * <code>InputMethodEvent</code>s, and <code>InvocationEvent</code>s have
   * timestamps, but this may be added to other events in future versions.
   * If this is called by the event dispatching thread, it can be any
   * (sequential) value, but to other threads, the safest bet is to return
   * System.currentTimeMillis().
   *
   * @return the most recent timestamp
   * @see InputEvent#getWhen()
   * @see ActionEvent#getWhen()
   * @see InvocationEvent#getWhen()
   * @see InputMethodEvent#getWhen()
   * @since 1.4
   */
  public static long getMostRecentEventTime()
  {
    EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
    if (Thread.currentThread() != eq.dispatchThread)
      return System.currentTimeMillis();
    return eq.lastWhen;
  }
}