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

  void addEventFilter(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);
                }
            }
        }
}

 EventQueue getEventQueue() 
{
 return theQueue;
}

 boolean isDispatching(EventQueue eq) 
{
        return theQueue.equals(eq);
}

  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);
        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) 
{
        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 (eventLog.isLoggable(Level.FINEST)) {
                eventLog.log(Level.FINEST, "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(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);
}