Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 jdk.accessibility.jmod - Accessibility Module
JDK 11 jdk.accessibility.jmod is the JMOD file for JDK 11 Accessibility module.
JDK 11 Accessibility module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.accessibility.jmod.
JDK 11 Accessibility module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Accessibility module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.accessibility.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ com/sun/java/accessibility/util/EventQueueMonitor.java
/* * Copyright (c) 2002, 2015, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ 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 */ 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<Container>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<Void>() { public Void 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; } }
⏎ com/sun/java/accessibility/util/EventQueueMonitor.java
Or download all of them as a single archive file:
File name: jdk.accessibility-11.0.1-src.zip File size: 79006 bytes Release date: 2018-11-04 Download
⇒ JDK 11 jdk.aot.jmod - AOT Compiler Module
2020-08-25, 11570👍, 0💬
Popular Posts:
JDK 11 jdk.javadoc.jmod is the JMOD file for JDK 11 Java Document tool, which can be invoked by the ...
How to download and install xml-commons External Source Package? The source package contains Java so...
How to download and install JDK (Java Development Kit) 6? If you want to write Java applications, yo...
JDK 11 jdk.jdi.jmod is the JMOD file for JDK 11 JDI (Java Debug Interface) tool. JDK 11 JDI tool com...
JDK 11 jdk.jdi.jmod is the JMOD file for JDK 11 JDI (Java Debug Interface) tool. JDK 11 JDI tool com...