/*

 * 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.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;

import sun.awt.AWTPermissions;

/**

 * <P>The {@code AWTEventMonitor} implements a suite of listeners that are

 * conditionally installed on every AWT component instance in the Java

 * Virtual Machine.  The events captured by these listeners are made

 * available through a unified set of listeners supported by {@code AWTEventMonitor}.

 * With this, all the individual events on each of the AWT component

 * instances are funneled into one set of listeners broken down by category

 * (see {@link EventID} for the categories).

 * <p>This class depends upon {@link EventQueueMonitor}, which provides the base

 * level support for capturing the top-level containers as they are created.

 */

public class AWTEventMonitor {

    /**

     * The current component with keyboard focus.

     *

     * @see #getComponentWithFocus

     *

     * @deprecated This field is unused; to get the component with focus use the

     * getComponentWithFocus method.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected Component componentWithFocus = null;

    static private Component componentWithFocus_private = null;

    // Low-level listeners

    /**

     * The current list of registered ComponentListener classes.

     *

     * @see #addComponentListener

     * @see #removeComponentListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected ComponentListener     componentListener     = null;

    static private ComponentListener componentListener_private = null;

    /**

     * The current list of registered ContainerListener classes.

     *

     * @see #addContainerListener

     * @see #removeContainerListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected ContainerListener     containerListener     = null;

    static private ContainerListener containerListener_private = null;

    /**

     * The current list of registered FocusListener classes.

     *

     * @see #addFocusListener

     * @see #removeFocusListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected FocusListener         focusListener         = null;

    static private FocusListener focusListener_private = null;

    /**

     * The current list of registered KeyListener classes.

     *

     * @see #addKeyListener

     * @see #removeKeyListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected KeyListener           keyListener           = null;

    static private KeyListener keyListener_private = null;

    /**

     * The current list of registered MouseListener classes.

     *

     * @see #addMouseListener

     * @see #removeMouseListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected MouseListener         mouseListener         = null;

    static private MouseListener mouseListener_private = null;

    /**

     * The current list of registered MouseMotionListener classes.

     *

     * @see #addMouseMotionListener

     * @see #removeMouseMotionListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected MouseMotionListener   mouseMotionListener   = null;

    static private MouseMotionListener mouseMotionListener_private = null;

    /**

     * The current list of registered WindowListener classes.

     *

     * @see #addWindowListener

     * @see #removeWindowListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected WindowListener        windowListener        = null;

    static private WindowListener windowListener_private = null;

    // Semantic listeners

    /**

     * The current list of registered ActionListener classes.

     *

     * @see #addActionListener

     * @see #removeActionListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected ActionListener        actionListener        = null;

    static private ActionListener actionListener_private = null;

    /**

     * The current list of registered AdjustmentListener classes.

     *

     * @see #addAdjustmentListener

     * @see #removeAdjustmentListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected AdjustmentListener    adjustmentListener    = null;

    static private AdjustmentListener adjustmentListener_private = null;

    /**

     * The current list of registered ItemListener classes.

     *

     * @see #addItemListener

     * @see #removeItemListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected ItemListener          itemListener          = null;

    static private ItemListener itemListener_private = null;

    /**

     * The current list of registered TextListener classes.

     *

     * @see #addTextListener

     * @see #removeTextListener

     *

     * @deprecated This field is unused.

     */

    @Deprecated(since="8", forRemoval=true)

    static protected TextListener          textListener          = null;

    static private TextListener textListener_private = null;

    /**

     * The actual listener that is installed on the component instances.

     * This listener calls the other registered listeners when an event

     * occurs.  By doing things this way, the actual number of listeners

     * installed on a component instance is drastically reduced.

     */

    static private final AWTEventsListener awtListener = new AWTEventsListener();

    /**

     * Returns the component that currently has keyboard focus.  The return

     * value can be null.

     *

     * @return the component that has keyboard focus

     */

    static public Component getComponentWithFocus() {

        return componentWithFocus_private;

    }

