src/share/classes/java/awt/EventDispatchThread.java

Print this page




 121 
 122     void pumpEventsForHierarchy(int id, Conditional cond, Component modalComponent) {
 123         pumpEventsForFilter(id, cond, new HierarchyEventFilter(modalComponent));
 124     }
 125 
 126     void pumpEventsForFilter(Conditional cond, EventFilter filter) {
 127         pumpEventsForFilter(ANY_EVENT, cond, filter);
 128     }
 129 
 130     void pumpEventsForFilter(int id, Conditional cond, EventFilter filter) {
 131         addEventFilter(filter);
 132         doDispatch = true;
 133         shutdown |= isInterrupted();
 134         while (doDispatch && !shutdown && cond.evaluate()) {
 135             pumpOneEventForFilters(id);
 136         }
 137         removeEventFilter(filter);
 138     }
 139 
 140     void addEventFilter(EventFilter filter) {
 141         if (eventLog.isLoggable(PlatformLogger.FINEST)) {
 142             eventLog.finest("adding the event filter: " + filter);
 143         }
 144         synchronized (eventFilters) {
 145             if (!eventFilters.contains(filter)) {
 146                 if (filter instanceof ModalEventFilter) {
 147                     ModalEventFilter newFilter = (ModalEventFilter)filter;
 148                     int k = 0;
 149                     for (k = 0; k < eventFilters.size(); k++) {
 150                         EventFilter f = eventFilters.get(k);
 151                         if (f instanceof ModalEventFilter) {
 152                             ModalEventFilter cf = (ModalEventFilter)f;
 153                             if (cf.compareTo(newFilter) > 0) {
 154                                 break;
 155                             }
 156                         }
 157                     }
 158                     eventFilters.add(k, filter);
 159                 } else {
 160                     eventFilters.add(filter);
 161                 }
 162             }
 163         }
 164     }
 165 
 166     void removeEventFilter(EventFilter filter) {
 167         if (eventLog.isLoggable(PlatformLogger.FINEST)) {
 168             eventLog.finest("removing the event filter: " + filter);
 169         }
 170         synchronized (eventFilters) {
 171             eventFilters.remove(filter);
 172         }
 173     }
 174 
 175     void pumpOneEventForFilters(int id) {
 176         AWTEvent event = null;
 177         boolean eventOK = false;
 178         try {
 179             EventQueue eq = null;
 180             EventQueueDelegate.Delegate delegate = null;
 181             do {
 182                 // EventQueue may change during the dispatching
 183                 eq = getEventQueue();
 184                 delegate = EventQueueDelegate.getDelegate();
 185 
 186                 if (delegate != null && id == ANY_EVENT) {
 187                     event = delegate.getNextEvent(eq);


 192                 eventOK = true;
 193                 synchronized (eventFilters) {
 194                     for (int i = eventFilters.size() - 1; i >= 0; i--) {
 195                         EventFilter f = eventFilters.get(i);
 196                         EventFilter.FilterAction accept = f.acceptEvent(event);
 197                         if (accept == EventFilter.FilterAction.REJECT) {
 198                             eventOK = false;
 199                             break;
 200                         } else if (accept == EventFilter.FilterAction.ACCEPT_IMMEDIATELY) {
 201                             break;
 202                         }
 203                     }
 204                 }
 205                 eventOK = eventOK && SunDragSourceContextPeer.checkEvent(event);
 206                 if (!eventOK) {
 207                     event.consume();
 208                 }
 209             }
 210             while (eventOK == false);
 211 
 212             if (eventLog.isLoggable(PlatformLogger.FINEST)) {
 213                 eventLog.finest("Dispatching: " + event);
 214             }
 215 
 216             Object handle = null;
 217             if (delegate != null) {
 218                 handle = delegate.beforeDispatch(event);
 219             }
 220             eq.dispatchEvent(event);
 221             if (delegate != null) {
 222                 delegate.afterDispatch(event, handle);
 223             }
 224         }
 225         catch (ThreadDeath death) {
 226             shutdown = true;
 227             throw death;
 228         }
 229         catch (InterruptedException interruptedException) {
 230             shutdown = true; // AppContext.dispose() interrupts all
 231                              // Threads in the AppContext
 232         }
 233         catch (Throwable e) {
 234             processException(e);
 235         }
 236     }
 237 
 238     private void processException(Throwable e) {
 239         if (eventLog.isLoggable(PlatformLogger.FINE)) {
 240             eventLog.fine("Processing exception: " + e);
 241         }
 242         getUncaughtExceptionHandler().uncaughtException(this, e);
 243     }
 244 
 245     public synchronized EventQueue getEventQueue() {
 246         return theQueue;
 247     }
 248     public synchronized void setEventQueue(EventQueue eq) {
 249         theQueue = eq;
 250     }
 251 
 252     private static class HierarchyEventFilter implements EventFilter {
 253         private Component modalComponent;
 254         public HierarchyEventFilter(Component modalComponent) {
 255             this.modalComponent = modalComponent;
 256         }
 257         public FilterAction acceptEvent(AWTEvent event) {
 258             if (modalComponent != null) {
 259                 int eventID = event.getID();




 121 
 122     void pumpEventsForHierarchy(int id, Conditional cond, Component modalComponent) {
 123         pumpEventsForFilter(id, cond, new HierarchyEventFilter(modalComponent));
 124     }
 125 
 126     void pumpEventsForFilter(Conditional cond, EventFilter filter) {
 127         pumpEventsForFilter(ANY_EVENT, cond, filter);
 128     }
 129 
 130     void pumpEventsForFilter(int id, Conditional cond, EventFilter filter) {
 131         addEventFilter(filter);
 132         doDispatch = true;
 133         shutdown |= isInterrupted();
 134         while (doDispatch && !shutdown && cond.evaluate()) {
 135             pumpOneEventForFilters(id);
 136         }
 137         removeEventFilter(filter);
 138     }
 139 
 140     void addEventFilter(EventFilter filter) {
 141         if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {
 142             eventLog.finest("adding the event filter: " + filter);
 143         }
 144         synchronized (eventFilters) {
 145             if (!eventFilters.contains(filter)) {
 146                 if (filter instanceof ModalEventFilter) {
 147                     ModalEventFilter newFilter = (ModalEventFilter)filter;
 148                     int k = 0;
 149                     for (k = 0; k < eventFilters.size(); k++) {
 150                         EventFilter f = eventFilters.get(k);
 151                         if (f instanceof ModalEventFilter) {
 152                             ModalEventFilter cf = (ModalEventFilter)f;
 153                             if (cf.compareTo(newFilter) > 0) {
 154                                 break;
 155                             }
 156                         }
 157                     }
 158                     eventFilters.add(k, filter);
 159                 } else {
 160                     eventFilters.add(filter);
 161                 }
 162             }
 163         }
 164     }
 165 
 166     void removeEventFilter(EventFilter filter) {
 167         if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {
 168             eventLog.finest("removing the event filter: " + filter);
 169         }
 170         synchronized (eventFilters) {
 171             eventFilters.remove(filter);
 172         }
 173     }
 174 
 175     void pumpOneEventForFilters(int id) {
 176         AWTEvent event = null;
 177         boolean eventOK = false;
 178         try {
 179             EventQueue eq = null;
 180             EventQueueDelegate.Delegate delegate = null;
 181             do {
 182                 // EventQueue may change during the dispatching
 183                 eq = getEventQueue();
 184                 delegate = EventQueueDelegate.getDelegate();
 185 
 186                 if (delegate != null && id == ANY_EVENT) {
 187                     event = delegate.getNextEvent(eq);


 192                 eventOK = true;
 193                 synchronized (eventFilters) {
 194                     for (int i = eventFilters.size() - 1; i >= 0; i--) {
 195                         EventFilter f = eventFilters.get(i);
 196                         EventFilter.FilterAction accept = f.acceptEvent(event);
 197                         if (accept == EventFilter.FilterAction.REJECT) {
 198                             eventOK = false;
 199                             break;
 200                         } else if (accept == EventFilter.FilterAction.ACCEPT_IMMEDIATELY) {
 201                             break;
 202                         }
 203                     }
 204                 }
 205                 eventOK = eventOK && SunDragSourceContextPeer.checkEvent(event);
 206                 if (!eventOK) {
 207                     event.consume();
 208                 }
 209             }
 210             while (eventOK == false);
 211 
 212             if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {
 213                 eventLog.finest("Dispatching: " + event);
 214             }
 215 
 216             Object handle = null;
 217             if (delegate != null) {
 218                 handle = delegate.beforeDispatch(event);
 219             }
 220             eq.dispatchEvent(event);
 221             if (delegate != null) {
 222                 delegate.afterDispatch(event, handle);
 223             }
 224         }
 225         catch (ThreadDeath death) {
 226             shutdown = true;
 227             throw death;
 228         }
 229         catch (InterruptedException interruptedException) {
 230             shutdown = true; // AppContext.dispose() interrupts all
 231                              // Threads in the AppContext
 232         }
 233         catch (Throwable e) {
 234             processException(e);
 235         }
 236     }
 237 
 238     private void processException(Throwable e) {
 239         if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {
 240             eventLog.fine("Processing exception: " + e);
 241         }
 242         getUncaughtExceptionHandler().uncaughtException(this, e);
 243     }
 244 
 245     public synchronized EventQueue getEventQueue() {
 246         return theQueue;
 247     }
 248     public synchronized void setEventQueue(EventQueue eq) {
 249         theQueue = eq;
 250     }
 251 
 252     private static class HierarchyEventFilter implements EventFilter {
 253         private Component modalComponent;
 254         public HierarchyEventFilter(Component modalComponent) {
 255             this.modalComponent = modalComponent;
 256         }
 257         public FilterAction acceptEvent(AWTEvent event) {
 258             if (modalComponent != null) {
 259                 int eventID = event.getID();