| Methods Summary |
|---|
| void | addEventFilter(java.awt.EventFilter filter)
synchronized (eventFilters) {
if (!eventFilters.contains(filter)) {
if (filter instanceof ModalEventFilter) {
ModalEventFilter newFilter = (ModalEventFilter)filter;
int k = 0;
for (k = 0; k < eventFilters.size(); k++) {
EventFilter f = eventFilters.get(k);
if (f instanceof ModalEventFilter) {
ModalEventFilter cf = (ModalEventFilter)f;
if (cf.compareTo(newFilter) > 0) {
break;
}
}
}
eventFilters.add(k, filter);
modalFiltersCount++;
} else {
eventFilters.add(filter);
}
}
}
|
| static boolean | checkMouseEventForModalJInternalFrame(java.awt.event.MouseEvent me, java.awt.Component modalComp)
// Check if the MouseEvent is targeted to the HW parent of the
// LW component, if so, then return true. The job of distinguishing
// between the LW components is done by the LW dispatcher.
if (Component.isInstanceOf(modalComp, "javax.swing.JInternalFrame")) {
Container c;
synchronized (modalComp.getTreeLock()) {
c = ((Container)modalComp).getHeavyweightContainer();
}
if (me.getSource() == c)
return true;
}
return false;
|
| java.awt.EventQueue | getEventQueue() return theQueue;
|
| private boolean | handleException(java.lang.Throwable thrown)Handles an exception thrown in the event-dispatch thread.
If the system property "sun.awt.exception.handler" is defined, then
when this method is invoked it will attempt to do the following:
- Load the class named by the value of that property, using the
current thread's context class loader,
- Instantiate that class using its zero-argument constructor,
- Find the resulting handler object's public void handle
method, which should take a single argument of type
Throwable, and
- Invoke the handler's handle method, passing it the
thrown argument that was passed to this method.
If any of the first three steps fail then this method will return
false and all following invocations of this method will return
false immediately. An exception thrown by the handler object's
handle will be caught, and will cause this method to return
false. If the handler's handle method is successfully
invoked, then this method will return true. This method will
never throw any sort of exception.
Note: This method is a temporary hack to work around the
absence of a real API that provides the ability to replace the
event-dispatch thread. The magic "sun.awt.exception.handler" property
will be removed in a future release.
try {
if (handlerClassName == NO_HANDLER) {
return false; /* Already tried, and failed */
}
/* Look up the class name */
if (handlerClassName == null) {
handlerClassName = ((String) AccessController.doPrivileged(
new GetPropertyAction(handlerPropName)));
if (handlerClassName == null) {
handlerClassName = NO_HANDLER; /* Do not try this again */
return false;
}
}
/* Load the class, instantiate it, and find its handle method */
Method m;
Object h;
try {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
Class c = Class.forName(handlerClassName, true, cl);
m = c.getMethod("handle", new Class[] { Throwable.class });
h = c.newInstance();
} catch (Throwable x) {
handlerClassName = NO_HANDLER; /* Do not try this again */
return false;
}
/* Finally, invoke the handler */
m.invoke(h, new Object[] { thrown });
} catch (Throwable x) {
return false;
}
return true;
|
| boolean | isDispatching(java.awt.EventQueue eq)
return theQueue.equals(eq);
|
| private void | processException(java.lang.Throwable e, boolean isModal)
if (!handleException(e)) {
// See bug ID 4499199.
// If we are in a modal dialog, we cannot throw
// an exception for the ThreadGroup to handle (as added
// in RFE 4063022). If we did, the message pump of
// the modal dialog would be interrupted.
// We instead choose to handle the exception ourselves.
// It may be useful to add either a runtime flag or API
// later if someone would like to instead dispose the
// dialog and allow the thread group to handle it.
if (isModal) {
System.err.println(
"Exception occurred during event dispatching:");
e.printStackTrace();
} else if (e instanceof RuntimeException) {
throw (RuntimeException)e;
} else if (e instanceof Error) {
throw (Error)e;
}
}
|
| void | pumpEvents(java.awt.Conditional cond)
pumpEvents(ANY_EVENT, cond);
|
| void | pumpEvents(int id, java.awt.Conditional cond)
pumpEventsForHierarchy(id, cond, null);
|
| void | pumpEventsForFilter(java.awt.Conditional cond, java.awt.EventFilter filter)
pumpEventsForFilter(ANY_EVENT, cond, filter);
|
| void | pumpEventsForFilter(int id, java.awt.Conditional cond, java.awt.EventFilter filter)
addEventFilter(filter);
while (doDispatch && cond.evaluate()) {
if (isInterrupted() || !pumpOneEventForFilters(id)) {
doDispatch = false;
}
}
removeEventFilter(filter);
|
| void | pumpEventsForHierarchy(java.awt.Conditional cond, java.awt.Component modalComponent)
pumpEventsForHierarchy(ANY_EVENT, cond, modalComponent);
|
| void | pumpEventsForHierarchy(int id, java.awt.Conditional cond, java.awt.Component modalComponent)
pumpEventsForFilter(id, cond, new HierarchyEventFilter(modalComponent));
|
| boolean | pumpOneEventForFilters(int id)
try {
AWTEvent event;
boolean eventOK;
do {
event = (id == ANY_EVENT)
? theQueue.getNextEvent()
: theQueue.getNextEvent(id);
eventOK = true;
synchronized (eventFilters) {
for (int i = eventFilters.size() - 1; i >= 0; i--) {
EventFilter f = eventFilters.get(i);
EventFilter.FilterAction accept = f.acceptEvent(event);
if (accept == EventFilter.FilterAction.REJECT) {
eventOK = false;
break;
} else if (accept == EventFilter.FilterAction.ACCEPT_IMMEDIATELY) {
break;
}
}
}
eventOK = eventOK && SunDragSourceContextPeer.checkEvent(event);
if (!eventOK) {
event.consume();
}
}
while (eventOK == false);
if (dbg.on) {
dbg.println("Dispatching: "+event);
}
theQueue.dispatchEvent(event);
return true;
}
catch (ThreadDeath death) {
return false;
}
catch (InterruptedException interruptedException) {
return false; // AppContext.dispose() interrupts all
// Threads in the AppContext
}
// Can get and throw only unchecked exceptions
catch (RuntimeException e) {
processException(e, modalFiltersCount > 0);
} catch (Error e) {
processException(e, modalFiltersCount > 0);
}
return true;
|
| void | removeEventFilter(java.awt.EventFilter filter)
synchronized (eventFilters) {
if (eventFilters.contains(filter)) {
if (filter instanceof ModalEventFilter) {
modalFiltersCount--;
}
eventFilters.remove(filter);
}
}
|
| public void | run()
try {
pumpEvents(new Conditional() {
public boolean evaluate() {
return true;
}
});
} finally {
/*
* This synchronized block is to secure that the event dispatch
* thread won't die in the middle of posting a new event to the
* associated event queue. It is important because we notify
* that the event dispatch thread is busy after posting a new event
* to its queue, so the EventQueue.dispatchThread reference must
* be valid at that point.
*/
synchronized (theQueue) {
if (theQueue.getDispatchThread() == this) {
theQueue.detachDispatchThread();
}
/*
* Event dispatch thread dies in case of an uncaught exception.
* A new event dispatch thread for this queue will be started
* only if a new event is posted to it. In case if no more
* events are posted after this thread died all events that
* currently are in the queue will never be dispatched.
*/
/*
* Fix for 4648733. Check both the associated java event
* queue and the PostEventQueue.
*/
if (theQueue.peekEvent() != null ||
!SunToolkit.isPostEventQueueEmpty()) {
theQueue.initDispatchThread();
}
AWTAutoShutdown.getInstance().notifyThreadFree(this);
}
}
|
| public void | stopDispatching()
stopDispatchingImpl(true);
|
| void | stopDispatchingImpl(boolean wait)
// Note: We stop dispatching via a flag rather than using
// Thread.interrupt() because we can't guarantee that the wait()
// we interrupt will be EventQueue.getNextEvent()'s. -fredx 8-11-98
StopDispatchEvent stopEvent = new StopDispatchEvent();
// wait for the dispatcher to complete
if (Thread.currentThread() != this) {
// fix 4122683, 4128923
// Post an empty event to ensure getNextEvent is unblocked
//
// We have to use postEventPrivate instead of postEvent because
// EventQueue.pop calls EventDispatchThread.stopDispatching.
// Calling SunToolkit.flushPendingEvents in this case could
// lead to deadlock.
theQueue.postEventPrivate(stopEvent);
if (wait) {
try {
join();
} catch(InterruptedException e) {
}
}
} else {
stopEvent.dispatch();
}
synchronized (theQueue) {
if (theQueue.getDispatchThread() == this) {
theQueue.detachDispatchThread();
}
}
|
| public void | stopDispatchingLater()
stopDispatchingImpl(false);
|
