Also see:

isDispatched

 public InvocationEvent(Object source,
    Runnable runnable) 
{
        this(source, runnable, null, false);
}

Constructs an InvocationEvent with the specified source which will execute the runnable's run method when dispatched.

This is a convenience constructor. An invocation of the form InvocationEvent(source, runnable) behaves in exactly the same way as the invocation of InvocationEvent (source, runnable, null, false).

This method throws an IllegalArgumentException if source is null.

Parameters:

source - The Object that originated the event

runnable - The Runnable whose run method will be executed

Throws:

IllegalArgumentException - if source is null

Also see:

getSource()
InvocationEvent(Object, Runnable, Object, boolean)

 public InvocationEvent(Object source,
    Runnable runnable,
    Object notifier,
    boolean catchThrowables) 
{
        this(source, INVOCATION_DEFAULT, runnable, notifier, catchThrowables);
}

Constructs an InvocationEvent with the specified source which will execute the runnable's run method when dispatched. If notifier is non-null, notifyAll() will be called on it immediately after run has returned or thrown an exception.

An invocation of the form InvocationEvent(source, runnable, notifier, catchThrowables) behaves in exactly the same way as the invocation of InvocationEvent (source, InvocationEvent.INVOCATION_DEFAULT, runnable, notifier, catchThrowables).

This method throws an IllegalArgumentException if source is null.

Parameters:

source - The Object that originated the event

runnable - The Runnable whose run method will be executed

notifier - The {@code Object} whose notifyAll method will be called after Runnable.run has returned or thrown an exception

catchThrowables - Specifies whether dispatch should catch Throwable when executing the Runnable's run method, or should instead propagate those Throwables to the EventDispatchThread's dispatch loop

Throws:

IllegalArgumentException - if source is null

Also see:

getSource()
InvocationEvent(Object, int, Runnable, Object, boolean)

 protected InvocationEvent(Object source,
    int id,
    Runnable runnable,
    Object notifier,
    boolean catchThrowables) 
{
        super(source, id);
        this.runnable = runnable;
        this.notifier = notifier;
        this.catchExceptions = catchThrowables;
        this.when = System.currentTimeMillis();
}

Constructs an InvocationEvent with the specified source and ID which will execute the runnable's run method when dispatched. If notifier is non-null, notifyAll will be called on it immediately after run has returned or thrown an exception.

This method throws an IllegalArgumentException if source is null.

Parameters:

source - The Object that originated the event

id - An integer indicating the type of event. For information on allowable values, see the class description for InvocationEvent

runnable - The Runnable whose run method will be executed

notifier - The Object whose notifyAll method will be called after Runnable.run has returned or thrown an exception

catchThrowables - Specifies whether dispatch should catch Throwable when executing the Runnable's run method, or should instead propagate those Throwables to the EventDispatchThread's dispatch loop

Throws:

IllegalArgumentException - if source is null

Also see:

getSource()
getID()

 public  void dispatch() 
{
        try {
            if (catchExceptions) {
                try {
                    runnable.run();
                }
                catch (Throwable t) {
                    if (t instanceof Exception) {
                        exception = (Exception) t;
                    }
                    throwable = t;
                }
            }
            else {
                runnable.run();
            }
        } finally {
            dispatched = true;
            if (notifier != null) {
                synchronized (notifier) {
                    notifier.notifyAll();
                }
            }
        }
}

Executes the Runnable's run() method and notifies the notifier (if any) when run() has returned or thrown an exception.

 public Exception getException() 
{
        return (catchExceptions) ? exception : null;
}

Returns any Exception caught while executing the Runnable's run() method.

 public Throwable getThrowable() 
{
        return (catchExceptions) ? throwable : null;
}

Returns any Throwable caught while executing the Runnable's run() method.

 public long getWhen() 
{
        return when;
}

Returns the timestamp of when this event occurred.

 public boolean isDispatched() 
{
        return dispatched;
}

Returns {@code true} if the event is dispatched or any exception is thrown while dispatching, {@code false} otherwise. The method should be called by a waiting thread that calls the {@code notifier.wait()} method. Since spurious wakeups are possible (as explained in Object#wait() ), this method should be used in a waiting loop to ensure that the event got dispatched:

    while (!event.isDispatched()) {
        notifier.wait();
    }

If the waiting thread wakes up without dispatching the event, the {@code isDispatched()} method returns {@code false}, and the {@code while} loop executes once more, thus, causing the awakened thread to revert to the waiting mode.

If the {@code notifier.notifyAll()} happens before the waiting thread enters the {@code notifier.wait()} method, the {@code while} loop ensures that the waiting thread will not enter the {@code notifier.wait()} method. Otherwise, there is no guarantee that the waiting thread will ever be woken from the wait.

 public String paramString() 
{
        String typeStr;
        switch(id) {
            case INVOCATION_DEFAULT:
                typeStr = "INVOCATION_DEFAULT";
                break;
            default:
                typeStr = "unknown type";
        }
        return typeStr + ",runnable=" + runnable + ",notifier=" + notifier +
            ",catchExceptions=" + catchExceptions + ",when=" + when;
}

Returns a parameter string identifying this event. This method is useful for event-logging and for debugging.