| /* |
| * Copyright (c) 2002, 2015, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.java.accessibility.util; |
| |
| import java.util.*; |
| import java.awt.*; |
| import java.awt.event.*; |
| import javax.accessibility.*; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| |
| /** |
| * The {@code EventQueueMonitor} class provides key core functionality for Assistive |
| * Technologies (and other system-level technologies that need some of the same |
| * things that Assistive Technology needs). |
| * |
| * @see AWTEventMonitor |
| * @see SwingEventMonitor |
| */ |
| @jdk.Exported |
| public class EventQueueMonitor |
| implements AWTEventListener { |
| |
| // NOTE: All of the following properties are static. The reason |
| // for this is that there may be multiple EventQueue instances |
| // in use in the same VM. By making these properties static, |
| // we can guarantee we get the information from all of the |
| // EventQueue instances. |
| |
| // The stuff that is cached. |
| // |
| static Vector topLevelWindows = new Vector(); |
| static Window topLevelWindowWithFocus = null; |
| static Point currentMousePosition = null; |
| static Component currentMouseComponent = null; |
| |
| // Low-level listener interfaces |
| // |
| static GUIInitializedListener guiInitializedListener = null; |
| static TopLevelWindowListener topLevelWindowListener = null; |
| static MouseMotionListener mouseMotionListener = null; |
| |
| /** |
| * Class variable stating whether the assistive technologies have |
| * been loaded yet or not. The assistive technologies won't be |
| * loaded until the first event is posted to the EventQueue. This |
| * gives the toolkit a chance to do all the necessary initialization |
| * it needs to do. |
| */ |
| |
| /** |
| * Class variable stating whether the GUI subsystem has been initialized |
| * or not. |
| * |
| * @see #isGUIInitialized |
| */ |
| static boolean guiInitialized = false; |
| |
| /** |
| * Queue that holds events for later processing. |
| */ |
| static EventQueueMonitorItem componentEventQueue = null; |
| |
| /** |
| * Class that tells us what the component event dispatch thread is. |
| */ |
| static private ComponentEvtDispatchThread cedt = null; |
| |
| /** |
| * Handle the synchronization between the thing that populates the |
| * component event dispatch thread ({@link #queueComponentEvent}) |
| * and the thing that processes the events ({@link ComponentEvtDispatchThread}). |
| */ |
| static Object componentEventQueueLock = new Object(); |
| |
| /** |
| * Create a new {@code EventQueueMonitor} instance. Normally, this will |
| * be called only by the AWT Toolkit during initialization time. |
| * Assistive technologies should not create instances of |
| * EventQueueMonitor by themselves. Instead, they should either |
| * refer to it directly via the static methods in this class, e.g., |
| * {@link #getCurrentMousePosition} or obtain the instance by asking the |
| * Toolkit, e.g., {@link java.awt.Toolkit#getSystemEventQueue}. |
| */ |
| public EventQueueMonitor() { |
| if (cedt == null) { |
| cedt = new ComponentEvtDispatchThread("EventQueueMonitor-ComponentEvtDispatch"); |
| |
| cedt.setDaemon(true); |
| cedt.start(); |
| } |
| } |
| |
| /** |
| * Queue up a {@link java.awt.event.ComponentEvent ComponentEvent} for later |
| * processing by the {@link ComponentEvtDispatch} thread. |
| * |
| * @param e a {@code ComponentEvent} |
| */ |
| static void queueComponentEvent(ComponentEvent e) { |
| synchronized(componentEventQueueLock) { |
| EventQueueMonitorItem eqi = new EventQueueMonitorItem(e); |
| if (componentEventQueue == null) { |
| componentEventQueue = eqi; |
| } else { |
| EventQueueMonitorItem q = componentEventQueue; |
| while (true) { |
| if (q.next != null) { |
| q = q.next; |
| } else { |
| break; |
| } |
| } |
| q.next = eqi; |
| } |
| componentEventQueueLock.notifyAll(); |
| } |
| } |
| |
| /** |
| * Tell the {@code EventQueueMonitor} to start listening for events. |
| */ |
| public static void maybeInitialize() { |
| if (cedt == null) { |
| java.security.AccessController.doPrivileged( |
| new java.security.PrivilegedAction() { |
| public Object run() { |
| try { |
| long eventMask = AWTEvent.WINDOW_EVENT_MASK | |
| AWTEvent.FOCUS_EVENT_MASK | |
| AWTEvent.MOUSE_MOTION_EVENT_MASK; |
| |
| Toolkit.getDefaultToolkit().addAWTEventListener(new EventQueueMonitor(), eventMask); |
| } catch (Exception e) { |
| } |
| return null; |
| } |
| } |
| ); |
| } |
| } |
| |
| /** |
| * Handle events as a result of registering a listener |
| * on the {@link java.awt.EventQueue EventQueue} in {@link #maybeInitialize}. |
| */ |
| public void eventDispatched(AWTEvent theEvent) { |
| processEvent(theEvent); |
| } |
| |
| /** |
| * Assisitive technologies that have |
| * registered a {@link GUIInitializedListener} will be notified. |
| * |
| * @see #addGUIInitializedListener |
| */ |
| static void maybeNotifyAssistiveTechnologies() { |
| |
| if (!guiInitialized) { |
| guiInitialized = true; |
| if (guiInitializedListener != null) { |
| guiInitializedListener.guiInitialized(); |
| } |
| } |
| |
| } |
| |
| /********************************************************************/ |
| /* */ |
| /* Package Private Methods */ |
| /* */ |
| /********************************************************************/ |
| |
| /** |
| * Add a Container to the list of top-level containers |
| * in the cache. This follows the object's hierarchy up the |
| * tree until it finds the top most parent. If the parent is |
| * not already in the list of Containers, it adds it to the list. |
| * |
| * @param c the Container |
| */ |
| static void addTopLevelWindow(Component c) { |
| Container parent; |
| |
| if (c == null) { |
| return; |
| } |
| |
| if (!(c instanceof Window)) { |
| addTopLevelWindow(c.getParent()); |
| return; |
| } |
| |
| if ((c instanceof Dialog) || (c instanceof Window)) { |
| parent = (Container) c; |
| } else { |
| parent = c.getParent(); |
| if (parent != null) { |
| addTopLevelWindow(parent); |
| return; |
| } |
| } |
| |
| if (parent == null) { |
| parent = (Container) c; |
| } |
| |
| // Because this method is static, do not make it synchronized because |
| // it can lock the whole class. Instead, just lock what needs to be |
| // locked. |
| // |
| synchronized (topLevelWindows) { |
| if ((parent != null) && !topLevelWindows.contains(parent)) { |
| topLevelWindows.addElement(parent); |
| if (topLevelWindowListener != null) { |
| topLevelWindowListener.topLevelWindowCreated((Window) parent); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Removes a container from the list of top level containers in the cache. |
| * |
| * @param c the top level container to remove |
| */ |
| static void removeTopLevelWindow(Window w) { |
| |
| // Because this method is static, do not make it synchronized because |
| // it can lock the whole class. Instead, just lock what needs to be |
| // locked. |
| // |
| synchronized (topLevelWindows) { |
| if (topLevelWindows.contains(w)) { |
| topLevelWindows.removeElement(w); |
| if (topLevelWindowListener != null) { |
| topLevelWindowListener.topLevelWindowDestroyed(w); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Update current mouse position. |
| * |
| * @param mouseEvent the MouseEvent that holds the new mouse position. |
| */ |
| static void updateCurrentMousePosition(MouseEvent mouseEvent) { |
| Point oldMousePos = currentMousePosition; |
| // Be careful here. The component in the event might be |
| // hidden by the time we process the event. |
| try { |
| Point eventPoint = mouseEvent.getPoint(); |
| currentMouseComponent = (Component) (mouseEvent.getSource()); |
| currentMousePosition = currentMouseComponent.getLocationOnScreen(); |
| currentMousePosition.translate(eventPoint.x,eventPoint.y); |
| } catch (Exception e) { |
| currentMousePosition = oldMousePos; |
| } |
| } |
| |
| /** |
| * Process the event. This maintains the event cache in addition |
| * to calling all the registered listeners. NOTE: The events that |
| * come through here are from peered Components. |
| * |
| * @param theEvent the AWTEvent |
| */ |
| static void processEvent(AWTEvent theEvent) { |
| switch (theEvent.getID()) { |
| case MouseEvent.MOUSE_MOVED: |
| case MouseEvent.MOUSE_DRAGGED: |
| case FocusEvent.FOCUS_GAINED: |
| case WindowEvent.WINDOW_DEACTIVATED: |
| queueComponentEvent((ComponentEvent) theEvent); |
| break; |
| |
| case WindowEvent.WINDOW_ACTIVATED: |
| // Dialogs fire WINDOW_ACTIVATED and FOCUS_GAINED events |
| // before WINDOW_OPENED so we need to add topLevelListeners |
| // for the dialog when it is first activated to get a |
| // focus gained event for the focus component in the dialog. |
| if (theEvent instanceof ComponentEvent) { |
| ComponentEvent ce = (ComponentEvent)theEvent; |
| if (ce.getComponent() instanceof Window) { |
| EventQueueMonitor.addTopLevelWindow(ce.getComponent()); |
| EventQueueMonitor.maybeNotifyAssistiveTechnologies(); |
| } else { |
| EventQueueMonitor.maybeNotifyAssistiveTechnologies(); |
| EventQueueMonitor.addTopLevelWindow(ce.getComponent()); |
| } |
| } |
| queueComponentEvent((ComponentEvent) theEvent); |
| break; |
| |
| // handle WINDOW_OPENED and WINDOW_CLOSED events synchronously |
| case WindowEvent.WINDOW_OPENED: |
| if (theEvent instanceof ComponentEvent) { |
| ComponentEvent ce = (ComponentEvent)theEvent; |
| if (ce.getComponent() instanceof Window) { |
| EventQueueMonitor.addTopLevelWindow(ce.getComponent()); |
| EventQueueMonitor.maybeNotifyAssistiveTechnologies(); |
| } else { |
| EventQueueMonitor.maybeNotifyAssistiveTechnologies(); |
| EventQueueMonitor.addTopLevelWindow(ce.getComponent()); |
| } |
| } |
| break; |
| case WindowEvent.WINDOW_CLOSED: |
| if (theEvent instanceof ComponentEvent) { |
| ComponentEvent ce = (ComponentEvent)theEvent; |
| EventQueueMonitor.removeTopLevelWindow((Window) (ce.getComponent())); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| /** |
| * Internal test |
| */ |
| static synchronized Component getShowingComponentAt(Container c, int x, int y) { |
| if (!c.contains(x, y)) { |
| return null; |
| } |
| int ncomponents = c.getComponentCount(); |
| for (int i = 0 ; i < ncomponents ; i++) { |
| Component comp = c.getComponent(i); |
| if (comp != null && comp.isShowing()) { |
| Point location = comp.getLocation(); |
| if (comp.contains(x - location.x, y - location.y)) { |
| return comp; |
| } |
| } |
| } |
| return c; |
| } |
| |
| /** |
| * Return the Component at the given Point on the screen in the |
| * given Container. |
| * |
| * @param c the Container to search |
| * @param p the Point in screen coordinates |
| * @return the Component at the given Point on the screen in the |
| * given Container -- can be null if no Component is at that Point |
| */ |
| static synchronized Component getComponentAt(Container c, Point p) { |
| if (!c.isShowing()) { |
| return null; |
| } |
| |
| Component comp; |
| Point containerLoc = c.getLocationOnScreen(); |
| Point containerPoint = new Point(p.x - containerLoc.x, |
| p.y - containerLoc.y); |
| |
| comp = getShowingComponentAt(c, containerPoint.x, containerPoint.y); |
| |
| if ((comp != c) && (comp instanceof Container)) { |
| return getComponentAt((Container)comp,p); |
| } else { |
| return comp; |
| } |
| } |
| |
| /** |
| * Obtain the {@link javax.accessibility.Accessible Accessible} object at the given point on the Screen. |
| * The return value may be null if an {@code Accessible} object cannot be |
| * found at the particular point. |
| * |
| * @param p the point to be accessed |
| * @return the {@code Accessible} at the specified point |
| */ |
| static public Accessible getAccessibleAt(Point p) { |
| Window w = getTopLevelWindowWithFocus(); |
| Window[] wins = getTopLevelWindows(); |
| Component c = null; |
| |
| // See if the point we're being asked about is the |
| // currentMousePosition. If so, start with the component |
| // that we know the currentMousePostion is over |
| // |
| if (currentMousePosition == null) { |
| return null; |
| } |
| if (currentMousePosition.equals(p)) { |
| if (currentMouseComponent instanceof Container) { |
| c = getComponentAt((Container) currentMouseComponent, p); |
| } |
| } |
| |
| // Try the window with focus next |
| // |
| if (c == null && w != null) { |
| c = getComponentAt(w,p); |
| } |
| |
| // Try the other windows next. [[[WDW: Stacking order???]]] |
| if (c == null) { |
| for (int i = 0; i < wins.length; i++) { |
| c = getComponentAt(wins[i],p); |
| if (c != null) { |
| break; |
| } |
| } |
| } |
| |
| if (c instanceof Accessible) { |
| AccessibleContext ac = ((Accessible) c).getAccessibleContext(); |
| if (ac != null) { |
| AccessibleComponent acmp = ac.getAccessibleComponent(); |
| if ((acmp != null) && (ac.getAccessibleChildrenCount() != 0)) { |
| Point location = acmp.getLocationOnScreen(); |
| location.move(p.x - location.x, p.y - location.y); |
| return acmp.getAccessibleAt(location); |
| } |
| } |
| return (Accessible) c; |
| } else { |
| return Translator.getAccessible(c); |
| } |
| } |
| |
| /********************************************************************/ |
| /* */ |
| /* Public Methods */ |
| /* */ |
| /********************************************************************/ |
| |
| /** |
| * Says whether the GUI subsystem has been initialized or not. |
| * If this returns true, the assistive technology can freely |
| * create GUI component instances. If the return value is false, |
| * the assistive technology should register a {@link GUIInitializedListener} |
| * and wait to create GUI component instances until the listener is |
| * called. |
| * |
| * @return true if the GUI subsystem has been initialized |
| * @see #addGUIInitializedListener |
| */ |
| static public boolean isGUIInitialized() { |
| maybeInitialize(); |
| return guiInitialized; |
| } |
| |
| /** |
| * Adds the specified listener to be notified when the GUI subsystem |
| * is initialized. Assistive technologies should get the results of |
| * {@link #isGUIInitialized} before calling this method. |
| * |
| * @param l the listener to add |
| * @see #isGUIInitialized |
| * @see #removeTopLevelWindowListener |
| */ |
| static public void addGUIInitializedListener(GUIInitializedListener l) { |
| maybeInitialize(); |
| guiInitializedListener = |
| GUIInitializedMulticaster.add(guiInitializedListener,l); |
| } |
| |
| /** |
| * Removes the specified listener to be notified when the GUI subsystem |
| * is initialized. |
| * |
| * @param l the listener to remove |
| * @see #addGUIInitializedListener |
| */ |
| static public void removeGUIInitializedListener(GUIInitializedListener l) { |
| guiInitializedListener = |
| GUIInitializedMulticaster.remove(guiInitializedListener,l); |
| } |
| |
| /** |
| * Adds the specified listener to be notified when a top level window |
| * is created or destroyed. |
| * |
| * @param l the listener to add |
| * @see #removeTopLevelWindowListener |
| */ |
| static public void addTopLevelWindowListener(TopLevelWindowListener l) { |
| topLevelWindowListener = |
| TopLevelWindowMulticaster.add(topLevelWindowListener,l); |
| } |
| |
| /** |
| * Removes the specified listener to be notified when a top level window |
| * is created or destroyed. |
| * |
| * @param l the listener to remove |
| * @see #addTopLevelWindowListener |
| */ |
| static public void removeTopLevelWindowListener(TopLevelWindowListener l) { |
| topLevelWindowListener = |
| TopLevelWindowMulticaster.remove(topLevelWindowListener,l); |
| } |
| |
| /** |
| * Return the last recorded position of the mouse in screen coordinates. |
| * |
| * @return the last recorded position of the mouse in screen coordinates |
| */ |
| static public Point getCurrentMousePosition() { |
| return currentMousePosition; |
| } |
| |
| /** |
| * Return the list of top level Windows in use in the Java Virtual Machine. |
| * |
| * @return an array of top level {@code Window}s in use in the Java Virtual Machine |
| */ |
| static public Window[] getTopLevelWindows() { |
| |
| // Because this method is static, do not make it synchronized because |
| // it can lock the whole class. Instead, just lock what needs to be |
| // locked. |
| // |
| synchronized (topLevelWindows) { |
| int count = topLevelWindows.size(); |
| if (count > 0) { |
| Window[] w = new Window[count]; |
| for (int i = 0; i < count; i++) { |
| w[i] = (Window)topLevelWindows.elementAt(i); |
| } |
| return w; |
| } else { |
| return new Window[0]; |
| } |
| } |
| } |
| |
| /** |
| * Return the top level {@code Window} that currently has keyboard focus. |
| * |
| * @return the top level {@code Window} that currently has keyboard focus |
| */ |
| static public Window getTopLevelWindowWithFocus() { |
| return topLevelWindowWithFocus; |
| } |
| } |
| |
| /** |
| * Handle all Component events in a separate thread. The reason for this is |
| * that WindowEvents tend to be used to do lots of processing on the Window |
| * hierarchy. As a result, it can frequently result in deadlock situations. |
| */ |
| class ComponentEvtDispatchThread extends Thread { |
| public ComponentEvtDispatchThread(String name) { |
| super(name); |
| } |
| public void run() { |
| ComponentEvent ce = null; |
| while (true) { |
| synchronized(EventQueueMonitor.componentEventQueueLock) { |
| while (EventQueueMonitor.componentEventQueue == null) { |
| try { |
| EventQueueMonitor.componentEventQueueLock.wait(); |
| } catch (InterruptedException e) { |
| } |
| } |
| ce = (ComponentEvent)EventQueueMonitor.componentEventQueue.event; |
| EventQueueMonitor.componentEventQueue = |
| EventQueueMonitor.componentEventQueue.next; |
| } |
| switch (ce.getID()) { |
| case MouseEvent.MOUSE_MOVED: |
| case MouseEvent.MOUSE_DRAGGED: |
| EventQueueMonitor.updateCurrentMousePosition((MouseEvent) ce); |
| break; |
| case WindowEvent.WINDOW_ACTIVATED: |
| EventQueueMonitor.maybeNotifyAssistiveTechnologies(); |
| EventQueueMonitor.topLevelWindowWithFocus = ((WindowEvent) ce).getWindow(); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| } |
| |
| /** |
| * EventQueueMonitorItem is the basic type that handles the |
| * queue for queueComponentEvent and the ComponentEvtDispatchThread. |
| */ |
| class EventQueueMonitorItem { |
| AWTEvent event; |
| EventQueueMonitorItem next; |
| |
| EventQueueMonitorItem(AWTEvent evt) { |
| event = evt; |
| next = null; |
| } |
| } |
