2543 lines
114 KiB
Java
2543 lines
114 KiB
Java
/*
|
|
* 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.beans.*;
|
|
import java.awt.*;
|
|
import java.awt.event.*;
|
|
import javax.swing.*;
|
|
import javax.swing.event.*;
|
|
import javax.swing.table.*;
|
|
import javax.swing.tree.*;
|
|
import javax.swing.text.*;
|
|
import javax.swing.undo.*;
|
|
import javax.accessibility.*;
|
|
|
|
|
|
/**
|
|
* <P>{@code SwingEventMonitor} extends {@link AWTEventMonitor} by adding a suite of
|
|
* listeners conditionally installed on every Swing 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 SwingEventMonitor}. With this, all the individual events on each of the
|
|
* AWT and Swing 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.
|
|
* <p>Because this class extends {@code AWTEventMonitor}, it is not
|
|
* necessary to use this class and {@code AWTEventMonitor} at the same time.
|
|
* If you want to monitor both AWT and Swing components, you should
|
|
* use just this class.
|
|
*
|
|
* @see AWTEventMonitor
|
|
*
|
|
*/
|
|
@jdk.Exported
|
|
public class SwingEventMonitor extends AWTEventMonitor {
|
|
|
|
/**
|
|
* The master list of all listeners registered by other classes.
|
|
* This can only be publicly modified by calling the add or
|
|
* remove listener methods in this class.
|
|
*/
|
|
static protected final EventListenerList listenerList = new EventListenerList();
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
static protected final SwingEventListener swingListener = new SwingEventListener();
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#ANCESTOR ANCESTOR}
|
|
* 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 #removeAncestorListener
|
|
*/
|
|
static public void addAncestorListener(AncestorListener l) {
|
|
if (listenerList.getListenerCount(AncestorListener.class) == 0) {
|
|
swingListener.installListeners(EventID.ANCESTOR);
|
|
}
|
|
listenerList.add(AncestorListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#ANCESTOR ANCESTOR} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addAncestorListener
|
|
*/
|
|
static public void removeAncestorListener(AncestorListener l) {
|
|
listenerList.remove(AncestorListener.class, l);
|
|
if (listenerList.getListenerCount(AncestorListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.ANCESTOR);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#CARET CARET} 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 #removeCaretListener
|
|
*/
|
|
static public void addCaretListener(CaretListener l) {
|
|
if (listenerList.getListenerCount(CaretListener.class) == 0) {
|
|
swingListener.installListeners(EventID.CARET);
|
|
}
|
|
listenerList.add(CaretListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#CARET CARET} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addCaretListener
|
|
*/
|
|
static public void removeCaretListener(CaretListener l) {
|
|
listenerList.remove(CaretListener.class, l);
|
|
if (listenerList.getListenerCount(CaretListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.CARET);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all
|
|
* {@link EventID#CELLEDITOR CELLEDITOR} 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 #removeCellEditorListener
|
|
*/
|
|
static public void addCellEditorListener(CellEditorListener l) {
|
|
if (listenerList.getListenerCount(CellEditorListener.class) == 0) {
|
|
swingListener.installListeners(EventID.CELLEDITOR);
|
|
}
|
|
listenerList.add(CellEditorListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#CELLEDITOR CELLEDITOR} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addCellEditorListener
|
|
*/
|
|
static public void removeCellEditorListener(CellEditorListener l) {
|
|
listenerList.remove(CellEditorListener.class, l);
|
|
if (listenerList.getListenerCount(CellEditorListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.CELLEDITOR);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#CHANGE CHANGE}
|
|
* 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 #removeChangeListener
|
|
*/
|
|
static public void addChangeListener(ChangeListener l) {
|
|
if (listenerList.getListenerCount(ChangeListener.class) == 0) {
|
|
swingListener.installListeners(EventID.CHANGE);
|
|
}
|
|
listenerList.add(ChangeListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#CHANGE CHANGE} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addChangeListener
|
|
*/
|
|
static public void removeChangeListener(ChangeListener l) {
|
|
listenerList.remove(ChangeListener.class, l);
|
|
if (listenerList.getListenerCount(ChangeListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.CHANGE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#COLUMNMODEL COLUMNMODEL}
|
|
* 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 #removeColumnModelListener
|
|
*/
|
|
static public void addColumnModelListener(TableColumnModelListener l) {
|
|
if (listenerList.getListenerCount(TableColumnModelListener.class) == 0) {
|
|
swingListener.installListeners(EventID.COLUMNMODEL);
|
|
}
|
|
listenerList.add(TableColumnModelListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#COLUMNMODEL COLUMNMODEL} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addColumnModelListener
|
|
*/
|
|
static public void removeColumnModelListener(TableColumnModelListener l) {
|
|
listenerList.remove(TableColumnModelListener.class, l);
|
|
if (listenerList.getListenerCount(TableColumnModelListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.COLUMNMODEL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#DOCUMENT DOCUMENT}
|
|
* 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 #removeDocumentListener
|
|
*/
|
|
static public void addDocumentListener(DocumentListener l) {
|
|
if (listenerList.getListenerCount(DocumentListener.class) == 0) {
|
|
swingListener.installListeners(EventID.DOCUMENT);
|
|
}
|
|
listenerList.add(DocumentListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#DOCUMENT DOCUMENT} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addDocumentListener
|
|
*/
|
|
static public void removeDocumentListener(DocumentListener l) {
|
|
listenerList.remove(DocumentListener.class, l);
|
|
if (listenerList.getListenerCount(DocumentListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.DOCUMENT);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#LISTDATA LISTDATA}
|
|
* 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 #removeListDataListener
|
|
*/
|
|
static public void addListDataListener(ListDataListener l) {
|
|
if (listenerList.getListenerCount(ListDataListener.class) == 0) {
|
|
swingListener.installListeners(EventID.LISTDATA);
|
|
}
|
|
listenerList.add(ListDataListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#LISTDATA LISTDATA} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addListDataListener
|
|
*/
|
|
static public void removeListDataListener(ListDataListener l) {
|
|
listenerList.remove(ListDataListener.class, l);
|
|
if (listenerList.getListenerCount(ListDataListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.LISTDATA);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#LISTSELECTION LISTSELECTION}
|
|
* 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 #removeListSelectionListener
|
|
*/
|
|
static public void addListSelectionListener(ListSelectionListener l) {
|
|
if (listenerList.getListenerCount(ListSelectionListener.class) == 0) {
|
|
swingListener.installListeners(EventID.LISTSELECTION);
|
|
}
|
|
listenerList.add(ListSelectionListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#LISTSELECTION LISTSELECTION} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addListSelectionListener
|
|
*/
|
|
static public void removeListSelectionListener(ListSelectionListener l) {
|
|
listenerList.remove(ListSelectionListener.class, l);
|
|
if (listenerList.getListenerCount(ListSelectionListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.LISTSELECTION);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#MENU MENU} 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 #removeMenuListener
|
|
*/
|
|
static public void addMenuListener(MenuListener l) {
|
|
if (listenerList.getListenerCount(MenuListener.class) == 0) {
|
|
swingListener.installListeners(EventID.MENU);
|
|
}
|
|
listenerList.add(MenuListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#MENU MENU} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addMenuListener
|
|
*/
|
|
static public void removeMenuListener(MenuListener l) {
|
|
listenerList.remove(MenuListener.class, l);
|
|
if (listenerList.getListenerCount(MenuListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.MENU);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#POPUPMENU POPUPMENU}
|
|
* 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 #removePopupMenuListener
|
|
*/
|
|
static public void addPopupMenuListener(PopupMenuListener l) {
|
|
if (listenerList.getListenerCount(PopupMenuListener.class) == 0) {
|
|
swingListener.installListeners(EventID.POPUPMENU);
|
|
}
|
|
listenerList.add(PopupMenuListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#POPUPMENU POPUPMENU} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addPopupMenuListener
|
|
*/
|
|
static public void removePopupMenuListener(PopupMenuListener l) {
|
|
listenerList.remove(PopupMenuListener.class, l);
|
|
if (listenerList.getListenerCount(PopupMenuListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.POPUPMENU);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#TABLEMODEL TABLEMODEL}
|
|
* 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 #removeTableModelListener
|
|
*/
|
|
static public void addTableModelListener(TableModelListener l) {
|
|
if (listenerList.getListenerCount(TableModelListener.class) == 0) {
|
|
swingListener.installListeners(EventID.TABLEMODEL);
|
|
}
|
|
listenerList.add(TableModelListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#TABLEMODEL TABLEMODEL} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addTableModelListener
|
|
*/
|
|
static public void removeTableModelListener(TableModelListener l) {
|
|
listenerList.remove(TableModelListener.class, l);
|
|
if (listenerList.getListenerCount(TableModelListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.TABLEMODEL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#TREEEXPANSION TREEEXPANSION}
|
|
* 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 #removeTreeExpansionListener
|
|
*/
|
|
static public void addTreeExpansionListener(TreeExpansionListener l) {
|
|
if (listenerList.getListenerCount(TreeExpansionListener.class) == 0) {
|
|
swingListener.installListeners(EventID.TREEEXPANSION);
|
|
}
|
|
listenerList.add(TreeExpansionListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#TREEEXPANSION TREEEXPANSION} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addTreeExpansionListener
|
|
*/
|
|
static public void removeTreeExpansionListener(TreeExpansionListener l) {
|
|
listenerList.remove(TreeExpansionListener.class, l);
|
|
if (listenerList.getListenerCount(TreeExpansionListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.TREEEXPANSION);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#TREEMODEL TREEMODEL}
|
|
* 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 #removeTreeModelListener
|
|
*/
|
|
static public void addTreeModelListener(TreeModelListener l) {
|
|
if (listenerList.getListenerCount(TreeModelListener.class) == 0) {
|
|
swingListener.installListeners(EventID.TREEMODEL);
|
|
}
|
|
listenerList.add(TreeModelListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#TREEMODEL TREEMODEL} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addTreeModelListener
|
|
*/
|
|
static public void removeTreeModelListener(TreeModelListener l) {
|
|
listenerList.remove(TreeModelListener.class, l);
|
|
if (listenerList.getListenerCount(TreeModelListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.TREEMODEL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#TREESELECTION TREESELECTION}
|
|
* 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 #removeTreeSelectionListener
|
|
*/
|
|
static public void addTreeSelectionListener(TreeSelectionListener l) {
|
|
if (listenerList.getListenerCount(TreeSelectionListener.class) == 0) {
|
|
swingListener.installListeners(EventID.TREESELECTION);
|
|
}
|
|
listenerList.add(TreeSelectionListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#TREESELECTION TREESELECTION} events when they occur.
|
|
* @see #addTreeSelectionListener
|
|
* @param l the listener to remove
|
|
*/
|
|
static public void removeTreeSelectionListener(TreeSelectionListener l) {
|
|
listenerList.remove(TreeSelectionListener.class, l);
|
|
if (listenerList.getListenerCount(TreeSelectionListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.TREESELECTION);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#UNDOABLEEDIT UNDOABLEEDIT}
|
|
* 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 #removeUndoableEditListener
|
|
*/
|
|
static public void addUndoableEditListener(UndoableEditListener l) {
|
|
if (listenerList.getListenerCount(UndoableEditListener.class) == 0) {
|
|
swingListener.installListeners(EventID.UNDOABLEEDIT);
|
|
}
|
|
listenerList.add(UndoableEditListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#UNDOABLEEDIT UNDOABLEEDIT} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addUndoableEditListener
|
|
*/
|
|
static public void removeUndoableEditListener(UndoableEditListener l) {
|
|
listenerList.remove(UndoableEditListener.class, l);
|
|
if (listenerList.getListenerCount(UndoableEditListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.UNDOABLEEDIT);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#INTERNALFRAME INTERNALFRAME}
|
|
* 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 #removeInternalFrameListener
|
|
*/
|
|
static public void addInternalFrameListener(InternalFrameListener l) {
|
|
if (listenerList.getListenerCount(InternalFrameListener.class) == 0) {
|
|
swingListener.installListeners(EventID.INTERNALFRAME);
|
|
}
|
|
listenerList.add(InternalFrameListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#INTERNALFRAME INTERNALFRAME} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addInternalFrameListener
|
|
*/
|
|
static public void removeInternalFrameListener(InternalFrameListener l) {
|
|
listenerList.remove(InternalFrameListener.class, l);
|
|
if (listenerList.getListenerCount(InternalFrameListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.INTERNALFRAME);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#PROPERTYCHANGE PROPERTYCHANGE}
|
|
* 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 #removePropertyChangeListener
|
|
*/
|
|
static public void addPropertyChangeListener(PropertyChangeListener l) {
|
|
if (listenerList.getListenerCount(PropertyChangeListener.class) == 0) {
|
|
swingListener.installListeners(EventID.PROPERTYCHANGE);
|
|
}
|
|
listenerList.add(PropertyChangeListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#PROPERTYCHANGE PROPERTYCHANGE} events when they occur.
|
|
* @see #addPropertyChangeListener
|
|
* @param l the listener to remove
|
|
*/
|
|
static public void removePropertyChangeListener(PropertyChangeListener l) {
|
|
listenerList.remove(PropertyChangeListener.class, l);
|
|
if (listenerList.getListenerCount(PropertyChangeListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.PROPERTYCHANGE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the specified listener to receive all {@link EventID#VETOABLECHANGE VETOABLECHANGE}
|
|
* 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 #removeVetoableChangeListener
|
|
*/
|
|
static public void addVetoableChangeListener(VetoableChangeListener l) {
|
|
if (listenerList.getListenerCount(VetoableChangeListener.class) == 0) {
|
|
swingListener.installListeners(EventID.VETOABLECHANGE);
|
|
}
|
|
listenerList.add(VetoableChangeListener.class, l);
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener so it no longer receives
|
|
* {@link EventID#VETOABLECHANGE VETOABLECHANGE} events when they occur.
|
|
*
|
|
* @param l the listener to remove
|
|
* @see #addVetoableChangeListener
|
|
*/
|
|
static public void removeVetoableChangeListener(VetoableChangeListener l) {
|
|
listenerList.remove(VetoableChangeListener.class, l);
|
|
if (listenerList.getListenerCount(VetoableChangeListener.class) == 0) {
|
|
swingListener.removeListeners(EventID.VETOABLECHANGE);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* SwingEventListener is the class that does all the work for
|
|
* SwingEventMonitor. It is not intended for use by any other class
|
|
* except SwingEventMonitor.
|
|
*
|
|
*/
|
|
static class SwingEventListener extends AWTEventsListener
|
|
implements AncestorListener, CaretListener, CellEditorListener,
|
|
ChangeListener, DocumentListener, ListDataListener,
|
|
ListSelectionListener, MenuListener, PopupMenuListener,
|
|
TableColumnModelListener, TableModelListener, TreeExpansionListener,
|
|
TreeModelListener, TreeSelectionListener, UndoableEditListener,
|
|
InternalFrameListener,
|
|
PropertyChangeListener, VetoableChangeListener {
|
|
|
|
/**
|
|
* internal variables for Caret introspection
|
|
*/
|
|
private java.lang.Class caretListeners[];
|
|
private java.lang.reflect.Method removeCaretMethod;
|
|
private java.lang.reflect.Method addCaretMethod;
|
|
private java.lang.Object caretArgs[];
|
|
|
|
/**
|
|
* internal variables for CellEditor introspection
|
|
*/
|
|
private java.lang.Class cellEditorListeners[];
|
|
private java.lang.reflect.Method removeCellEditorMethod;
|
|
private java.lang.reflect.Method addCellEditorMethod;
|
|
private java.lang.Object cellEditorArgs[];
|
|
private java.lang.reflect.Method getCellEditorMethod;
|
|
|
|
/**
|
|
* internal variables for Change introspection
|
|
*/
|
|
private java.lang.Class changeListeners[];
|
|
private java.lang.reflect.Method removeChangeMethod;
|
|
private java.lang.reflect.Method addChangeMethod;
|
|
private java.lang.Object changeArgs[];
|
|
|
|
/**
|
|
* internal variable for ColumnModel introspection
|
|
*/
|
|
private java.lang.reflect.Method getColumnModelMethod;
|
|
|
|
/**
|
|
* internal variables for Document introspection
|
|
*/
|
|
private java.lang.Class documentListeners[];
|
|
private java.lang.reflect.Method removeDocumentMethod;
|
|
private java.lang.reflect.Method addDocumentMethod;
|
|
private java.lang.Object documentArgs[];
|
|
private java.lang.reflect.Method getDocumentMethod;
|
|
|
|
/**
|
|
* internal variable for ListData, Table, and Tree introspection
|
|
*/
|
|
private java.lang.reflect.Method getModelMethod;
|
|
|
|
/**
|
|
* internal variables for ListSelection introspection
|
|
*/
|
|
private java.lang.Class listSelectionListeners[];
|
|
private java.lang.reflect.Method removeListSelectionMethod;
|
|
private java.lang.reflect.Method addListSelectionMethod;
|
|
private java.lang.Object listSelectionArgs[];
|
|
private java.lang.reflect.Method getSelectionModelMethod;
|
|
|
|
/**
|
|
* internal variables for Menu introspection
|
|
*/
|
|
private java.lang.Class menuListeners[];
|
|
private java.lang.reflect.Method removeMenuMethod;
|
|
private java.lang.reflect.Method addMenuMethod;
|
|
private java.lang.Object menuArgs[];
|
|
|
|
/**
|
|
* internal variables for PopupMenu introspection
|
|
*/
|
|
private java.lang.Class popupMenuListeners[];
|
|
private java.lang.reflect.Method removePopupMenuMethod;
|
|
private java.lang.reflect.Method addPopupMenuMethod;
|
|
private java.lang.Object popupMenuArgs[];
|
|
private java.lang.reflect.Method getPopupMenuMethod;
|
|
|
|
/**
|
|
* internal variables for TreeExpansion introspection
|
|
*/
|
|
private java.lang.Class treeExpansionListeners[];
|
|
private java.lang.reflect.Method removeTreeExpansionMethod;
|
|
private java.lang.reflect.Method addTreeExpansionMethod;
|
|
private java.lang.Object treeExpansionArgs[];
|
|
|
|
/**
|
|
* internal variables for TreeSelection introspection
|
|
*/
|
|
private java.lang.Class treeSelectionListeners[];
|
|
private java.lang.reflect.Method removeTreeSelectionMethod;
|
|
private java.lang.reflect.Method addTreeSelectionMethod;
|
|
private java.lang.Object treeSelectionArgs[];
|
|
|
|
/**
|
|
* internal variables for UndoableEdit introspection
|
|
*/
|
|
private java.lang.Class undoableEditListeners[];
|
|
private java.lang.reflect.Method removeUndoableEditMethod;
|
|
private java.lang.reflect.Method addUndoableEditMethod;
|
|
private java.lang.Object undoableEditArgs[];
|
|
|
|
/**
|
|
* internal variables for InternalFrame introspection
|
|
*/
|
|
private java.lang.Class internalFrameListeners[];
|
|
private java.lang.reflect.Method removeInternalFrameMethod;
|
|
private java.lang.reflect.Method addInternalFrameMethod;
|
|
private java.lang.Object internalFrameArgs[];
|
|
|
|
/**
|
|
* internal variables for PropertyChange introspection
|
|
*/
|
|
private java.lang.Class propertyChangeListeners[];
|
|
private java.lang.reflect.Method removePropertyChangeMethod;
|
|
private java.lang.reflect.Method addPropertyChangeMethod;
|
|
private java.lang.Object propertyChangeArgs[];
|
|
|
|
/**
|
|
* internal variables for a variety of change introspections
|
|
*/
|
|
private java.lang.Class nullClass[];
|
|
private java.lang.Object nullArgs[];
|
|
|
|
/**
|
|
* 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 SwingEventMonitor. Also registers itself
|
|
* as a TopLevelWindowListener with EventQueueMonitor so it can
|
|
* automatically add new listeners to new components.
|
|
* @see EventQueueMonitor
|
|
* @see SwingEventMonitor
|
|
*/
|
|
public SwingEventListener() {
|
|
initializeIntrospection();
|
|
installListeners();
|
|
EventQueueMonitor.addTopLevelWindowListener(this);
|
|
}
|
|
|
|
/**
|
|
* Set up all of the variables needed for introspection
|
|
*/
|
|
private boolean initializeIntrospection() {
|
|
try {
|
|
caretListeners = new java.lang.Class[1];
|
|
caretArgs = new java.lang.Object[1];
|
|
caretListeners[0] = Class.forName("javax.swing.event.CaretListener");
|
|
caretArgs[0] = this;
|
|
|
|
cellEditorListeners = new java.lang.Class[1];
|
|
cellEditorArgs = new java.lang.Object[1];
|
|
cellEditorListeners[0] = Class.forName("javax.swing.event.CellEditorListener");
|
|
cellEditorArgs[0] = this;
|
|
|
|
changeListeners = new java.lang.Class[1];
|
|
changeArgs = new java.lang.Object[1];
|
|
changeListeners[0] = Class.forName("javax.swing.event.ChangeListener");
|
|
changeArgs[0] = this;
|
|
|
|
documentListeners = new java.lang.Class[1];
|
|
documentArgs = new java.lang.Object[1];
|
|
documentListeners[0] = Class.forName("javax.swing.event.DocumentListener");
|
|
documentArgs[0] = this;
|
|
|
|
listSelectionListeners = new java.lang.Class[1];
|
|
listSelectionArgs = new java.lang.Object[1];
|
|
listSelectionListeners[0] = Class.forName("javax.swing.event.ListSelectionListener");
|
|
listSelectionArgs[0] = this;
|
|
|
|
menuListeners = new java.lang.Class[1];
|
|
menuArgs = new java.lang.Object[1];
|
|
menuListeners[0] = Class.forName("javax.swing.event.MenuListener");
|
|
menuArgs[0] = this;
|
|
|
|
popupMenuListeners = new java.lang.Class[1];
|
|
popupMenuArgs = new java.lang.Object[1];
|
|
popupMenuListeners[0] = Class.forName("javax.swing.event.PopupMenuListener");
|
|
popupMenuArgs[0] = this;
|
|
|
|
treeExpansionListeners = new java.lang.Class[1];
|
|
treeExpansionArgs = new java.lang.Object[1];
|
|
treeExpansionListeners[0] = Class.forName("javax.swing.event.TreeExpansionListener");
|
|
treeExpansionArgs[0] = this;
|
|
|
|
treeSelectionListeners = new java.lang.Class[1];
|
|
treeSelectionArgs = new java.lang.Object[1];
|
|
treeSelectionListeners[0] = Class.forName("javax.swing.event.TreeSelectionListener");
|
|
treeSelectionArgs[0] = this;
|
|
|
|
undoableEditListeners = new java.lang.Class[1];
|
|
undoableEditArgs = new java.lang.Object[1];
|
|
undoableEditListeners[0] = Class.forName("javax.swing.event.UndoableEditListener");
|
|
undoableEditArgs[0] = this;
|
|
|
|
internalFrameListeners = new java.lang.Class[1];
|
|
internalFrameArgs = new java.lang.Object[1];
|
|
internalFrameListeners[0] = Class.forName("javax.swing.event.InternalFrameListener");
|
|
internalFrameArgs[0] = this;
|
|
|
|
nullClass = new java.lang.Class[0];
|
|
nullArgs = new java.lang.Object[0];
|
|
|
|
} catch (ClassNotFoundException e) {
|
|
System.out.println("EXCEPTION - Class 'javax.swing.event.*' not in CLASSPATH");
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
propertyChangeListeners = new java.lang.Class[1];
|
|
propertyChangeArgs = new java.lang.Object[1];
|
|
propertyChangeListeners[0] = Class.forName("java.beans.PropertyChangeListener");
|
|
propertyChangeArgs[0] = this;
|
|
|
|
} catch (ClassNotFoundException e) {
|
|
System.out.println("EXCEPTION - Class 'java.beans.*' not in CLASSPATH");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Installs all appropriate Swing listeners to just the component.
|
|
* Also calls super (AWTEventsListener.installListeners()) to install
|
|
* the requested AWT listeners.
|
|
* @param c the component to add listeners to
|
|
*/
|
|
protected void installListeners(Component c) {
|
|
|
|
// This SwingEventListener needs to be notified when a new
|
|
// Swing component has been added so it can add Swing listeners
|
|
// to these components. As a result, we always need a Container
|
|
// listener on every Container.
|
|
//
|
|
installListeners(c,EventID.CONTAINER);
|
|
|
|
// conditionally install Swing listeners
|
|
//
|
|
if (SwingEventMonitor.listenerList.getListenerCount(AncestorListener.class) > 0) {
|
|
installListeners(c,EventID.ANCESTOR);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(CaretListener.class) > 0) {
|
|
installListeners(c,EventID.CARET);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(CellEditorListener.class) > 0) {
|
|
installListeners(c,EventID.CELLEDITOR);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(ChangeListener.class) > 0) {
|
|
installListeners(c,EventID.CHANGE);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TableColumnModelListener.class) > 0) {
|
|
installListeners(c,EventID.COLUMNMODEL);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(DocumentListener.class) > 0) {
|
|
installListeners(c,EventID.DOCUMENT);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(ListDataListener.class) > 0) {
|
|
installListeners(c,EventID.LISTDATA);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(ListSelectionListener.class) > 0) {
|
|
installListeners(c,EventID.LISTSELECTION);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(MenuListener.class) > 0) {
|
|
installListeners(c,EventID.MENU);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(PopupMenuListener.class) > 0) {
|
|
installListeners(c,EventID.POPUPMENU);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TableModelListener.class) > 0) {
|
|
installListeners(c,EventID.TABLEMODEL);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TreeExpansionListener.class) > 0) {
|
|
installListeners(c,EventID.TREEEXPANSION);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TreeModelListener.class) > 0) {
|
|
installListeners(c,EventID.TREEMODEL);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TreeSelectionListener.class) > 0) {
|
|
installListeners(c,EventID.TREESELECTION);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(UndoableEditListener.class) > 0) {
|
|
installListeners(c,EventID.UNDOABLEEDIT);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(InternalFrameListener.class) > 0) {
|
|
installListeners(c,EventID.INTERNALFRAME);
|
|
}
|
|
|
|
// Conditionally install Beans listeners
|
|
//
|
|
if (SwingEventMonitor.listenerList.getListenerCount(PropertyChangeListener.class) > 0) {
|
|
installListeners(c,EventID.PROPERTYCHANGE);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(VetoableChangeListener.class) > 0) {
|
|
installListeners(c,EventID.VETOABLECHANGE);
|
|
}
|
|
|
|
// Now install the AWT listeners if needed.
|
|
//
|
|
super.installListeners(c);
|
|
}
|
|
|
|
/**
|
|
* Installs all appropriate Swing listeners to the component and all its
|
|
* children. As a precaution, it always attempts to remove itself as
|
|
* a listener first so we're always guaranteed it will installed itself
|
|
* just once.
|
|
* @param c the component to add listeners to
|
|
* @param eventID the eventID to add listeners for
|
|
*/
|
|
protected void installListeners(Component c, int eventID) {
|
|
|
|
// install the appropriate listener hook into this component
|
|
//
|
|
switch (eventID) {
|
|
|
|
case EventID.CONTAINER:
|
|
if (c instanceof Container) {
|
|
((Container) c).removeContainerListener(this);
|
|
((Container) c).addContainerListener(this);
|
|
}
|
|
break;
|
|
|
|
case EventID.ANCESTOR:
|
|
if (c instanceof JComponent) {
|
|
((JComponent) c).removeAncestorListener(this);
|
|
((JComponent) c).addAncestorListener(this);
|
|
}
|
|
break;
|
|
|
|
case EventID.CARET:
|
|
try {
|
|
removeCaretMethod = c.getClass().getMethod(
|
|
"removeCaretListener", caretListeners);
|
|
addCaretMethod = c.getClass().getMethod(
|
|
"addCaretListener", caretListeners);
|
|
try {
|
|
removeCaretMethod.invoke(c, caretArgs);
|
|
addCaretMethod.invoke(c, caretArgs);
|
|
} 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.CELLEDITOR:
|
|
// Look for components which support the getCellEditor method
|
|
// (e.g. JTable, JTree)
|
|
//
|
|
try {
|
|
getCellEditorMethod = c.getClass().getMethod(
|
|
"getCellEditorMethod", nullClass);
|
|
try {
|
|
Object o = getCellEditorMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof CellEditor) {
|
|
((CellEditor) o).removeCellEditorListener(this);
|
|
((CellEditor) o).addCellEditorListener(this);
|
|
}
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support CellEditor listeners
|
|
// (no current example)
|
|
//
|
|
try {
|
|
removeCellEditorMethod = c.getClass().getMethod(
|
|
"removeCellEditorListener", cellEditorListeners);
|
|
addCellEditorMethod = c.getClass().getMethod(
|
|
"addCellEditorListener", cellEditorListeners);
|
|
try {
|
|
removeCellEditorMethod.invoke(c, cellEditorArgs);
|
|
addCellEditorMethod.invoke(c, cellEditorArgs);
|
|
} 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.CHANGE:
|
|
// [[[FIXME: Need to add support for Style, StyleContext -pk]]]
|
|
|
|
// Look for components which support Change listeners
|
|
// (e.g. AbstractButton, Caret, JProgressBar, JSlider,
|
|
// JTabbedpane, JTextComponent, JViewport)
|
|
//
|
|
try {
|
|
removeChangeMethod = c.getClass().getMethod(
|
|
"removeChangeListener", changeListeners);
|
|
addChangeMethod = c.getClass().getMethod(
|
|
"addChangeListener", changeListeners);
|
|
try {
|
|
removeChangeMethod.invoke(c, changeArgs);
|
|
addChangeMethod.invoke(c, changeArgs);
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support the getModel method
|
|
// whose model supports Change listeners
|
|
// (e.g. BoundedRangeModel, ButtonModel, SingleSelectionModel)
|
|
//
|
|
try {
|
|
getModelMethod = c.getClass().getMethod(
|
|
"getModel", nullClass);
|
|
try {
|
|
Object o = getModelMethod.invoke(c, nullArgs);
|
|
if (o != null) {
|
|
removeChangeMethod = o.getClass().getMethod(
|
|
"removeChangeListener", changeListeners);
|
|
addChangeMethod = o.getClass().getMethod(
|
|
"addChangeListener", changeListeners);
|
|
removeChangeMethod.invoke(o, changeArgs);
|
|
addChangeMethod.invoke(o, changeArgs);
|
|
}
|
|
} 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.COLUMNMODEL:
|
|
try {
|
|
getColumnModelMethod = c.getClass().getMethod(
|
|
"getTableColumnModel", nullClass);
|
|
try {
|
|
Object o = getColumnModelMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof TableColumnModel) {
|
|
((TableColumnModel) o).removeColumnModelListener(this);
|
|
((TableColumnModel) o).addColumnModelListener(this);
|
|
}
|
|
} 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.DOCUMENT:
|
|
// Look for components which support the getDocument method
|
|
// (e.g. JTextComponent)
|
|
//
|
|
try {
|
|
getDocumentMethod = c.getClass().getMethod(
|
|
"getDocument", nullClass);
|
|
try {
|
|
Object o = getDocumentMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof Document) {
|
|
((Document) o).removeDocumentListener(this);
|
|
((Document) o).addDocumentListener(this);
|
|
}
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support Document listeners
|
|
// (no current example)
|
|
//
|
|
try {
|
|
removeDocumentMethod = c.getClass().getMethod(
|
|
"removeDocumentListener", documentListeners);
|
|
addDocumentMethod = c.getClass().getMethod(
|
|
"addDocumentListener", documentListeners);
|
|
try {
|
|
removeDocumentMethod.invoke(c, documentArgs);
|
|
addDocumentMethod.invoke(c, documentArgs);
|
|
} 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());
|
|
}
|
|
// Add the monitor as a PropertyChangeListener for document
|
|
// change events from text components.
|
|
//
|
|
if (c instanceof JTextComponent) {
|
|
try {
|
|
removePropertyChangeMethod = c.getClass().getMethod(
|
|
"removePropertyChangeListener",
|
|
propertyChangeListeners);
|
|
addPropertyChangeMethod = c.getClass().getMethod(
|
|
"addPropertyChangeListener",
|
|
propertyChangeListeners);
|
|
try {
|
|
removePropertyChangeMethod.invoke(c,
|
|
propertyChangeArgs);
|
|
addPropertyChangeMethod.invoke(c,
|
|
propertyChangeArgs);
|
|
} 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.LISTDATA:
|
|
case EventID.TABLEMODEL:
|
|
case EventID.TREEMODEL:
|
|
try {
|
|
getModelMethod = c.getClass().getMethod(
|
|
"getModel", nullClass);
|
|
try {
|
|
Object o = getModelMethod.invoke(c, nullArgs);
|
|
if (o != null) {
|
|
if (eventID == EventID.LISTDATA &&
|
|
o instanceof ListModel) {
|
|
((ListModel) o).removeListDataListener(this);
|
|
((ListModel) o).addListDataListener(this);
|
|
} else if (eventID == EventID.TABLEMODEL &&
|
|
o instanceof TableModel) {
|
|
((TableModel) o).removeTableModelListener(this);
|
|
((TableModel) o).addTableModelListener(this);
|
|
} else if (
|
|
o instanceof TreeModel) {
|
|
((TreeModel) o).removeTreeModelListener(this);
|
|
((TreeModel) o).addTreeModelListener(this);
|
|
}
|
|
}
|
|
} 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.LISTSELECTION:
|
|
// Look for components which support ListSelectionListeners
|
|
// (e.g. JList)
|
|
//
|
|
try {
|
|
removeListSelectionMethod = c.getClass().getMethod(
|
|
"removeListSelectionListener", listSelectionListeners);
|
|
addListSelectionMethod = c.getClass().getMethod(
|
|
"addListSelectionListener", listSelectionListeners);
|
|
try {
|
|
removeListSelectionMethod.invoke(c, listSelectionArgs);
|
|
addListSelectionMethod.invoke(c, listSelectionArgs);
|
|
} 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());
|
|
}
|
|
|
|
// Look for selection models which support ListSelectionListeners
|
|
// (e.g. JTable's selection model)
|
|
//
|
|
try {
|
|
getSelectionModelMethod = c.getClass().getMethod(
|
|
"getSelectionModel", nullClass);
|
|
try {
|
|
Object o = getSelectionModelMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof ListSelectionModel) {
|
|
((ListSelectionModel) o).removeListSelectionListener(this);
|
|
((ListSelectionModel) o).addListSelectionListener(this);
|
|
}
|
|
} 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.MENU:
|
|
try {
|
|
removeMenuMethod = c.getClass().getMethod(
|
|
"removeMenuListener", menuListeners);
|
|
addMenuMethod = c.getClass().getMethod(
|
|
"addMenuListener", menuListeners);
|
|
try {
|
|
removeMenuMethod.invoke(c, menuArgs);
|
|
addMenuMethod.invoke(c, menuArgs);
|
|
} 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.POPUPMENU:
|
|
// Look for components which support PopupMenuListeners
|
|
// (e.g. JPopupMenu)
|
|
//
|
|
try {
|
|
removePopupMenuMethod = c.getClass().getMethod(
|
|
"removePopupMenuListener", popupMenuListeners);
|
|
addPopupMenuMethod = c.getClass().getMethod(
|
|
"addPopupMenuListener", popupMenuListeners);
|
|
try {
|
|
removePopupMenuMethod.invoke(c, popupMenuArgs);
|
|
addPopupMenuMethod.invoke(c, popupMenuArgs);
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support getPopupMenu
|
|
// (e.g. JMenu)
|
|
//
|
|
try {
|
|
getPopupMenuMethod = c.getClass().getMethod(
|
|
"getPopupMenu", nullClass);
|
|
try {
|
|
Object o = getPopupMenuMethod.invoke(c, nullArgs);
|
|
if (o != null) {
|
|
removePopupMenuMethod = o.getClass().getMethod(
|
|
"removePopupMenuListener", popupMenuListeners);
|
|
addPopupMenuMethod = o.getClass().getMethod(
|
|
"addPopupMenuListener", popupMenuListeners);
|
|
removePopupMenuMethod.invoke(o, popupMenuArgs);
|
|
addPopupMenuMethod.invoke(o, popupMenuArgs);
|
|
}
|
|
} 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.TREEEXPANSION:
|
|
try {
|
|
removeTreeExpansionMethod = c.getClass().getMethod(
|
|
"removeTreeExpansionListener", treeExpansionListeners);
|
|
addTreeExpansionMethod = c.getClass().getMethod(
|
|
"addTreeExpansionListener", treeExpansionListeners);
|
|
try {
|
|
removeTreeExpansionMethod.invoke(c, treeExpansionArgs);
|
|
addTreeExpansionMethod.invoke(c, treeExpansionArgs);
|
|
} 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.TREESELECTION:
|
|
try {
|
|
removeTreeSelectionMethod = c.getClass().getMethod(
|
|
"removeTreeSelectionListener", treeSelectionListeners);
|
|
addTreeSelectionMethod = c.getClass().getMethod(
|
|
"addTreeSelectionListener", treeSelectionListeners);
|
|
try {
|
|
removeTreeSelectionMethod.invoke(c, treeSelectionArgs);
|
|
addTreeSelectionMethod.invoke(c, treeSelectionArgs);
|
|
} 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.UNDOABLEEDIT:
|
|
// Look for components which support the getDocument method
|
|
// (e.g. JTextComponent)
|
|
//
|
|
try {
|
|
getDocumentMethod = c.getClass().getMethod(
|
|
"getDocument", nullClass);
|
|
try {
|
|
Object o = getDocumentMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof Document) {
|
|
((Document) o).removeUndoableEditListener(this);
|
|
((Document) o).addUndoableEditListener(this);
|
|
}
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support UndoableEdit listeners
|
|
// (no current example)
|
|
//
|
|
try {
|
|
removeUndoableEditMethod = c.getClass().getMethod(
|
|
"removeUndoableEditListener", undoableEditListeners);
|
|
addUndoableEditMethod = c.getClass().getMethod(
|
|
"addUndoableEditListener", undoableEditListeners);
|
|
try {
|
|
removeUndoableEditMethod.invoke(c, undoableEditArgs);
|
|
addUndoableEditMethod.invoke(c, undoableEditArgs);
|
|
} 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.INTERNALFRAME:
|
|
// Look for components which support InternalFrame listeners
|
|
// (e.g. JInternalFrame)
|
|
//
|
|
try {
|
|
removeInternalFrameMethod = c.getClass().getMethod(
|
|
"removeInternalFrameListener", internalFrameListeners);
|
|
addInternalFrameMethod = c.getClass().getMethod(
|
|
"addInternalFrameListener", internalFrameListeners);
|
|
try {
|
|
removeInternalFrameMethod.invoke(c, internalFrameArgs);
|
|
addInternalFrameMethod.invoke(c, internalFrameArgs);
|
|
} 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.PROPERTYCHANGE:
|
|
// Look for components which support PropertyChange listeners
|
|
// (e.g. JComponent)
|
|
//
|
|
try {
|
|
removePropertyChangeMethod = c.getClass().getMethod(
|
|
"removePropertyChangeListener", propertyChangeListeners);
|
|
addPropertyChangeMethod = c.getClass().getMethod(
|
|
"addPropertyChangeListener", propertyChangeListeners);
|
|
try {
|
|
removePropertyChangeMethod.invoke(c, propertyChangeArgs);
|
|
addPropertyChangeMethod.invoke(c, propertyChangeArgs);
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support the getSelectionModel method
|
|
// (e.g. JTextComponent)
|
|
//
|
|
try {
|
|
getSelectionModelMethod = c.getClass().getMethod(
|
|
"getSelectionModel", nullClass);
|
|
try {
|
|
Object o = getSelectionModelMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof TreeSelectionModel) {
|
|
((TreeSelectionModel) o).removePropertyChangeListener(this);
|
|
((TreeSelectionModel) o).addPropertyChangeListener(this);
|
|
}
|
|
} 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.VETOABLECHANGE:
|
|
if (c instanceof JComponent) {
|
|
((JComponent) c).removeVetoableChangeListener(this);
|
|
((JComponent) c).addVetoableChangeListener(this);
|
|
}
|
|
break;
|
|
|
|
// Don't bother recursing the children if this isn't going to
|
|
// accomplish anything.
|
|
//
|
|
default:
|
|
return;
|
|
}
|
|
|
|
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 component and all its children.
|
|
* @param c the component
|
|
*/
|
|
protected void removeListeners(Component c) {
|
|
|
|
// conditionaly remove the Swing listeners
|
|
//
|
|
if (SwingEventMonitor.listenerList.getListenerCount(AncestorListener.class) > 0) {
|
|
removeListeners(c,EventID.ANCESTOR);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(CaretListener.class) > 0) {
|
|
removeListeners(c,EventID.CARET);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(CellEditorListener.class) > 0) {
|
|
removeListeners(c,EventID.CELLEDITOR);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(ChangeListener.class) > 0) {
|
|
removeListeners(c,EventID.CHANGE);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TableColumnModelListener.class) > 0) {
|
|
removeListeners(c,EventID.COLUMNMODEL);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(DocumentListener.class) > 0) {
|
|
removeListeners(c,EventID.DOCUMENT);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(ListDataListener.class) > 0) {
|
|
removeListeners(c,EventID.LISTDATA);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(ListSelectionListener.class) > 0) {
|
|
removeListeners(c,EventID.LISTSELECTION);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(MenuListener.class) > 0) {
|
|
removeListeners(c,EventID.MENU);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(PopupMenuListener.class) > 0) {
|
|
removeListeners(c,EventID.POPUPMENU);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TableModelListener.class) > 0) {
|
|
removeListeners(c,EventID.TABLEMODEL);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TreeExpansionListener.class) > 0) {
|
|
removeListeners(c,EventID.TREEEXPANSION);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TreeModelListener.class) > 0) {
|
|
removeListeners(c,EventID.TREEMODEL);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(TreeSelectionListener.class) > 0) {
|
|
removeListeners(c,EventID.TREESELECTION);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(UndoableEditListener.class) > 0) {
|
|
removeListeners(c,EventID.UNDOABLEEDIT);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(InternalFrameListener.class) > 0) {
|
|
removeListeners(c,EventID.INTERNALFRAME);
|
|
}
|
|
|
|
// conditionaly remove the beans listeners
|
|
//
|
|
if (SwingEventMonitor.listenerList.getListenerCount(PropertyChangeListener.class) > 0) {
|
|
removeListeners(c,EventID.PROPERTYCHANGE);
|
|
}
|
|
if (SwingEventMonitor.listenerList.getListenerCount(VetoableChangeListener.class) > 0) {
|
|
removeListeners(c,EventID.VETOABLECHANGE);
|
|
}
|
|
|
|
// Now remove the AWT listeners if needed.
|
|
//
|
|
super.removeListeners(c);
|
|
}
|
|
|
|
/**
|
|
* Removes all Swing listeners for the event ID from the component and
|
|
* all of its children.
|
|
* @param c the component to remove listeners from
|
|
*/
|
|
protected void removeListeners(Component c, int eventID) {
|
|
|
|
// remove the appropriate listener hook into this component
|
|
//
|
|
switch (eventID) {
|
|
|
|
case EventID.CONTAINER:
|
|
//Never remove these because we're always interested in them
|
|
// for our own use.
|
|
break;
|
|
|
|
case EventID.ANCESTOR:
|
|
if (c instanceof JComponent) {
|
|
((JComponent) c).removeAncestorListener(this);
|
|
}
|
|
break;
|
|
|
|
case EventID.CARET:
|
|
try {
|
|
removeCaretMethod = c.getClass().getMethod(
|
|
"removeCaretListener", caretListeners);
|
|
try {
|
|
removeCaretMethod.invoke(c, caretArgs);
|
|
} 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.CELLEDITOR:
|
|
// Look for components which support the getCellEditor method
|
|
// (e.g. JTable, JTree)
|
|
//
|
|
try {
|
|
getCellEditorMethod = c.getClass().getMethod(
|
|
"getCellEditorMethod", nullClass);
|
|
try {
|
|
Object o = getCellEditorMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof CellEditor) {
|
|
((CellEditor) o).removeCellEditorListener(this);
|
|
}
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support CellEditor listeners
|
|
// (no current example)
|
|
//
|
|
try {
|
|
removeCellEditorMethod = c.getClass().getMethod(
|
|
"removeCellEditorListener", cellEditorListeners);
|
|
try {
|
|
removeCellEditorMethod.invoke(c, cellEditorArgs);
|
|
} 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.CHANGE:
|
|
// [[[FIXME: Need to add support for Style, StyleContext -pk ]]]
|
|
|
|
// Look for components which support Change listeners
|
|
// (e.g. AbstractButton, Caret, JProgressBar, JSlider,
|
|
// JTabbedpane, JTextComponent, JViewport)
|
|
//
|
|
try {
|
|
removeChangeMethod = c.getClass().getMethod(
|
|
"removeChangeListener", changeListeners);
|
|
try {
|
|
removeChangeMethod.invoke(c, changeArgs);
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support the getModel method
|
|
// whose model supports Change listeners
|
|
// (e.g. BoundedRangeModel, ButtonModel, SingleSelectionModel)
|
|
//
|
|
try {
|
|
getModelMethod = c.getClass().getMethod(
|
|
"getModel", nullClass);
|
|
try {
|
|
Object o = getModelMethod.invoke(c, nullArgs);
|
|
if (o != null) {
|
|
removeChangeMethod = o.getClass().getMethod(
|
|
"removeChangeListener", changeListeners);
|
|
removeChangeMethod.invoke(o, changeArgs);
|
|
}
|
|
} 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.COLUMNMODEL:
|
|
try {
|
|
getColumnModelMethod = c.getClass().getMethod(
|
|
"getTableColumnModel", nullClass);
|
|
try {
|
|
Object o = getColumnModelMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof TableColumnModel) {
|
|
((TableColumnModel) o).removeColumnModelListener(this);
|
|
}
|
|
} 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.DOCUMENT:
|
|
// Look for components which support the getDocument method
|
|
// (e.g. JTextComponent)
|
|
//
|
|
try {
|
|
getDocumentMethod = c.getClass().getMethod(
|
|
"getDocument", nullClass);
|
|
try {
|
|
Object o = getDocumentMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof Document) {
|
|
((Document) o).removeDocumentListener(this);
|
|
}
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support Document listeners
|
|
// (no current example)
|
|
//
|
|
try {
|
|
removeDocumentMethod = c.getClass().getMethod(
|
|
"removeDocumentListener", documentListeners);
|
|
try {
|
|
removeDocumentMethod.invoke(c, documentArgs);
|
|
} 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.LISTDATA:
|
|
case EventID.TABLEMODEL:
|
|
case EventID.TREEMODEL:
|
|
try {
|
|
getModelMethod = c.getClass().getMethod(
|
|
"getModel", nullClass);
|
|
try {
|
|
Object o = getModelMethod.invoke(c, nullArgs);
|
|
if (o != null) {
|
|
if (eventID == EventID.LISTDATA &&
|
|
o instanceof ListModel) {
|
|
((ListModel) o).removeListDataListener(this);
|
|
} else if (eventID == EventID.TABLEMODEL &&
|
|
o instanceof TableModel) {
|
|
((TableModel) o).removeTableModelListener(this);
|
|
} else if (
|
|
o instanceof TreeModel) {
|
|
((TreeModel) o).removeTreeModelListener(this);
|
|
}
|
|
}
|
|
} 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.LISTSELECTION:
|
|
// Look for components which support ListSelectionListeners
|
|
// (e.g. JList)
|
|
//
|
|
try {
|
|
removeListSelectionMethod = c.getClass().getMethod(
|
|
"removeListSelectionListener", listSelectionListeners);
|
|
try {
|
|
removeListSelectionMethod.invoke(c, listSelectionArgs);
|
|
} 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());
|
|
}
|
|
|
|
// Look for selection models which support
|
|
// ListSelectionListeners (e.g. JTable's selection model)
|
|
//
|
|
try {
|
|
getSelectionModelMethod = c.getClass().getMethod(
|
|
"getSelectionModel", nullClass);
|
|
try {
|
|
Object o = getSelectionModelMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof ListSelectionModel) {
|
|
((ListSelectionModel) o).removeListSelectionListener(this);
|
|
}
|
|
} 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.MENU:
|
|
try {
|
|
removeMenuMethod = c.getClass().getMethod(
|
|
"removeMenuListener", menuListeners);
|
|
try {
|
|
removeMenuMethod.invoke(c, menuArgs);
|
|
} 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.POPUPMENU:
|
|
// Look for components which support PopupMenuListeners
|
|
// (e.g. JPopupMenu)
|
|
//
|
|
try {
|
|
removePopupMenuMethod = c.getClass().getMethod(
|
|
"removePopupMenuListener", popupMenuListeners);
|
|
try {
|
|
removePopupMenuMethod.invoke(c, popupMenuArgs);
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support getPopupMenu
|
|
// (e.g. JMenu)
|
|
//
|
|
try {
|
|
getPopupMenuMethod = c.getClass().getMethod(
|
|
"getPopupMenu", nullClass);
|
|
try {
|
|
Object o = getPopupMenuMethod.invoke(c, nullArgs);
|
|
if (o != null) {
|
|
removePopupMenuMethod = o.getClass().getMethod(
|
|
"removePopupMenuListener", popupMenuListeners);
|
|
removePopupMenuMethod.invoke(o, popupMenuArgs);
|
|
}
|
|
} 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.TREEEXPANSION:
|
|
try {
|
|
removeTreeExpansionMethod = c.getClass().getMethod(
|
|
"removeTreeExpansionListener", treeExpansionListeners);
|
|
try {
|
|
removeTreeExpansionMethod.invoke(c, treeExpansionArgs);
|
|
} 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.TREESELECTION:
|
|
try {
|
|
removeTreeSelectionMethod = c.getClass().getMethod(
|
|
"removeTreeSelectionListener", treeSelectionListeners);
|
|
try {
|
|
removeTreeSelectionMethod.invoke(c, treeSelectionArgs);
|
|
} 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.UNDOABLEEDIT:
|
|
// Look for components which support the getDocument method
|
|
// (e.g. JTextComponent)
|
|
//
|
|
try {
|
|
getDocumentMethod = c.getClass().getMethod(
|
|
"getDocument", nullClass);
|
|
try {
|
|
Object o = getDocumentMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof Document) {
|
|
((Document) o).removeUndoableEditListener(this);
|
|
}
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support UndoableEdit listeners
|
|
// (no current example)
|
|
//
|
|
try {
|
|
removeUndoableEditMethod = c.getClass().getMethod(
|
|
"removeUndoableEditListener", undoableEditListeners);
|
|
try {
|
|
removeUndoableEditMethod.invoke(c, undoableEditArgs);
|
|
} 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.INTERNALFRAME:
|
|
try {
|
|
removeInternalFrameMethod = c.getClass().getMethod(
|
|
"removeInternalFrameListener", internalFrameListeners);
|
|
try {
|
|
removeInternalFrameMethod.invoke(c, internalFrameArgs);
|
|
} 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.PROPERTYCHANGE:
|
|
// Look for components which support PropertyChange listeners
|
|
// (e.g. JComponent)
|
|
//
|
|
try {
|
|
removePropertyChangeMethod = c.getClass().getMethod(
|
|
"removePropertyChangeListener", propertyChangeListeners);
|
|
try {
|
|
removePropertyChangeMethod.invoke(c, propertyChangeArgs);
|
|
} 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());
|
|
}
|
|
|
|
// Look for components which support the getSelectionModel
|
|
// method (e.g. JTextComponent)
|
|
//
|
|
try {
|
|
getSelectionModelMethod = c.getClass().getMethod(
|
|
"getSelectionModel", nullClass);
|
|
try {
|
|
Object o = getSelectionModelMethod.invoke(c, nullArgs);
|
|
if (o != null && o instanceof TreeSelectionModel) {
|
|
((TreeSelectionModel) o).removePropertyChangeListener(this);
|
|
}
|
|
} 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.VETOABLECHANGE:
|
|
if (c instanceof JComponent) {
|
|
((JComponent) c).removeVetoableChangeListener(this);
|
|
}
|
|
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 */
|
|
/* */
|
|
/********************************************************************/
|
|
|
|
/* ContainerListener Methods ************************************/
|
|
|
|
public void componentAdded(ContainerEvent e) {
|
|
installListeners(e.getChild());
|
|
}
|
|
public void componentRemoved(ContainerEvent e) {
|
|
removeListeners(e.getChild());
|
|
}
|
|
|
|
/* AncestorListener Methods ******************************************/
|
|
|
|
public void ancestorAdded(AncestorEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==AncestorListener.class) {
|
|
((AncestorListener)listeners[i+1]).ancestorAdded(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ancestorRemoved(AncestorEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==AncestorListener.class) {
|
|
((AncestorListener)listeners[i+1]).ancestorRemoved(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ancestorMoved(AncestorEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==AncestorListener.class) {
|
|
((AncestorListener)listeners[i+1]).ancestorMoved(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* CaretListener Methods ******************************************/
|
|
|
|
public void caretUpdate(CaretEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==CaretListener.class) {
|
|
((CaretListener)listeners[i+1]).caretUpdate(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* CellEditorListener Methods *****************************************/
|
|
|
|
public void editingStopped(ChangeEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==CellEditorListener.class) {
|
|
((CellEditorListener)listeners[i+1]).editingStopped(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void editingCanceled(ChangeEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==CellEditorListener.class) {
|
|
((CellEditorListener)listeners[i+1]).editingCanceled(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ChangeListener Methods *****************************************/
|
|
|
|
public void stateChanged(ChangeEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==ChangeListener.class) {
|
|
((ChangeListener)listeners[i+1]).stateChanged(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* TableColumnModelListener Methods *******************************/
|
|
|
|
public void columnAdded(TableColumnModelEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TableColumnModelListener.class) {
|
|
((TableColumnModelListener)listeners[i+1]).columnAdded(e);
|
|
}
|
|
}
|
|
}
|
|
public void columnMarginChanged(ChangeEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TableColumnModelListener.class) {
|
|
((TableColumnModelListener)listeners[i+1]).columnMarginChanged(e);
|
|
}
|
|
}
|
|
}
|
|
public void columnMoved(TableColumnModelEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TableColumnModelListener.class) {
|
|
((TableColumnModelListener)listeners[i+1]).columnMoved(e);
|
|
}
|
|
}
|
|
}
|
|
public void columnRemoved(TableColumnModelEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TableColumnModelListener.class) {
|
|
((TableColumnModelListener)listeners[i+1]).columnRemoved(e);
|
|
}
|
|
}
|
|
}
|
|
public void columnSelectionChanged(ListSelectionEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TableColumnModelListener.class) {
|
|
((TableColumnModelListener)listeners[i+1]).columnSelectionChanged(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* DocumentListener Methods **************************************/
|
|
|
|
public void changedUpdate(DocumentEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==DocumentListener.class) {
|
|
((DocumentListener)listeners[i+1]).changedUpdate(e);
|
|
}
|
|
}
|
|
}
|
|
public void insertUpdate(DocumentEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==DocumentListener.class) {
|
|
((DocumentListener)listeners[i+1]).insertUpdate(e);
|
|
}
|
|
}
|
|
}
|
|
public void removeUpdate(DocumentEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==DocumentListener.class) {
|
|
((DocumentListener)listeners[i+1]).removeUpdate(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ListDataListener Methods *****************************************/
|
|
|
|
public void contentsChanged(ListDataEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==ListDataListener.class) {
|
|
((ListDataListener)listeners[i+1]).contentsChanged(e);
|
|
}
|
|
}
|
|
}
|
|
public void intervalAdded(ListDataEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==ListDataListener.class) {
|
|
((ListDataListener)listeners[i+1]).intervalAdded(e);
|
|
}
|
|
}
|
|
}
|
|
public void intervalRemoved(ListDataEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==ListDataListener.class) {
|
|
((ListDataListener)listeners[i+1]).intervalRemoved(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ListSelectionListener Methods ***********************************/
|
|
|
|
public void valueChanged(ListSelectionEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==ListSelectionListener.class) {
|
|
((ListSelectionListener)listeners[i+1]).valueChanged(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* MenuListener Methods *****************************************/
|
|
|
|
public void menuCanceled(MenuEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==MenuListener.class) {
|
|
((MenuListener)listeners[i+1]).menuCanceled(e);
|
|
}
|
|
}
|
|
}
|
|
public void menuDeselected(MenuEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==MenuListener.class) {
|
|
((MenuListener)listeners[i+1]).menuDeselected(e);
|
|
}
|
|
}
|
|
}
|
|
public void menuSelected(MenuEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==MenuListener.class) {
|
|
((MenuListener)listeners[i+1]).menuSelected(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* PopupMenuListener Methods **************************************/
|
|
|
|
public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==PopupMenuListener.class) {
|
|
((PopupMenuListener)listeners[i+1]).popupMenuWillBecomeVisible(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==PopupMenuListener.class) {
|
|
((PopupMenuListener)listeners[i+1]).popupMenuWillBecomeInvisible(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void popupMenuCanceled(PopupMenuEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==PopupMenuListener.class) {
|
|
((PopupMenuListener)listeners[i+1]).popupMenuCanceled(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* TableModelListener Methods **************************************/
|
|
|
|
public void tableChanged(TableModelEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TableModelListener.class) {
|
|
((TableModelListener)listeners[i+1]).tableChanged(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* TreeExpansionListener Methods **********************************/
|
|
|
|
public void treeCollapsed(TreeExpansionEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TreeExpansionListener.class) {
|
|
((TreeExpansionListener)listeners[i+1]).treeCollapsed(e);
|
|
}
|
|
}
|
|
}
|
|
public void treeExpanded(TreeExpansionEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TreeExpansionListener.class) {
|
|
((TreeExpansionListener)listeners[i+1]).treeExpanded(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* TreeModelListener Methods **********************************/
|
|
|
|
public void treeNodesChanged(TreeModelEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TreeModelListener.class) {
|
|
((TreeModelListener)listeners[i+1]).treeNodesChanged(e);
|
|
}
|
|
}
|
|
}
|
|
public void treeNodesInserted(TreeModelEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TreeModelListener.class) {
|
|
((TreeModelListener)listeners[i+1]).treeNodesInserted(e);
|
|
}
|
|
}
|
|
}
|
|
public void treeNodesRemoved(TreeModelEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TreeModelListener.class) {
|
|
((TreeModelListener)listeners[i+1]).treeNodesRemoved(e);
|
|
}
|
|
}
|
|
}
|
|
public void treeStructureChanged(TreeModelEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TreeModelListener.class) {
|
|
((TreeModelListener)listeners[i+1]).treeStructureChanged(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* TreeSelectionListener Methods ***********************************/
|
|
|
|
public void valueChanged(TreeSelectionEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==TreeSelectionListener.class) {
|
|
((TreeSelectionListener)listeners[i+1]).valueChanged(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* UndoableEditListener Methods **************************************/
|
|
|
|
public void undoableEditHappened(UndoableEditEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==UndoableEditListener.class) {
|
|
((UndoableEditListener)listeners[i+1]).undoableEditHappened(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* InternalFrame Methods **********************************/
|
|
|
|
public void internalFrameOpened(InternalFrameEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==InternalFrameListener.class) {
|
|
((InternalFrameListener)listeners[i+1]).internalFrameOpened(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void internalFrameActivated(InternalFrameEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==InternalFrameListener.class) {
|
|
((InternalFrameListener)listeners[i+1]).internalFrameActivated(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void internalFrameDeactivated(InternalFrameEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==InternalFrameListener.class) {
|
|
((InternalFrameListener)listeners[i+1]).internalFrameDeactivated(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void internalFrameIconified(InternalFrameEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==InternalFrameListener.class) {
|
|
((InternalFrameListener)listeners[i+1]).internalFrameIconified(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void internalFrameDeiconified(InternalFrameEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==InternalFrameListener.class) {
|
|
((InternalFrameListener)listeners[i+1]).internalFrameDeiconified(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void internalFrameClosing(InternalFrameEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==InternalFrameListener.class) {
|
|
((InternalFrameListener)listeners[i+1]).internalFrameClosing(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void internalFrameClosed(InternalFrameEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==InternalFrameListener.class) {
|
|
((InternalFrameListener)listeners[i+1]).internalFrameClosed(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* PropertyChangeListener Methods **********************************/
|
|
|
|
public void propertyChange(PropertyChangeEvent e) {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==PropertyChangeListener.class) {
|
|
((PropertyChangeListener)listeners[i+1]).propertyChange(e);
|
|
}
|
|
}
|
|
// Re-add the monitor as a DocumentChangeListener if
|
|
// the document changed in the text component.
|
|
if (e.getSource() instanceof JTextComponent) {
|
|
Document c = ((JTextComponent)e.getSource()).getDocument();
|
|
if (c == null) {
|
|
return;
|
|
}
|
|
try {
|
|
removeDocumentMethod = c.getClass().getMethod(
|
|
"removeDocumentListener", documentListeners);
|
|
addDocumentMethod = c.getClass().getMethod(
|
|
"addDocumentListener", documentListeners);
|
|
try {
|
|
removeDocumentMethod.invoke(c, documentArgs);
|
|
addDocumentMethod.invoke(c, documentArgs);
|
|
} catch (java.lang.reflect.InvocationTargetException e2) {
|
|
System.out.println("Exception: " + e2.toString());
|
|
} catch (IllegalAccessException e2) {
|
|
System.out.println("Exception: " + e2.toString());
|
|
}
|
|
} catch (NoSuchMethodException e2) {
|
|
// System.out.println("Exception: " + e2.toString());
|
|
} catch (SecurityException e2) {
|
|
System.out.println("Exception: " + e2.toString());
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* VetoableChangeListener Methods **********************************/
|
|
|
|
public void vetoableChange(PropertyChangeEvent e)
|
|
throws PropertyVetoException {
|
|
Object[] listeners = SwingEventMonitor.listenerList.getListenerList();
|
|
for (int i = listeners.length-2; i>=0; i-=2) {
|
|
if (listeners[i]==VetoableChangeListener.class) {
|
|
((VetoableChangeListener)listeners[i+1]).vetoableChange(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|