/*

 * Copyright (c) 2002, 2016, 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

 *

 */

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 private 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