1 /*

     2  * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package java.awt;

    27 

    28 import java.awt.event.MouseEvent;

    29 import java.awt.event.ActionEvent;

    30 import java.awt.event.WindowEvent;

    31 

    32 import java.util.ArrayList;

    33 import sun.util.logging.PlatformLogger;

    34 

    35 import sun.awt.dnd.SunDragSourceContextPeer;

    36 

    37 /**

    38  * EventDispatchThread is a package-private AWT class which takes

    39  * events off the EventQueue and dispatches them to the appropriate

    40  * AWT components.

    41  *

    42  * The Thread starts a "permanent" event pump with a call to

    43  * pumpEvents(Conditional) in its run() method. Event handlers can choose to

    44  * block this event pump at any time, but should start a new pump (<b>not</b>

    45  * a new EventDispatchThread) by again calling pumpEvents(Conditional). This

    46  * secondary event pump will exit automatically as soon as the Condtional

    47  * evaluate()s to false and an additional Event is pumped and dispatched.

    48  *

    49  * @author Tom Ball

    50  * @author Amy Fowler

    51  * @author Fred Ecks

    52  * @author David Mendenhall

    53  *

    54  * @since 1.1

    55  */

    56 class EventDispatchThread extends Thread {

    57 

    58     private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.EventDispatchThread");

    59 

    60     private EventQueue theQueue;

    61     private volatile boolean doDispatch = true;

    62 

    63     private static final int ANY_EVENT = -1;

    64 

    65     private ArrayList<EventFilter> eventFilters = new ArrayList<EventFilter>();

    66 

    67     EventDispatchThread(ThreadGroup group, String name, EventQueue queue) {

    68         super(group, name);

    69         setEventQueue(queue);

    70     }

    71 

    72     /*

    73      * Must be called on EDT only, that's why no synchronization

    74      */

    75     public void stopDispatching() {

    76         doDispatch = false;

    77     }

    78 

    79     public void run() {

    80         try {

    81             pumpEvents(new Conditional() {

    82                 public boolean evaluate() {

    83                     return true;

    84                 }

    85             });

    86         } finally {

    87             getEventQueue().detachDispatchThread(this);

    88         }

    89     }

    90 

    91     void pumpEvents(Conditional cond) {

    92         pumpEvents(ANY_EVENT, cond);

    93     }

    94 

    95     void pumpEventsForHierarchy(Conditional cond, Component modalComponent) {

    96         pumpEventsForHierarchy(ANY_EVENT, cond, modalComponent);

    97     }

    98 

    99     void pumpEvents(int id, Conditional cond) {

   100         pumpEventsForHierarchy(id, cond, null);

   101     }

   102 

   103     void pumpEventsForHierarchy(int id, Conditional cond, Component modalComponent) {

   104         pumpEventsForFilter(id, cond, new HierarchyEventFilter(modalComponent));

   105     }

   106 

   107     void pumpEventsForFilter(Conditional cond, EventFilter filter) {

   108         pumpEventsForFilter(ANY_EVENT, cond, filter);

   109     }

   110 

   111     void pumpEventsForFilter(int id, Conditional cond, EventFilter filter) {

   112         addEventFilter(filter);

   113         doDispatch = true;

   114         while (doDispatch && !isInterrupted() && cond.evaluate()) {

   115             pumpOneEventForFilters(id);

   116         }

   117         removeEventFilter(filter);

   118     }

   119 

   120     void addEventFilter(EventFilter filter) {

   121         if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {

   122             eventLog.finest("adding the event filter: " + filter);

   123         }

   124         synchronized (eventFilters) {

   125             if (!eventFilters.contains(filter)) {

   126                 if (filter instanceof ModalEventFilter) {

   127                     ModalEventFilter newFilter = (ModalEventFilter)filter;

   128                     int k = 0;

   129                     for (k = 0; k < eventFilters.size(); k++) {

   130                         EventFilter f = eventFilters.get(k);

   131                         if (f instanceof ModalEventFilter) {

   132                             ModalEventFilter cf = (ModalEventFilter)f;

   133                             if (cf.compareTo(newFilter) > 0) {

   134                                 break;

   135                             }

   136                         }

   137                     }

   138                     eventFilters.add(k, filter);

   139                 } else {

   140                     eventFilters.add(filter);

   141                 }

   142             }

   143         }

   144     }

   145 

   146     void removeEventFilter(EventFilter filter) {

   147         if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {

   148             eventLog.finest("removing the event filter: " + filter);

   149         }

   150         synchronized (eventFilters) {

   151             eventFilters.remove(filter);

   152         }

   153     }

   154 

   155     void pumpOneEventForFilters(int id) {

   156         AWTEvent event = null;

   157         boolean eventOK = false;

   158         try {

   159             EventQueue eq = null;

   160             do {

   161                 // EventQueue may change during the dispatching

   162                 eq = getEventQueue();

   163 

   164                 event = (id == ANY_EVENT) ? eq.getNextEvent() : eq.getNextEvent(id);

   165 

   166                 eventOK = true;

   167                 synchronized (eventFilters) {

   168                     for (int i = eventFilters.size() - 1; i >= 0; i--) {

   169                         EventFilter f = eventFilters.get(i);

   170                         EventFilter.FilterAction accept = f.acceptEvent(event);

   171                         if (accept == EventFilter.FilterAction.REJECT) {

   172                             eventOK = false;

   173                             break;

   174                         } else if (accept == EventFilter.FilterAction.ACCEPT_IMMEDIATELY) {

   175                             break;

   176                         }

   177                     }

   178                 }

   179                 eventOK = eventOK && SunDragSourceContextPeer.checkEvent(event);

   180                 if (!eventOK) {

   181                     event.consume();

   182                 }

   183             }

   184             while (eventOK == false);

   185 

   186             if (eventLog.isLoggable(PlatformLogger.Level.FINEST)) {

   187                 eventLog.finest("Dispatching: " + event);

   188             }

   189 

   190             eq.dispatchEvent(event);

   191         }

   192         catch (ThreadDeath death) {

   193             doDispatch = false;

   194             throw death;

   195         }

   196         catch (InterruptedException interruptedException) {

   197             doDispatch = false; // AppContext.dispose() interrupts all

   198                                 // Threads in the AppContext

   199         }

   200         catch (Throwable e) {

   201             processException(e);

   202         }

   203     }

   204 

   205     private void processException(Throwable e) {

   206         if (eventLog.isLoggable(PlatformLogger.Level.FINE)) {

   207             eventLog.fine("Processing exception: " + e);

   208         }

   209         getUncaughtExceptionHandler().uncaughtException(this, e);

   210     }

   211 

   212     public synchronized EventQueue getEventQueue() {

   213         return theQueue;

   214     }

   215     public synchronized void setEventQueue(EventQueue eq) {

   216         theQueue = eq;

   217     }

   218 

   219     private static class HierarchyEventFilter implements EventFilter {

   220         private Component modalComponent;

   221         public HierarchyEventFilter(Component modalComponent) {

   222             this.modalComponent = modalComponent;

   223         }

   224         public FilterAction acceptEvent(AWTEvent event) {

   225             if (modalComponent != null) {

   226                 int eventID = event.getID();

   227                 boolean mouseEvent = (eventID >= MouseEvent.MOUSE_FIRST) &&

   228                                      (eventID <= MouseEvent.MOUSE_LAST);

   229                 boolean actionEvent = (eventID >= ActionEvent.ACTION_FIRST) &&

   230                                       (eventID <= ActionEvent.ACTION_LAST);

   231                 boolean windowClosingEvent = (eventID == WindowEvent.WINDOW_CLOSING);

   232                 /*

   233                  * filter out MouseEvent and ActionEvent that's outside

   234                  * the modalComponent hierarchy.

   235                  * KeyEvent is handled by using enqueueKeyEvent

   236                  * in Dialog.show

   237                  */

   238                 if (Component.isInstanceOf(modalComponent, "javax.swing.JInternalFrame")) {

   239                     /*

   240                      * Modal internal frames are handled separately. If event is

   241                      * for some component from another heavyweight than modalComp,

   242                      * it is accepted. If heavyweight is the same - we still accept

   243                      * event and perform further filtering in LightweightDispatcher

   244                      */

   245                     return windowClosingEvent ? FilterAction.REJECT : FilterAction.ACCEPT;

   246                 }

   247                 if (mouseEvent || actionEvent || windowClosingEvent) {

   248                     Object o = event.getSource();

   249                     if (o instanceof sun.awt.ModalExclude) {

   250                         // Exclude this object from modality and

   251                         // continue to pump it's events.

   252                         return FilterAction.ACCEPT;

   253                     } else if (o instanceof Component) {

   254                         Component c = (Component) o;

   255                         // 5.0u3 modal exclusion

   256                         boolean modalExcluded = false;

   257                         if (modalComponent instanceof Container) {

   258                             while (c != modalComponent && c != null) {

   259                                 if ((c instanceof Window) &&

   260                                     (sun.awt.SunToolkit.isModalExcluded((Window)c))) {

   261                                     // Exclude this window and all its children from

   262                                     //  modality and continue to pump it's events.

   263                                     modalExcluded = true;

   264                                     break;

   265                                 }

   266                                 c = c.getParent();

   267                             }

   268                         }

   269                         if (!modalExcluded && (c != modalComponent)) {

   270                             return FilterAction.REJECT;

   271                         }

   272                     }

   273                 }

   274             }

   275             return FilterAction.ACCEPT;

   276         }

   277     }

   278 }