/// <summary>
/// Creates a {@code WaitDispatchSupport} instance to
/// serve the given event dispatch thread.
/// </summary>
/// <param name="dispatchThread"> An event dispatch thread that
/// should not stop dispatching events while waiting </param>
/// <param name="extCond"> A conditional object used to determine
/// if the loop should be terminated
///
/// @since 1.7 </param>
public WaitDispatchSupport(EventDispatchThread dispatchThread, Conditional extCond)
{
if (dispatchThread == null)
{
throw new IllegalArgumentException("The dispatchThread can not be null");
}
this.DispatchThread = dispatchThread;
this.ExtCondition = extCond;
this.Condition = new ConditionalAnonymousInnerClassHelper(this);
}
/// <summary>
/// Creates a {@code WaitDispatchSupport} instance to
/// serve the given event dispatch thread.
/// <para>
/// The <seealso cref="EventFilter"/> is set on the {@code dispatchThread}
/// while waiting. The filter is removed on completion of the
/// waiting process.
/// </para>
/// <para>
///
///
/// </para>
/// </summary>
/// <param name="dispatchThread"> An event dispatch thread that
/// should not stop dispatching events while waiting </param>
/// <param name="filter"> {@code EventFilter} to be set </param>
/// <param name="interval"> A time interval to wait for. Note that
/// when the waiting process takes place on EDT
/// there is no guarantee to stop it in the given time
///
/// @since 1.7 </param>
public WaitDispatchSupport(EventDispatchThread dispatchThread, Conditional extCondition, EventFilter filter, long interval) : this(dispatchThread, extCondition)
{
this.Filter = filter;
if (interval < 0)
{
throw new IllegalArgumentException("The interval value must be >= 0");
}
this.Interval = interval;
if (interval != 0)
{
InitializeTimer();
}
}
/// <summary>
/// Dispatches the nested event after all previous nested events have been
/// dispatched or disposed. If this method is invoked before all previous nested events
/// have been dispatched, then this method blocks until such a point is
/// reached.
/// While waiting disposes nested events to disposed AppContext
///
/// NOTE: Locking protocol. Since dispose() can get EventQueue lock,
/// dispatch() shall never call dispose() while holding the lock on the list,
/// as EventQueue lock is held during dispatching. The locks should be acquired
/// in the same order.
/// </summary>
public void Dispatch()
{
try
{
AppContext = AppContext.AppContext;
if (First != this)
{
if (EventQueue.DispatchThread)
{
EventDispatchThread edt = (EventDispatchThread)Thread.CurrentThread;
edt.PumpEvents(SentEvent.ID, new ConditionalAnonymousInnerClassHelper(this));
}
else
{
while (!FirstOrDisposed)
{
lock (typeof(SequencedEvent))
{
try
{
Monitor.Wait(typeof(SequencedEvent), TimeSpan.FromMilliseconds(1000));
}
catch (InterruptedException)
{
break;
}
}
}
}
}
if (!Disposed)
{
KeyboardFocusManager.CurrentKeyboardFocusManager.CurrentSequencedEvent = this;
Toolkit.EventQueue.DispatchEvent(Nested);
}
}
finally
{
Dispose();
}
}
/// <summary>
/// Creates a {@code WaitDispatchSupport} instance to
/// serve the given event dispatch thread.
/// </summary>
/// <param name="dispatchThread"> An event dispatch thread that
/// should not stop dispatching events while waiting
///
/// @since 1.7 </param>
public WaitDispatchSupport(EventDispatchThread dispatchThread) : this(dispatchThread, null)
{
}
public ConditionalAnonymousInnerClassHelper(EventDispatchThread outerInstance)
{
this.OuterInstance = outerInstance;
}