Back to index...

	/*
	* 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);
	}
	}
	}
	}

Back to index...