    /*

     * Check permissions

     */

    static private void checkInstallPermission() {

        SecurityManager security = System.getSecurityManager();

        if (security != null) {

            security.checkPermission(AWTPermissions.ALL_AWT_EVENTS_PERMISSION);

        }

    }

    /**

     * Adds the specified listener to receive all {@link EventID#COMPONENT COMPONENT}

     * events on each component instance in the Java Virtual Machine as they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeComponentListener

     */

    static public void addComponentListener(ComponentListener l) {

        if (componentListener_private == null) {

            checkInstallPermission();

            awtListener.installListeners(EventID.COMPONENT);

        }

        componentListener_private = AWTEventMulticaster.add(componentListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives

     * {@link EventID#COMPONENT COMPONENT} events when they occur.

     *

     * @param l the listener to remove

     * @see #addComponentListener

     */

    static public void removeComponentListener(ComponentListener l) {

        componentListener_private = AWTEventMulticaster.remove(componentListener_private, l);

        if (componentListener_private == null) {

            awtListener.removeListeners(EventID.COMPONENT);

        }

    }

    /**

     * Adds the specified listener to receive all {@link EventID#CONTAINER CONTAINER}

     * events on each component instance in the Java Virtual Machine as they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeContainerListener

     */

    static public void addContainerListener(ContainerListener l) {

        containerListener_private = AWTEventMulticaster.add(containerListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives

     * {@link EventID#CONTAINER CONTAINER} events when they occur.

     *

     * @param l the listener to remove

     * @see #addContainerListener

     */

    static public void removeContainerListener(ContainerListener l) {

        containerListener_private = AWTEventMulticaster.remove(containerListener_private, l);

    }

    /**

     * Adds the specified listener to receive all {@link EventID#FOCUS FOCUS} events

     * on each component instance in the Java Virtual Machine when they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeFocusListener

     */

    static public void addFocusListener(FocusListener l) {

        focusListener_private = AWTEventMulticaster.add(focusListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives {@link EventID#FOCUS FOCUS}

     * events when they occur.

     *

     * @param l the listener to remove

     * @see #addFocusListener

     */

    static public void removeFocusListener(FocusListener l) {

        focusListener_private = AWTEventMulticaster.remove(focusListener_private, l);

    }

    /**

     * Adds the specified listener to receive all {@link EventID#KEY KEY} events on each

     * component instance in the Java Virtual Machine when they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeKeyListener

     */

    static public void addKeyListener(KeyListener l) {

        if (keyListener_private == null) {

            checkInstallPermission();

            awtListener.installListeners(EventID.KEY);

        }

        keyListener_private = AWTEventMulticaster.add(keyListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives {@link EventID#KEY KEY}

     * events when they occur.

     *

     * @param l the listener to remove

     * @see #addKeyListener

     */

    static public void removeKeyListener(KeyListener l) {

        keyListener_private = AWTEventMulticaster.remove(keyListener_private, l);

        if (keyListener_private == null)  {

            awtListener.removeListeners(EventID.KEY);

        }

    }

    /**

     * Adds the specified listener to receive all {@link EventID#MOUSE MOUSE} events

     * on each component instance in the Java Virtual Machine when they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeMouseListener

     */

    static public void addMouseListener(MouseListener l) {

        if (mouseListener_private == null) {

            checkInstallPermission();

            awtListener.installListeners(EventID.MOUSE);

        }

        mouseListener_private = AWTEventMulticaster.add(mouseListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives

     * {@link EventID#MOUSE MOUSE} events when they occur.

     *

     * @param l the listener to remove

     * @see #addMouseListener

     */

    static public void removeMouseListener(MouseListener l) {

        mouseListener_private = AWTEventMulticaster.remove(mouseListener_private, l);

        if (mouseListener_private == null) {

            awtListener.removeListeners(EventID.MOUSE);

        }

    }

    /**

     * Adds the specified listener to receive all mouse {@link EventID#MOTION MOTION}

     * events on each component instance in the Java Virtual Machine when they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeMouseMotionListener

     */

    static public void addMouseMotionListener(MouseMotionListener l) {

        if (mouseMotionListener_private == null) {

            checkInstallPermission();

            awtListener.installListeners(EventID.MOTION);

        }

        mouseMotionListener_private = AWTEventMulticaster.add(mouseMotionListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives

     * {@link EventID#MOTION MOTION} events when they occur.

     *

     * @param l the listener to remove

     * @see #addMouseMotionListener

     */

    static public void removeMouseMotionListener(MouseMotionListener l) {

        mouseMotionListener_private = AWTEventMulticaster.remove(mouseMotionListener_private, l);

        if (mouseMotionListener_private == null) {

            awtListener.removeListeners(EventID.MOTION);

        }

    }

    /**

     * Adds the specified listener to receive all {@link EventID#WINDOW WINDOW}

     * events on each component instance in the Java Virtual Machine when they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeWindowListener

     */

    static public void addWindowListener(WindowListener l) {

        if (windowListener_private == null) {

            checkInstallPermission();

            awtListener.installListeners(EventID.WINDOW);

        }

        windowListener_private = AWTEventMulticaster.add(windowListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives

     * {@link EventID#WINDOW WINDOW} events when they occur.

     *

     * @param l the listener to remove

     * @see #addWindowListener

     */

    static public void removeWindowListener(WindowListener l) {

        windowListener_private = AWTEventMulticaster.remove(windowListener_private, l);

        if (windowListener_private == null) {

            awtListener.removeListeners(EventID.WINDOW);

        }

    }

    /**

     * Adds the specified listener to receive all {@link EventID#ACTION ACTION}

     * events on each component instance in the Java Virtual Machine when they occur.

     * <P>Note: This listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeActionListener

     */

    static public void addActionListener(ActionListener l) {

        if (actionListener_private == null) {

            checkInstallPermission();

            awtListener.installListeners(EventID.ACTION);

        }

        actionListener_private = AWTEventMulticaster.add(actionListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives

     * {@link EventID#ACTION ACTION} events when they occur.

     *

     * @param l the listener to remove

     * @see #addActionListener

     */

    static public void removeActionListener(ActionListener l) {

        actionListener_private = AWTEventMulticaster.remove(actionListener_private, l);

        if (actionListener_private == null) {

            awtListener.removeListeners(EventID.ACTION);

        }

    }

    /**

     * Adds the specified listener to receive all

     * {@link EventID#ADJUSTMENT ADJUSTMENT} events on each component instance

     * in the Java Virtual Machine when they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeAdjustmentListener

     */

    static public void addAdjustmentListener(AdjustmentListener l) {

        if (adjustmentListener_private == null) {

            checkInstallPermission();

            awtListener.installListeners(EventID.ADJUSTMENT);

        }

        adjustmentListener_private = AWTEventMulticaster.add(adjustmentListener_private, l);

    }

    /**

     * Removes the specified listener so it no longer receives

     * {@link EventID#ADJUSTMENT ADJUSTMENT} events when they occur.

     *

     * @param l the listener to remove

     * @see #addAdjustmentListener

     */

    static public void removeAdjustmentListener(AdjustmentListener l) {

        adjustmentListener_private = AWTEventMulticaster.remove(adjustmentListener_private, l);

        if (adjustmentListener_private == null) {

            awtListener.removeListeners(EventID.ADJUSTMENT);

        }

    }

    /**

     * Adds the specified listener to receive all {@link EventID#ITEM ITEM} events

     * on each component instance in the Java Virtual Machine when they occur.

     * <P>Note: this listener is automatically added to all component

     * instances created after this method is called.  In addition, it

     * is only added to component instances that support this listener type.

     *

     * @param l the listener to add

     * @see #removeItemListener

     */

    static public void addItemListener(ItemListener l) {

        if (itemListener_private == null) {

            checkInstallPermission();