EventDispatchThread(ThreadGroup group,
    String name,
    EventQueue queue) 
{
        super(group, name);
        setEventQueue(queue);
}

  void addEventFilter(EventFilter filter) 
{
        eventLog.finest("adding the event filter: " + 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);
                } else {
                    eventFilters.add(filter);
                }
            }
        }
}

 public synchronized EventQueue getEventQueue() 
{
        return theQueue;
}

  void pumpEvents(Conditional cond) 
{
        pumpEvents(ANY_EVENT, cond);
}

  void pumpEvents(int id,
    Conditional cond) 
{
        pumpEventsForHierarchy(id, cond, null);
}

  void pumpEventsForFilter(Conditional cond,
    EventFilter filter) 
{
        pumpEventsForFilter(ANY_EVENT, cond, filter);
}

  void pumpEventsForFilter(int id,
    Conditional cond,
    EventFilter filter) 
{
        addEventFilter(filter);
        doDispatch = true;
        while (doDispatch && cond.evaluate()) {
            if (isInterrupted() || !pumpOneEventForFilters(id)) {
                doDispatch = false;
            }
        }
        removeEventFilter(filter);
}

  void pumpEventsForHierarchy(Conditional cond,
    Component modalComponent) 
{
        pumpEventsForHierarchy(ANY_EVENT, cond, modalComponent);
}

  void pumpEventsForHierarchy(int id,
    Conditional cond,
    Component modalComponent) 
{
        pumpEventsForFilter(id, cond, new HierarchyEventFilter(modalComponent));
}

 boolean pumpOneEventForFilters(int id) 
{
        AWTEvent event = null;
        boolean eventOK = false;
        try {
            EventQueue eq = null;
            EventQueueDelegate.Delegate delegate = null;
            do {
                // EventQueue may change during the dispatching
                eq = getEventQueue();
                delegate = EventQueueDelegate.getDelegate();
                if (delegate != null && id == ANY_EVENT) {
                    event = delegate.getNextEvent(eq);
                } else {
                    event = (id == ANY_EVENT) ? eq.getNextEvent() : eq.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 (eventLog.isLoggable(PlatformLogger.FINEST)) {
                eventLog.finest("Dispatching: " + event);
            }
            Object handle = null;
            if (delegate != null) {
                handle = delegate.beforeDispatch(event);
            }
            eq.dispatchEvent(event);
            if (delegate != null) {
                delegate.afterDispatch(event, handle);
            }
            return true;
        }
        catch (ThreadDeath death) {
            threadDeathCaught = true;
            return false;
        }
        catch (InterruptedException interruptedException) {
            return false; // AppContext.dispose() interrupts all
                          // Threads in the AppContext
        }
        catch (Throwable e) {
            processException(e);
        }
        return true;
}

  void removeEventFilter(EventFilter filter) 
{
        eventLog.finest("removing the event filter: " + filter);
        synchronized (eventFilters) {
            eventFilters.remove(filter);
        }
}

 public  void run() 
{
        while (true) {
            try {
                pumpEvents(new Conditional() {
                    public boolean evaluate() {
                        return true;
                    }
                });
            } finally {
                EventQueue eq = getEventQueue();
                if (eq.detachDispatchThread(this) || threadDeathCaught) {
                    break;
                }
            }
        }
}

 public synchronized  void setEventQueue(EventQueue eq) 
{
        theQueue = eq;
}

 public  void stopDispatching() 
{
        doDispatch = false;
}