188     void pumpEventsForHierarchy(int id, Conditional cond, Component modalComponent)
 189     {
 190         pumpEventsForFilter(id, cond, new HierarchyEventFilter(modalComponent));
 191     }
 192 
 193     void pumpEventsForFilter(Conditional cond, EventFilter filter) {
 194         pumpEventsForFilter(ANY_EVENT, cond, filter);
 195     }
 196 
 197     void pumpEventsForFilter(int id, Conditional cond, EventFilter filter) {
 198         addEventFilter(filter);
 199         while (doDispatch && cond.evaluate()) {
 200             if (isInterrupted() || !pumpOneEventForFilters(id)) {
 201                 doDispatch = false;
 202             }
 203         }
 204         removeEventFilter(filter);
 205     }
 206 
 207     void addEventFilter(EventFilter filter) {



 208         synchronized (eventFilters) {
 209             if (!eventFilters.contains(filter)) {
 210                 if (filter instanceof ModalEventFilter) {
 211                     ModalEventFilter newFilter = (ModalEventFilter)filter;
 212                     int k = 0;
 213                     for (k = 0; k < eventFilters.size(); k++) {
 214                         EventFilter f = eventFilters.get(k);
 215                         if (f instanceof ModalEventFilter) {
 216                             ModalEventFilter cf = (ModalEventFilter)f;
 217                             if (cf.compareTo(newFilter) > 0) {
 218                                 break;
 219                             }
 220                         }
 221                     }
 222                     eventFilters.add(k, filter);
 223                     modalFiltersCount++;
 224                 } else {
 225                     eventFilters.add(filter);
 226                 }
 227             }
 228         }
 229     }
 230 
 231     void removeEventFilter(EventFilter filter) {



 232         synchronized (eventFilters) {
 233             if (eventFilters.contains(filter)) {
 234                 if (filter instanceof ModalEventFilter) {
 235                     modalFiltersCount--;
 236                 }
 237                 eventFilters.remove(filter);
 238             }
 239         }
 240     }
 241 
 242     boolean pumpOneEventForFilters(int id) {
 243         try {
 244             AWTEvent event;
 245             boolean eventOK;
 246             do {
 247                 event = (id == ANY_EVENT)
 248                     ? theQueue.getNextEvent()
 249                     : theQueue.getNextEvent(id);
 250 
 251                 eventOK = true;

 188     void pumpEventsForHierarchy(int id, Conditional cond, Component modalComponent)
 189     {
 190         pumpEventsForFilter(id, cond, new HierarchyEventFilter(modalComponent));
 191     }
 192 
 193     void pumpEventsForFilter(Conditional cond, EventFilter filter) {
 194         pumpEventsForFilter(ANY_EVENT, cond, filter);
 195     }
 196 
 197     void pumpEventsForFilter(int id, Conditional cond, EventFilter filter) {
 198         addEventFilter(filter);
 199         while (doDispatch && cond.evaluate()) {
 200             if (isInterrupted() || !pumpOneEventForFilters(id)) {
 201                 doDispatch = false;
 202             }
 203         }
 204         removeEventFilter(filter);
 205     }
 206 
 207     void addEventFilter(EventFilter filter) {
 208         if (eventLog.isLoggable(Level.FINEST)) {
 209             eventLog.finest("adding the event filter: " + filter);
 210         }
 211         synchronized (eventFilters) {
 212             if (!eventFilters.contains(filter)) {
 213                 if (filter instanceof ModalEventFilter) {
 214                     ModalEventFilter newFilter = (ModalEventFilter)filter;
 215                     int k = 0;
 216                     for (k = 0; k < eventFilters.size(); k++) {
 217                         EventFilter f = eventFilters.get(k);
 218                         if (f instanceof ModalEventFilter) {
 219                             ModalEventFilter cf = (ModalEventFilter)f;
 220                             if (cf.compareTo(newFilter) > 0) {
 221                                 break;
 222                             }
 223                         }
 224                     }
 225                     eventFilters.add(k, filter);
 226                     modalFiltersCount++;
 227                 } else {
 228                     eventFilters.add(filter);
 229                 }
 230             }
 231         }
 232     }
 233 
 234     void removeEventFilter(EventFilter filter) {
 235         if (eventLog.isLoggable(Level.FINEST)) {
 236             eventLog.finest("removing the event filter: " + filter);
 237         }
 238         synchronized (eventFilters) {
 239             if (eventFilters.contains(filter)) {
 240                 if (filter instanceof ModalEventFilter) {
 241                     modalFiltersCount--;
 242                 }
 243                 eventFilters.remove(filter);
 244             }
 245         }
 246     }
 247 
 248     boolean pumpOneEventForFilters(int id) {
 249         try {
 250             AWTEvent event;
 251             boolean eventOK;
 252             do {
 253                 event = (id == ANY_EVENT)
 254                     ? theQueue.getNextEvent()
 255                     : theQueue.getNextEvent(id);
 256 
 257                 eventOK = true;