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