/// <summary>
/// true only if event exists and nested source appContext is disposed.
/// </summary>
private static bool IsOwnerAppContextDisposed(SequencedEvent se)
{
if (se != null)
{
Object target = se.Nested.Source;
if (target is Component)
{
return(((Component)target).AppContext.Disposed);
}
}
return(false);
}
/// <summary>
/// Disposes of this instance. This method is invoked once the nested event
/// has been dispatched and handled, or when the peer of the target of the
/// nested event has been disposed with a call to Component.removeNotify.
///
/// NOTE: Locking protocol. Since SunToolkit.postEvent can get EventQueue lock,
/// it shall never be called while holding the lock on the list,
/// as EventQueue lock is held during dispatching and dispatch() will get
/// lock on the list. The locks should be acquired in the same order.
/// </summary>
internal void Dispose()
{
lock (typeof(SequencedEvent))
{
if (Disposed)
{
return;
}
if (KeyboardFocusManager.CurrentKeyboardFocusManager.CurrentSequencedEvent == this)
{
KeyboardFocusManager.CurrentKeyboardFocusManager.CurrentSequencedEvent = null;
}
Disposed = true;
}
// Wake myself up
if (AppContext != null)
{
SunToolkit.postEvent(AppContext, new SentEvent());
}
SequencedEvent next = null;
lock (typeof(SequencedEvent))
{
Monitor.PulseAll(typeof(SequencedEvent));
if (List.First == this)
{
List.RemoveFirst();
if (!List.Empty)
{
next = (SequencedEvent)List.First;
}
}
else
{
List.Remove(this);
}
}
// Wake up waiting threads
if (next != null && next.AppContext != null)
{
SunToolkit.postEvent(next.AppContext, new SentEvent());
}
}
/// <summary>
/// {@inheritDoc}
/// </summary>
public virtual bool Enter()
{
if (Log.isLoggable(PlatformLogger.Level.FINE))
{
Log.fine("enter(): blockingEDT=" + KeepBlockingEDT.Get() + ", blockingCT=" + KeepBlockingCT.Get());
}
if (!KeepBlockingEDT.CompareAndSet(false, true))
{
Log.fine("The secondary loop is already running, aborting");
return(false);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final Runnable run = new Runnable()
Runnable run = new RunnableAnonymousInnerClassHelper(this);
// We have two mechanisms for blocking: if we're on the
// dispatch thread, start a new event pump; if we're
// on any other thread, call wait() on the treelock
Thread currentThread = Thread.CurrentThread;
if (currentThread == DispatchThread)
{
if (Log.isLoggable(PlatformLogger.Level.FINEST))
{
Log.finest("On dispatch thread: " + DispatchThread);
}
if (Interval != 0)
{
if (Log.isLoggable(PlatformLogger.Level.FINEST))
{
Log.finest("scheduling the timer for " + Interval + " ms");
}
Timer.Schedule(TimerTask = new TimerTaskAnonymousInnerClassHelper(this), Interval);
}
// Dispose SequencedEvent we are dispatching on the the current
// AppContext, to prevent us from hang - see 4531693 for details
SequencedEvent currentSE = KeyboardFocusManager.CurrentKeyboardFocusManager.CurrentSequencedEvent;
if (currentSE != null)
{
if (Log.isLoggable(PlatformLogger.Level.FINE))
{
Log.fine("Dispose current SequencedEvent: " + currentSE);
}
currentSE.Dispose();
}
// In case the exit() method is called before starting
// new event pump it will post the waking event to EDT.
// The event will be handled after the the new event pump
// starts. Thus, the enter() method will not hang.
//
// Event pump should be privileged. See 6300270.
AccessController.doPrivileged(new PrivilegedActionAnonymousInnerClassHelper(this, run));
}
else
{
if (Log.isLoggable(PlatformLogger.Level.FINEST))
{
Log.finest("On non-dispatch thread: " + currentThread);
}
lock (TreeLock)
{
if (Filter != null)
{
DispatchThread.AddEventFilter(Filter);
}
try
{
EventQueue eq = DispatchThread.EventQueue;
eq.PostEvent(new PeerEvent(this, run, PeerEvent.PRIORITY_EVENT));
KeepBlockingCT.Set(true);
if (Interval > 0)
{
long currTime = DateTimeHelperClass.CurrentUnixTimeMillis();
while (KeepBlockingCT.Get() && ((ExtCondition != null) ? ExtCondition.Evaluate() : true) && (currTime + Interval > DateTimeHelperClass.CurrentUnixTimeMillis()))
{
Monitor.Wait(TreeLock, TimeSpan.FromMilliseconds(Interval));
}
}
else
{
while (KeepBlockingCT.Get() && ((ExtCondition != null) ? ExtCondition.Evaluate() : true))
{
TreeLock.Wait();
}
}
if (Log.isLoggable(PlatformLogger.Level.FINE))
{
Log.fine("waitDone " + KeepBlockingEDT.Get() + " " + KeepBlockingCT.Get());
}
}
catch (InterruptedException e)
{
if (Log.isLoggable(PlatformLogger.Level.FINE))
{
Log.fine("Exception caught while waiting: " + e);
}
}
finally
{
if (Filter != null)
{
DispatchThread.RemoveEventFilter(Filter);
}
}
// If the waiting process has been stopped because of the
// time interval passed or an exception occurred, the state
// should be changed
KeepBlockingEDT.Set(false);
KeepBlockingCT.Set(false);
}
}
return(true);
}
public ConditionalAnonymousInnerClassHelper(SequencedEvent outerInstance)
{
this.OuterInstance = outerInstance;
}
