| /* |
| * 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 javax.swing.*; |
| import javax.swing.event.*; |
| import sun.security.util.SecurityConstants.AWT; |
| |
| /** |
| * <P>The {@code AWTEventMonitor} implements a suite of listeners that are |
| * conditionally installed on every AWT component instance in the Java |
| * Virtual Machine. The events captured by these listeners are made |
| * available through a unified set of listeners supported by {@code AWTEventMonitor}. |
| * With this, all the individual events on each of the AWT component |
| * instances are funneled into one set of listeners broken down by category |
| * (see {@link EventID} for the categories). |
| * <p>This class depends upon {@link EventQueueMonitor}, which provides the base |
| * level support for capturing the top-level containers as they are created. |
| */ |
| |
| @jdk.Exported |
| public class AWTEventMonitor { |
| |
| static private boolean runningOnJDK1_4 = false; |
| |
| /** |
| * The current component with keyboard focus. |
| * |
| * @see #getComponentWithFocus |
| * |
| * @deprecated This field is unused; to get the component with focus use the |
| * getComponentWithFocus method. |
| */ |
| @Deprecated |
| static protected Component componentWithFocus = null; |
| |
| static private Component componentWithFocus_private = null; |
| |
| // Low-level listeners |
| /** |
| * The current list of registered ComponentListener classes. |
| * |
| * @see #addComponentListener |
| * @see #removeComponentListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected ComponentListener componentListener = null; |
| |
| static private ComponentListener componentListener_private = null; |
| |
| /** |
| * The current list of registered ContainerListener classes. |
| * |
| * @see #addContainerListener |
| * @see #removeContainerListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected ContainerListener containerListener = null; |
| |
| static private ContainerListener containerListener_private = null; |
| |
| /** |
| * The current list of registered FocusListener classes. |
| * |
| * @see #addFocusListener |
| * @see #removeFocusListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected FocusListener focusListener = null; |
| |
| static private FocusListener focusListener_private = null; |
| |
| /** |
| * The current list of registered KeyListener classes. |
| * |
| * @see #addKeyListener |
| * @see #removeKeyListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected KeyListener keyListener = null; |
| |
| static private KeyListener keyListener_private = null; |
| |
| /** |
| * The current list of registered MouseListener classes. |
| * |
| * @see #addMouseListener |
| * @see #removeMouseListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected MouseListener mouseListener = null; |
| |
| static private MouseListener mouseListener_private = null; |
| |
| /** |
| * The current list of registered MouseMotionListener classes. |
| * |
| * @see #addMouseMotionListener |
| * @see #removeMouseMotionListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected MouseMotionListener mouseMotionListener = null; |
| |
| static private MouseMotionListener mouseMotionListener_private = null; |
| |
| /** |
| * The current list of registered WindowListener classes. |
| * |
| * @see #addWindowListener |
| * @see #removeWindowListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected WindowListener windowListener = null; |
| |
| static private WindowListener windowListener_private = null; |
| |
| |
| // Semantic listeners |
| /** |
| * The current list of registered ActionListener classes. |
| * |
| * @see #addActionListener |
| * @see #removeActionListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected ActionListener actionListener = null; |
| |
| static private ActionListener actionListener_private = null; |
| |
| /** |
| * The current list of registered AdjustmentListener classes. |
| * |
| * @see #addAdjustmentListener |
| * @see #removeAdjustmentListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected AdjustmentListener adjustmentListener = null; |
| |
| static private AdjustmentListener adjustmentListener_private = null; |
| |
| /** |
| * The current list of registered ItemListener classes. |
| * |
| * @see #addItemListener |
| * @see #removeItemListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected ItemListener itemListener = null; |
| |
| static private ItemListener itemListener_private = null; |
| |
| /** |
| * The current list of registered TextListener classes. |
| * |
| * @see #addTextListener |
| * @see #removeTextListener |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected TextListener textListener = null; |
| |
| static private TextListener textListener_private = null; |
| |
| |
| /** |
| * The actual listener that is installed on the component instances. |
| * This listener calls the other registered listeners when an event |
| * occurs. By doing things this way, the actual number of listeners |
| * installed on a component instance is drastically reduced. |
| * |
| * @deprecated This field is unused. |
| */ |
| @Deprecated |
| static protected AWTEventsListener awtListener = new AWTEventsListener(); |
| |
| static private final AWTEventsListener awtListener_private = new AWTEventsListener(); |
| |
| /** |
| * Returns the component that currently has keyboard focus. The return |
| * value can be null. |
| * |
| * @return the component that has keyboard focus |
| */ |
| static public Component getComponentWithFocus() { |
| return componentWithFocus_private; |
| } |
| |
| /* |
| * Check permissions |
| */ |
| static private void checkInstallPermission() { |
| SecurityManager security = System.getSecurityManager(); |
| if (security != null) { |
| security.checkPermission(AWT.ALL_AWT_EVENTS_PERMISSION); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#COMPONENT COMPONENT} |
| * events on each component instance in the Java Virtual Machine as they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeComponentListener |
| */ |
| static public void addComponentListener(ComponentListener l) { |
| if (componentListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.COMPONENT); |
| } |
| componentListener_private = AWTEventMulticaster.add(componentListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives |
| * {@link EventID#COMPONENT COMPONENT} events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addComponentListener |
| */ |
| static public void removeComponentListener(ComponentListener l) { |
| componentListener_private = AWTEventMulticaster.remove(componentListener_private, l); |
| if (componentListener_private == null) { |
| awtListener_private.removeListeners(EventID.COMPONENT); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#CONTAINER CONTAINER} |
| * events on each component instance in the Java Virtual Machine as they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeContainerListener |
| */ |
| static public void addContainerListener(ContainerListener l) { |
| containerListener_private = AWTEventMulticaster.add(containerListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives |
| * {@link EventID#CONTAINER CONTAINER} events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addContainerListener |
| */ |
| static public void removeContainerListener(ContainerListener l) { |
| containerListener_private = AWTEventMulticaster.remove(containerListener_private, l); |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#FOCUS FOCUS} events |
| * on each component instance in the Java Virtual Machine when they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeFocusListener |
| */ |
| static public void addFocusListener(FocusListener l) { |
| focusListener_private = AWTEventMulticaster.add(focusListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives {@link EventID#FOCUS FOCUS} |
| * events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addFocusListener |
| */ |
| static public void removeFocusListener(FocusListener l) { |
| focusListener_private = AWTEventMulticaster.remove(focusListener_private, l); |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#KEY KEY} events on each |
| * component instance in the Java Virtual Machine when they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeKeyListener |
| */ |
| static public void addKeyListener(KeyListener l) { |
| if (keyListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.KEY); |
| } |
| keyListener_private = AWTEventMulticaster.add(keyListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives {@link EventID#KEY KEY} |
| * events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addKeyListener |
| */ |
| static public void removeKeyListener(KeyListener l) { |
| keyListener_private = AWTEventMulticaster.remove(keyListener_private, l); |
| if (keyListener_private == null) { |
| awtListener_private.removeListeners(EventID.KEY); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#MOUSE MOUSE} events |
| * on each component instance in the Java Virtual Machine when they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeMouseListener |
| */ |
| static public void addMouseListener(MouseListener l) { |
| if (mouseListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.MOUSE); |
| } |
| mouseListener_private = AWTEventMulticaster.add(mouseListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives |
| * {@link EventID#MOUSE MOUSE} events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addMouseListener |
| */ |
| static public void removeMouseListener(MouseListener l) { |
| mouseListener_private = AWTEventMulticaster.remove(mouseListener_private, l); |
| if (mouseListener_private == null) { |
| awtListener_private.removeListeners(EventID.MOUSE); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all mouse {@link EventID#MOTION MOTION} |
| * events on each component instance in the Java Virtual Machine when they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeMouseMotionListener |
| */ |
| static public void addMouseMotionListener(MouseMotionListener l) { |
| if (mouseMotionListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.MOTION); |
| } |
| mouseMotionListener_private = AWTEventMulticaster.add(mouseMotionListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives |
| * {@link EventID#MOTION MOTION} events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addMouseMotionListener |
| */ |
| static public void removeMouseMotionListener(MouseMotionListener l) { |
| mouseMotionListener_private = AWTEventMulticaster.remove(mouseMotionListener_private, l); |
| if (mouseMotionListener_private == null) { |
| awtListener_private.removeListeners(EventID.MOTION); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#WINDOW WINDOW} |
| * events on each component instance in the Java Virtual Machine when they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeWindowListener |
| */ |
| static public void addWindowListener(WindowListener l) { |
| if (windowListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.WINDOW); |
| } |
| windowListener_private = AWTEventMulticaster.add(windowListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives |
| * {@link EventID#WINDOW WINDOW} events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addWindowListener |
| */ |
| static public void removeWindowListener(WindowListener l) { |
| windowListener_private = AWTEventMulticaster.remove(windowListener_private, l); |
| if (windowListener_private == null) { |
| awtListener_private.removeListeners(EventID.WINDOW); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#ACTION ACTION} |
| * events on each component instance in the Java Virtual Machine when they occur. |
| * <P>Note: This listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeActionListener |
| */ |
| static public void addActionListener(ActionListener l) { |
| if (actionListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.ACTION); |
| } |
| actionListener_private = AWTEventMulticaster.add(actionListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives |
| * {@link EventID#ACTION ACTION} events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addActionListener |
| */ |
| static public void removeActionListener(ActionListener l) { |
| actionListener_private = AWTEventMulticaster.remove(actionListener_private, l); |
| if (actionListener_private == null) { |
| awtListener_private.removeListeners(EventID.ACTION); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all |
| * {@link EventID#ADJUSTMENT ADJUSTMENT} events on each component instance |
| * in the Java Virtual Machine when they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeAdjustmentListener |
| */ |
| static public void addAdjustmentListener(AdjustmentListener l) { |
| if (adjustmentListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.ADJUSTMENT); |
| } |
| adjustmentListener_private = AWTEventMulticaster.add(adjustmentListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives |
| * {@link EventID#ADJUSTMENT ADJUSTMENT} events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addAdjustmentListener |
| */ |
| static public void removeAdjustmentListener(AdjustmentListener l) { |
| adjustmentListener_private = AWTEventMulticaster.remove(adjustmentListener_private, l); |
| if (adjustmentListener_private == null) { |
| awtListener_private.removeListeners(EventID.ADJUSTMENT); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#ITEM ITEM} events |
| * on each component instance in the Java Virtual Machine when they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeItemListener |
| */ |
| static public void addItemListener(ItemListener l) { |
| if (itemListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.ITEM); |
| } |
| itemListener_private = AWTEventMulticaster.add(itemListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives {@link EventID#ITEM ITEM} |
| * events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addItemListener |
| */ |
| static public void removeItemListener(ItemListener l) { |
| itemListener_private = AWTEventMulticaster.remove(itemListener_private, l); |
| if (itemListener_private == null) { |
| awtListener_private.removeListeners(EventID.ITEM); |
| } |
| } |
| |
| /** |
| * Adds the specified listener to receive all {@link EventID#TEXT TEXT} events |
| * on each component instance in the Java Virtual Machine when they occur. |
| * <P>Note: this listener is automatically added to all component |
| * instances created after this method is called. In addition, it |
| * is only added to component instances that support this listener type. |
| * |
| * @param l the listener to add |
| * @see #removeTextListener |
| */ |
| static public void addTextListener(TextListener l) { |
| if (textListener_private == null) { |
| checkInstallPermission(); |
| awtListener_private.installListeners(EventID.TEXT); |
| } |
| textListener_private = AWTEventMulticaster.add(textListener_private, l); |
| } |
| |
| /** |
| * Removes the specified listener so it no longer receives {@link EventID#TEXT TEXT} |
| * events when they occur. |
| * |
| * @param l the listener to remove |
| * @see #addTextListener |
| */ |
| static public void removeTextListener(TextListener l) { |
| textListener_private = AWTEventMulticaster.remove(textListener_private, l); |
| if (textListener_private == null) { |
| awtListener_private.removeListeners(EventID.TEXT); |
| } |
| } |
| |
| |
| /** |
| * AWTEventsListener is the class that does all the work for AWTEventMonitor. |
| * It is not intended for use by any other class except AWTEventMonitor. |
| * |
| */ |
| |
| static class AWTEventsListener implements TopLevelWindowListener, |
| ActionListener, AdjustmentListener, ComponentListener, |
| ContainerListener, FocusListener, ItemListener, KeyListener, |
| MouseListener, MouseMotionListener, TextListener, WindowListener, |
| ChangeListener { |
| |
| /** |
| * internal variables for Action introspection |
| */ |
| private java.lang.Class actionListeners[]; |
| private java.lang.reflect.Method removeActionMethod; |
| private java.lang.reflect.Method addActionMethod; |
| private java.lang.Object actionArgs[]; |
| |
| /** |
| * internal variables for Item introspection |
| */ |
| private java.lang.Class itemListeners[]; |
| private java.lang.reflect.Method removeItemMethod; |
| private java.lang.reflect.Method addItemMethod; |
| private java.lang.Object itemArgs[]; |
| |
| /** |
| * internal variables for Text introspection |
| */ |
| private java.lang.Class textListeners[]; |
| private java.lang.reflect.Method removeTextMethod; |
| private java.lang.reflect.Method addTextMethod; |
| private java.lang.Object textArgs[]; |
| |
| /** |
| * internal variables for Window introspection |
| */ |
| private java.lang.Class windowListeners[]; |
| private java.lang.reflect.Method removeWindowMethod; |
| private java.lang.reflect.Method addWindowMethod; |
| private java.lang.Object windowArgs[]; |
| |
| /** |
| * Create a new instance of this class and install it on each component |
| * instance in the virtual machine that supports any of the currently |
| * registered listeners in AWTEventMonitor. Also registers itself |
| * as a TopLevelWindowListener with EventQueueMonitor so it can |
| * automatically add new listeners to new components. |
| * |
| * @see EventQueueMonitor |
| * @see AWTEventMonitor |
| */ |
| public AWTEventsListener() { |
| String version = System.getProperty("java.version"); |
| if (version != null) { |
| runningOnJDK1_4 = (version.compareTo("1.4") >= 0); |
| } |
| initializeIntrospection(); |
| installListeners(); |
| if (runningOnJDK1_4) { |
| MenuSelectionManager.defaultManager().addChangeListener(this); |
| } |
| EventQueueMonitor.addTopLevelWindowListener(this); |
| } |
| |
| /** |
| * Set up all of the variables needed for introspection |
| */ |
| private boolean initializeIntrospection() { |
| try { |
| actionListeners = new java.lang.Class[1]; |
| actionArgs = new java.lang.Object[1]; |
| actionListeners[0] = Class.forName("java.awt.event.ActionListener"); |
| actionArgs[0] = this; |
| |
| itemListeners = new java.lang.Class[1]; |
| itemArgs = new java.lang.Object[1]; |
| itemListeners[0] = Class.forName("java.awt.event.ItemListener"); |
| itemArgs[0] = this; |
| |
| textListeners = new java.lang.Class[1]; |
| textArgs = new java.lang.Object[1]; |
| textListeners[0] = Class.forName("java.awt.event.TextListener"); |
| textArgs[0] = this; |
| |
| windowListeners = new java.lang.Class[1]; |
| windowArgs = new java.lang.Object[1]; |
| windowListeners[0] = Class.forName("java.awt.event.WindowListener"); |
| windowArgs[0] = this; |
| |
| return true; |
| } catch (ClassNotFoundException e) { |
| System.out.println("EXCEPTION - Class 'java.awt.event.*' not in CLASSPATH"); |
| return false; |
| } |
| } |
| |
| /** |
| * Installs all currently registered listeners on all components based |
| * upon the current topLevelWindows cached by EventQueueMonitor. |
| * @see EventQueueMonitor |
| * @see AWTEventMonitor |
| */ |
| protected void installListeners() { |
| Window topLevelWindows[] = EventQueueMonitor.getTopLevelWindows(); |
| if (topLevelWindows != null) { |
| for (int i = 0; i < topLevelWindows.length; i++) { |
| installListeners(topLevelWindows[i]); |
| } |
| } |
| } |
| |
| /** |
| * Installs listeners for the given event ID on all components based |
| * upon the current topLevelWindows cached by EventQueueMonitor. |
| * @see EventID |
| * @param eventID the event ID |
| */ |
| protected void installListeners(int eventID) { |
| Window topLevelWindows[] = EventQueueMonitor.getTopLevelWindows(); |
| if (topLevelWindows != null) { |
| for (int i = 0; i < topLevelWindows.length; i++) { |
| installListeners(topLevelWindows[i], eventID); |
| } |
| } |
| } |
| |
| /** |
| * Installs all currently registered listeners to just the component. |
| * @param c the component to add listeners to |
| */ |
| protected void installListeners(Component c) { |
| |
| // Container and focus listeners are always installed for our own use. |
| // |
| installListeners(c,EventID.CONTAINER); |
| installListeners(c,EventID.FOCUS); |
| |
| // conditionally install low-level listeners |
| // |
| if (AWTEventMonitor.componentListener_private != null) { |
| installListeners(c,EventID.COMPONENT); |
| } |
| if (AWTEventMonitor.keyListener_private != null) { |
| installListeners(c,EventID.KEY); |
| } |
| if (AWTEventMonitor.mouseListener_private != null) { |
| installListeners(c,EventID.MOUSE); |
| } |
| if (AWTEventMonitor.mouseMotionListener_private != null) { |
| installListeners(c,EventID.MOTION); |
| } |
| if (AWTEventMonitor.windowListener_private != null) { |
| installListeners(c,EventID.WINDOW); |
| } |
| |
| // conditionally install Semantic listeners |
| // |
| if (AWTEventMonitor.actionListener_private != null) { |
| installListeners(c,EventID.ACTION); |
| } |
| if (AWTEventMonitor.adjustmentListener_private != null) { |
| installListeners(c,EventID.ADJUSTMENT); |
| } |
| if (AWTEventMonitor.itemListener_private != null) { |
| installListeners(c,EventID.ITEM); |
| } |
| if (AWTEventMonitor.textListener_private != null) { |
| installListeners(c,EventID.TEXT); |
| } |
| } |
| |
| public void stateChanged(ChangeEvent e) { |
| processFocusGained(); |
| } |
| |
| private void processFocusGained() { |
| Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); |
| if (focusOwner == null) { |
| return; |
| } |
| MenuSelectionManager.defaultManager().removeChangeListener(this); |
| MenuSelectionManager.defaultManager().addChangeListener(this); |
| |
| // Only menus and popup selections are handled by the JRootPane. |
| if (focusOwner instanceof JRootPane) { |
| MenuElement [] path = |
| MenuSelectionManager.defaultManager().getSelectedPath(); |
| if (path.length > 1) { |
| Component penult = path[path.length-2].getComponent(); |
| Component last = path[path.length-1].getComponent(); |
| |
| if (last instanceof JPopupMenu || |
| last instanceof JMenu) { |
| // This is a popup with nothing in the popup |
| // selected. The menu itself is selected. |
| componentWithFocus_private = last; |
| } else if (penult instanceof JPopupMenu) { |
| // This is a popup with an item selected |
| componentWithFocus_private = penult; |
| } |
| } |
| } else { |
| // The focus owner has the selection. |
| componentWithFocus_private = focusOwner; |
| } |
| } |
| |
| /** |
| * Installs the given listener on the component and any of its children. |
| * As a precaution, it always attempts to remove itself as a listener |
| * first so it's always guaranteed to have installed itself just once. |
| * @param c the component to add listeners to |
| * @param eventID the eventID to add listeners for |
| * @see EventID |
| */ |
| protected void installListeners(Component c, int eventID) { |
| |
| // install the appropriate listener hook into this component |
| // |
| switch (eventID) { |
| |
| case EventID.ACTION: |
| try { |
| removeActionMethod = c.getClass().getMethod( |
| "removeActionListener", actionListeners); |
| addActionMethod = c.getClass().getMethod( |
| "addActionListener", actionListeners); |
| try { |
| removeActionMethod.invoke(c, actionArgs); |
| addActionMethod.invoke(c, actionArgs); |
| } catch (java.lang.reflect.InvocationTargetException e) { |
| System.out.println("Exception: " + e.toString()); |
| } catch (IllegalAccessException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| } catch (NoSuchMethodException e) { |
| // System.out.println("Exception: " + e.toString()); |
| } catch (SecurityException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| break; |
| |
| case EventID.ADJUSTMENT: |
| if (c instanceof Adjustable) { |
| ((Adjustable) c).removeAdjustmentListener(this); |
| ((Adjustable) c).addAdjustmentListener(this); |
| } |
| break; |
| |
| case EventID.COMPONENT: |
| c.removeComponentListener(this); |
| c.addComponentListener(this); |
| break; |
| |
| case EventID.CONTAINER: |
| if (c instanceof Container) { |
| ((Container) c).removeContainerListener(this); |
| ((Container) c).addContainerListener(this); |
| } |
| break; |
| |
| case EventID.FOCUS: |
| c.removeFocusListener(this); |
| c.addFocusListener(this); |
| |
| if (runningOnJDK1_4) { |
| processFocusGained(); |
| |
| } else { // not runningOnJDK1_4 |
| if ((c != componentWithFocus_private) && c.hasFocus()) { |
| componentWithFocus_private = c; |
| } |
| } |
| break; |
| |
| case EventID.ITEM: |
| try { |
| removeItemMethod = c.getClass().getMethod( |
| "removeItemListener", itemListeners); |
| addItemMethod = c.getClass().getMethod( |
| "addItemListener", itemListeners); |
| try { |
| removeItemMethod.invoke(c, itemArgs); |
| addItemMethod.invoke(c, itemArgs); |
| } catch (java.lang.reflect.InvocationTargetException e) { |
| System.out.println("Exception: " + e.toString()); |
| } catch (IllegalAccessException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| } catch (NoSuchMethodException e) { |
| // System.out.println("Exception: " + e.toString()); |
| } catch (SecurityException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| // [PK] CheckboxMenuItem isn't a component but it does |
| // implement Interface ItemSelectable!! |
| // if (c instanceof CheckboxMenuItem) { |
| // ((CheckboxMenuItem) c).removeItemListener(this); |
| // ((CheckboxMenuItem) c).addItemListener(this); |
| break; |
| |
| case EventID.KEY: |
| c.removeKeyListener(this); |
| c.addKeyListener(this); |
| break; |
| |
| case EventID.MOUSE: |
| c.removeMouseListener(this); |
| c.addMouseListener(this); |
| break; |
| |
| case EventID.MOTION: |
| c.removeMouseMotionListener(this); |
| c.addMouseMotionListener(this); |
| break; |
| |
| case EventID.TEXT: |
| try { |
| removeTextMethod = c.getClass().getMethod( |
| "removeTextListener", textListeners); |
| addTextMethod = c.getClass().getMethod( |
| "addTextListener", textListeners); |
| try { |
| removeTextMethod.invoke(c, textArgs); |
| addTextMethod.invoke(c, textArgs); |
| } catch (java.lang.reflect.InvocationTargetException e) { |
| System.out.println("Exception: " + e.toString()); |
| } catch (IllegalAccessException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| } catch (NoSuchMethodException e) { |
| // System.out.println("Exception: " + e.toString()); |
| } catch (SecurityException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| break; |
| |
| case EventID.WINDOW: |
| try { |
| removeWindowMethod = c.getClass().getMethod( |
| "removeWindowListener", windowListeners); |
| addWindowMethod = c.getClass().getMethod( |
| "addWindowListener", windowListeners); |
| try { |
| removeWindowMethod.invoke(c, windowArgs); |
| addWindowMethod.invoke(c, windowArgs); |
| } catch (java.lang.reflect.InvocationTargetException e) { |
| System.out.println("Exception: " + e.toString()); |
| } catch (IllegalAccessException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| } catch (NoSuchMethodException e) { |
| // System.out.println("Exception: " + e.toString()); |
| } catch (SecurityException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| break; |
| |
| // Don't bother recursing the children if this isn't going to |
| // accomplish anything. |
| // |
| default: |
| return; |
| } |
| |
| // if this component is a container, recurse through children |
| // |
| if (c instanceof Container) { |
| int count = ((Container) c).getComponentCount(); |
| for (int i = 0; i < count; i++) { |
| installListeners(((Container) c).getComponent(i), eventID); |
| } |
| } |
| } |
| |
| /** |
| * Removes all listeners for the given event ID on all components based |
| * upon the topLevelWindows cached by EventQueueMonitor. |
| * @param eventID the event ID |
| * @see EventID |
| */ |
| protected void removeListeners(int eventID) { |
| Window topLevelWindows[] = EventQueueMonitor.getTopLevelWindows(); |
| if (topLevelWindows != null) { |
| for (int i = 0; i < topLevelWindows.length; i++) { |
| removeListeners(topLevelWindows[i], eventID); |
| } |
| } |
| } |
| |
| /** |
| * Removes all listeners for the given component and all its children. |
| * @param c the component |
| */ |
| protected void removeListeners(Component c) { |
| |
| // conditionally remove low-level listeners |
| // |
| if (AWTEventMonitor.componentListener_private != null) { |
| removeListeners(c,EventID.COMPONENT); |
| } |
| if (AWTEventMonitor.keyListener_private != null) { |
| removeListeners(c,EventID.KEY); |
| } |
| if (AWTEventMonitor.mouseListener_private != null) { |
| removeListeners(c,EventID.MOUSE); |
| } |
| if (AWTEventMonitor.mouseMotionListener_private != null) { |
| removeListeners(c,EventID.MOTION); |
| } |
| if (AWTEventMonitor.windowListener_private != null) { |
| removeListeners(c,EventID.WINDOW); |
| } |
| |
| // Remove semantic listeners |
| // |
| if (AWTEventMonitor.actionListener_private != null) { |
| removeListeners(c,EventID.ACTION); |
| } |
| if (AWTEventMonitor.adjustmentListener_private != null) { |
| removeListeners(c,EventID.ADJUSTMENT); |
| } |
| if (AWTEventMonitor.itemListener_private != null) { |
| removeListeners(c,EventID.ITEM); |
| } |
| if (AWTEventMonitor.textListener_private != null) { |
| removeListeners(c,EventID.TEXT); |
| } |
| } |
| |
| /** |
| * Removes all listeners for the event ID from the component and all |
| * of its children. |
| * @param c the component to remove listeners from |
| * @see EventID |
| */ |
| protected void removeListeners(Component c, int eventID) { |
| |
| // remove the appropriate listener hook into this component |
| // |
| switch (eventID) { |
| |
| case EventID.ACTION: |
| try { |
| removeActionMethod = c.getClass().getMethod( |
| "removeActionListener", |
| actionListeners); |
| try { |
| removeActionMethod.invoke(c, actionArgs); |
| } catch (java.lang.reflect.InvocationTargetException e) { |
| System.out.println("Exception: " + e.toString()); |
| } catch (IllegalAccessException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| } catch (NoSuchMethodException e) { |
| // System.out.println("Exception: " + e.toString()); |
| } catch (SecurityException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| break; |
| |
| case EventID.ADJUSTMENT: |
| if (c instanceof Adjustable) { |
| ((Adjustable) c).removeAdjustmentListener(this); |
| } |
| break; |
| |
| case EventID.COMPONENT: |
| c.removeComponentListener(this); |
| break; |
| |
| // Never remove these because we're always interested in them |
| // for our own use. |
| //case EventID.CONTAINER: |
| // if (c instanceof Container) { |
| // ((Container) c).removeContainerListener(this); |
| // } |
| // break; |
| // |
| //case EventID.FOCUS: |
| // c.removeFocusListener(this); |
| // break; |
| |
| case EventID.ITEM: |
| try { |
| removeItemMethod = c.getClass().getMethod( |
| "removeItemListener", itemListeners); |
| try { |
| removeItemMethod.invoke(c, itemArgs); |
| } catch (java.lang.reflect.InvocationTargetException e) { |
| System.out.println("Exception: " + e.toString()); |
| } catch (IllegalAccessException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| } catch (NoSuchMethodException e) { |
| // System.out.println("Exception: " + e.toString()); |
| } catch (SecurityException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| // [PK] CheckboxMenuItem isn't a component but it does |
| // implement Interface ItemSelectable!! |
| // if (c instanceof CheckboxMenuItem) { |
| // ((CheckboxMenuItem) c).removeItemListener(this); |
| break; |
| |
| case EventID.KEY: |
| c.removeKeyListener(this); |
| break; |
| |
| case EventID.MOUSE: |
| c.removeMouseListener(this); |
| break; |
| |
| case EventID.MOTION: |
| c.removeMouseMotionListener(this); |
| break; |
| |
| case EventID.TEXT: |
| try { |
| removeTextMethod = c.getClass().getMethod( |
| "removeTextListener", textListeners); |
| try { |
| removeTextMethod.invoke(c, textArgs); |
| } catch (java.lang.reflect.InvocationTargetException e) { |
| System.out.println("Exception: " + e.toString()); |
| } catch (IllegalAccessException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| } catch (NoSuchMethodException e) { |
| // System.out.println("Exception: " + e.toString()); |
| } catch (SecurityException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| break; |
| |
| case EventID.WINDOW: |
| try { |
| removeWindowMethod = c.getClass().getMethod( |
| "removeWindowListener", windowListeners); |
| try { |
| removeWindowMethod.invoke(c, windowArgs); |
| } catch (java.lang.reflect.InvocationTargetException e) { |
| System.out.println("Exception: " + e.toString()); |
| } catch (IllegalAccessException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| } catch (NoSuchMethodException e) { |
| // System.out.println("Exception: " + e.toString()); |
| } catch (SecurityException e) { |
| System.out.println("Exception: " + e.toString()); |
| } |
| break; |
| |
| default: |
| return; |
| } |
| |
| if (c instanceof Container) { |
| int count = ((Container) c).getComponentCount(); |
| for (int i = 0; i < count; i++) { |
| removeListeners(((Container) c).getComponent(i), eventID); |
| } |
| } |
| } |
| |
| /********************************************************************/ |
| /* */ |
| /* Listener Interface Methods */ |
| /* */ |
| /********************************************************************/ |
| |
| /* TopLevelWindow Methods ***************************************/ |
| |
| /** |
| * Called when top level window is created. |
| * @see EventQueueMonitor |
| * @see EventQueueMonitor#addTopLevelWindowListener |
| */ |
| public void topLevelWindowCreated(Window w) { |
| installListeners(w); |
| } |
| |
| /** |
| * Called when top level window is destroyed. |
| * @see EventQueueMonitor |
| * @see EventQueueMonitor#addTopLevelWindowListener |
| */ |
| public void topLevelWindowDestroyed(Window w) { |
| } |
| |
| /* ActionListener Methods ***************************************/ |
| |
| /** |
| * Called when an action is performed. |
| * @see AWTEventMonitor#addActionListener |
| */ |
| public void actionPerformed(ActionEvent e) { |
| if (AWTEventMonitor.actionListener_private != null) { |
| AWTEventMonitor.actionListener_private.actionPerformed(e); |
| } |
| } |
| |
| /* AdjustmentListener Methods ***********************************/ |
| |
| /** |
| * Called when an adjustment is made. |
| * @see AWTEventMonitor#addAdjustmentListener |
| */ |
| public void adjustmentValueChanged(AdjustmentEvent e) { |
| if (AWTEventMonitor.adjustmentListener_private != null) { |
| AWTEventMonitor.adjustmentListener_private.adjustmentValueChanged(e); |
| } |
| } |
| |
| /* ComponentListener Methods ************************************/ |
| |
| /** |
| * Called when a component is hidden. |
| * @see AWTEventMonitor#addComponentListener |
| */ |
| public void componentHidden(ComponentEvent e) { |
| if (AWTEventMonitor.componentListener_private != null) { |
| AWTEventMonitor.componentListener_private.componentHidden(e); |
| } |
| } |
| |
| /** |
| * Called when a component is moved. |
| * @see AWTEventMonitor#addComponentListener |
| */ |
| public void componentMoved(ComponentEvent e) { |
| if (AWTEventMonitor.componentListener_private != null) { |
| AWTEventMonitor.componentListener_private.componentMoved(e); |
| } |
| } |
| |
| /** |
| * Called when a component is resized. |
| * @see AWTEventMonitor#addComponentListener |
| */ |
| public void componentResized(ComponentEvent e) { |
| if (AWTEventMonitor.componentListener_private != null) { |
| AWTEventMonitor.componentListener_private.componentResized(e); |
| } |
| } |
| |
| /** |
| * Called when a component is shown. |
| * @see AWTEventMonitor#addComponentListener |
| */ |
| public void componentShown(ComponentEvent e) { |
| if (AWTEventMonitor.componentListener_private != null) { |
| AWTEventMonitor.componentListener_private.componentShown(e); |
| } |
| } |
| |
| /* ContainerListener Methods ************************************/ |
| |
| /** |
| * Called when a component is added to a container. |
| * @see AWTEventMonitor#addContainerListener |
| */ |
| public void componentAdded(ContainerEvent e) { |
| installListeners(e.getChild()); |
| if (AWTEventMonitor.containerListener_private != null) { |
| AWTEventMonitor.containerListener_private.componentAdded(e); |
| } |
| } |
| |
| /** |
| * Called when a component is removed from a container. |
| * @see AWTEventMonitor#addContainerListener |
| */ |
| public void componentRemoved(ContainerEvent e) { |
| removeListeners(e.getChild()); |
| if (AWTEventMonitor.containerListener_private != null) { |
| AWTEventMonitor.containerListener_private.componentRemoved(e); |
| } |
| } |
| |
| /* FocusListener Methods ****************************************/ |
| |
| /** |
| * Called when a component gains keyboard focus. |
| * @see AWTEventMonitor#addFocusListener |
| */ |
| public void focusGained(FocusEvent e) { |
| AWTEventMonitor.componentWithFocus_private = (Component) e.getSource(); |
| if (AWTEventMonitor.focusListener_private != null) { |
| AWTEventMonitor.focusListener_private.focusGained(e); |
| } |
| } |
| |
| /** |
| * Called when a component loses keyboard focus. |
| * @see AWTEventMonitor#addFocusListener |
| */ |
| public void focusLost(FocusEvent e) { |
| AWTEventMonitor.componentWithFocus_private = null; |
| if (AWTEventMonitor.focusListener_private != null) { |
| AWTEventMonitor.focusListener_private.focusLost(e); |
| } |
| } |
| |
| /* ItemListener Methods *****************************************/ |
| |
| /** |
| * Called when an item's state changes. |
| * @see AWTEventMonitor#addItemListener |
| */ |
| public void itemStateChanged(ItemEvent e) { |
| if (AWTEventMonitor.itemListener_private != null) { |
| AWTEventMonitor.itemListener_private.itemStateChanged(e); |
| } |
| } |
| |
| /* KeyListener Methods ******************************************/ |
| |
| /** |
| * Called when a key is pressed. |
| * @see AWTEventMonitor#addKeyListener |
| */ |
| public void keyPressed(KeyEvent e) { |
| if (AWTEventMonitor.keyListener_private != null) { |
| AWTEventMonitor.keyListener_private.keyPressed(e); |
| } |
| } |
| |
| /** |
| * Called when a key is typed. |
| * @see AWTEventMonitor#addKeyListener |
| */ |
| public void keyReleased(KeyEvent e) { |
| if (AWTEventMonitor.keyListener_private != null) { |
| AWTEventMonitor.keyListener_private.keyReleased(e); |
| } |
| } |
| |
| /** |
| * Called when a key is released. |
| * @see AWTEventMonitor#addKeyListener |
| */ |
| public void keyTyped(KeyEvent e) { |
| if (AWTEventMonitor.keyListener_private != null) { |
| AWTEventMonitor.keyListener_private.keyTyped(e); |
| } |
| } |
| |
| /* MouseListener Methods ****************************************/ |
| |
| /** |
| * Called when the mouse is clicked. |
| * @see AWTEventMonitor#addMouseListener |
| */ |
| public void mouseClicked(MouseEvent e) { |
| if (AWTEventMonitor.mouseListener_private != null) { |
| AWTEventMonitor.mouseListener_private.mouseClicked(e); |
| } |
| } |
| |
| /** |
| * Called when the mouse enters a component. |
| * @see AWTEventMonitor#addMouseListener |
| */ |
| public void mouseEntered(MouseEvent e) { |
| if (AWTEventMonitor.mouseListener_private != null) { |
| AWTEventMonitor.mouseListener_private.mouseEntered(e); |
| } |
| } |
| |
| /** |
| * Called when the mouse leaves a component. |
| * @see AWTEventMonitor#addMouseListener |
| */ |
| public void mouseExited(MouseEvent e) { |
| if (AWTEventMonitor.mouseListener_private != null) { |
| AWTEventMonitor.mouseListener_private.mouseExited(e); |
| } |
| } |
| |
| /** |
| * Called when the mouse is pressed. |
| * @see AWTEventMonitor#addMouseListener |
| */ |
| public void mousePressed(MouseEvent e) { |
| if (AWTEventMonitor.mouseListener_private != null) { |
| AWTEventMonitor.mouseListener_private.mousePressed(e); |
| } |
| } |
| |
| /** |
| * Called when the mouse is released. |
| * @see AWTEventMonitor#addMouseListener |
| */ |
| public void mouseReleased(MouseEvent e) { |
| if (AWTEventMonitor.mouseListener_private != null) { |
| AWTEventMonitor.mouseListener_private.mouseReleased(e); |
| } |
| } |
| |
| /* MouseMotionListener Methods **********************************/ |
| |
| /** |
| * Called when the mouse is dragged. |
| * @see AWTEventMonitor#addMouseMotionListener |
| */ |
| public void mouseDragged(MouseEvent e) { |
| if (AWTEventMonitor.mouseMotionListener_private != null) { |
| AWTEventMonitor.mouseMotionListener_private.mouseDragged(e); |
| } |
| } |
| |
| /** |
| * Called when the mouse is moved. |
| * @see AWTEventMonitor#addMouseMotionListener |
| */ |
| public void mouseMoved(MouseEvent e) { |
| if (AWTEventMonitor.mouseMotionListener_private != null) { |
| AWTEventMonitor.mouseMotionListener_private.mouseMoved(e); |
| } |
| } |
| |
| /* TextListener Methods *****************************************/ |
| |
| /** |
| * Called when a component's text value changed. |
| * @see AWTEventMonitor#addTextListener |
| */ |
| public void textValueChanged(TextEvent e) { |
| if (AWTEventMonitor.textListener_private != null) { |
| AWTEventMonitor.textListener_private.textValueChanged(e); |
| } |
| } |
| |
| /* WindowListener Methods ***************************************/ |
| |
| /** |
| * Called when a window is opened. |
| * @see AWTEventMonitor#addWindowListener |
| */ |
| public void windowOpened(WindowEvent e) { |
| if (AWTEventMonitor.windowListener_private != null) { |
| AWTEventMonitor.windowListener_private.windowOpened(e); |
| } |
| } |
| |
| /** |
| * Called when a window is in the process of closing. |
| * @see AWTEventMonitor#addWindowListener |
| */ |
| public void windowClosing(WindowEvent e) { |
| if (AWTEventMonitor.windowListener_private != null) { |
| AWTEventMonitor.windowListener_private.windowClosing(e); |
| } |
| } |
| |
| /** |
| * Called when a window is closed. |
| * @see AWTEventMonitor#addWindowListener |
| */ |
| public void windowClosed(WindowEvent e) { |
| if (AWTEventMonitor.windowListener_private != null) { |
| AWTEventMonitor.windowListener_private.windowClosed(e); |
| } |
| } |
| |
| /** |
| * Called when a window is iconified. |
| * @see AWTEventMonitor#addWindowListener |
| */ |
| public void windowIconified(WindowEvent e) { |
| if (AWTEventMonitor.windowListener_private != null) { |
| AWTEventMonitor.windowListener_private.windowIconified(e); |
| } |
| } |
| |
| /** |
| * Called when a window is deiconified. |
| * @see AWTEventMonitor#addWindowListener |
| */ |
| public void windowDeiconified(WindowEvent e) { |
| if (AWTEventMonitor.windowListener_private != null) { |
| AWTEventMonitor.windowListener_private.windowDeiconified(e); |
| } |
| } |
| |
| /** |
| * Called when a window is activated. |
| * @see AWTEventMonitor#addWindowListener |
| */ |
| public void windowActivated(WindowEvent e) { |
| if (AWTEventMonitor.windowListener_private != null) { |
| AWTEventMonitor.windowListener_private.windowActivated(e); |
| } |
| } |
| |
| /** |
| * Called when a window is deactivated. |
| * @see AWTEventMonitor#addWindowListener |
| */ |
| public void windowDeactivated(WindowEvent e) { |
| if (AWTEventMonitor.windowListener_private != null) { |
| AWTEventMonitor.windowListener_private.windowDeactivated(e); |
| } |
| } |
| } |
| } |
