jdk/src/share/classes/java/awt/EventDispatchThread.java
changeset 1971 553b81ac1756
parent 1961 436a5a828d9f
parent 1293 ef349b440fc9
child 1979 f47a542ee9b7
equal deleted inserted replaced
1970:7718bf3a85ad 1971:553b81ac1756
    37 
    37 
    38 import java.util.Vector;
    38 import java.util.Vector;
    39 import java.util.logging.*;
    39 import java.util.logging.*;
    40 
    40 
    41 import sun.awt.dnd.SunDragSourceContextPeer;
    41 import sun.awt.dnd.SunDragSourceContextPeer;
       
    42 import sun.awt.EventQueueDelegate;
    42 
    43 
    43 /**
    44 /**
    44  * EventDispatchThread is a package-private AWT class which takes
    45  * EventDispatchThread is a package-private AWT class which takes
    45  * events off the EventQueue and dispatches them to the appropriate
    46  * events off the EventQueue and dispatches them to the appropriate
    46  * AWT components.
    47  * AWT components.
   241 
   242 
   242     boolean pumpOneEventForFilters(int id) {
   243     boolean pumpOneEventForFilters(int id) {
   243         try {
   244         try {
   244             AWTEvent event;
   245             AWTEvent event;
   245             boolean eventOK;
   246             boolean eventOK;
       
   247             EventQueueDelegate.Delegate delegate =
       
   248                 EventQueueDelegate.getDelegate();
   246             do {
   249             do {
   247                 event = (id == ANY_EVENT)
   250                 if (delegate != null && id == ANY_EVENT) {
   248                     ? theQueue.getNextEvent()
   251                     event = delegate.getNextEvent(theQueue);
   249                     : theQueue.getNextEvent(id);
   252                 } else {
       
   253                     event = (id == ANY_EVENT)
       
   254                         ? theQueue.getNextEvent()
       
   255                         : theQueue.getNextEvent(id);
       
   256                 }
   250 
   257 
   251                 eventOK = true;
   258                 eventOK = true;
   252                 synchronized (eventFilters) {
   259                 synchronized (eventFilters) {
   253                     for (int i = eventFilters.size() - 1; i >= 0; i--) {
   260                     for (int i = eventFilters.size() - 1; i >= 0; i--) {
   254                         EventFilter f = eventFilters.get(i);
   261                         EventFilter f = eventFilters.get(i);
   270 
   277 
   271             if (eventLog.isLoggable(Level.FINEST)) {
   278             if (eventLog.isLoggable(Level.FINEST)) {
   272                 eventLog.log(Level.FINEST, "Dispatching: " + event);
   279                 eventLog.log(Level.FINEST, "Dispatching: " + event);
   273             }
   280             }
   274 
   281 
       
   282             Object handle = null;
       
   283             if (delegate != null) {
       
   284                 handle = delegate.beforeDispatch(event);
       
   285             }
   275             theQueue.dispatchEvent(event);
   286             theQueue.dispatchEvent(event);
       
   287             if (delegate != null) {
       
   288                 delegate.afterDispatch(event, handle);
       
   289             }
   276             return true;
   290             return true;
   277         }
   291         }
   278         catch (ThreadDeath death) {
   292         catch (ThreadDeath death) {
   279             return false;
   293             return false;
   280 
   294