/*

 * Copyright (c) 1996, 2014, 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 java.awt;

import java.awt.event.*;

import java.lang.reflect.Array;

import java.util.EventListener;

import java.io.Serializable;

import java.io.ObjectOutputStream;

import java.io.IOException;

import java.util.EventListener;

/**

 * {@code AWTEventMulticaster} implements efficient and thread-safe multi-cast

 * event dispatching for the AWT events defined in the {@code java.awt.event}

 * package.

 * <p>

 * The following example illustrates how to use this class:

 *

 * <pre><code>

 * public myComponent extends Component {

 *     ActionListener actionListener = null;

 *

 *     public synchronized void addActionListener(ActionListener l) {

 *         actionListener = AWTEventMulticaster.add(actionListener, l);

 *     }

 *     public synchronized void removeActionListener(ActionListener l) {

 *         actionListener = AWTEventMulticaster.remove(actionListener, l);

 *     }

 *     public void processEvent(AWTEvent e) {

 *         // when event occurs which causes "action" semantic

 *         ActionListener listener = actionListener;

 *         if (listener != null) {

 *             listener.actionPerformed(new ActionEvent());

 *         }

 *     }

 * }

 * </code></pre>

 * The important point to note is the first argument to the {@code

 * add} and {@code remove} methods is the field maintaining the

 * listeners. In addition you must assign the result of the {@code add}

 * and {@code remove} methods to the field maintaining the listeners.

 * <p>

 * {@code AWTEventMulticaster} is implemented as a pair of {@code

 * EventListeners} that are set at construction time. {@code

 * AWTEventMulticaster} is immutable. The {@code add} and {@code

 * remove} methods do not alter {@code AWTEventMulticaster} in

 * anyway. If necessary, a new {@code AWTEventMulticaster} is

 * created. In this way it is safe to add and remove listeners during

 * the process of an event dispatching.  However, event listeners

 * added during the process of an event dispatch operation are not

 * notified of the event currently being dispatched.

 * <p>

 * All of the {@code add} methods allow {@code null} arguments. If the

 * first argument is {@code null}, the second argument is returned. If

 * the first argument is not {@code null} and the second argument is

 * {@code null}, the first argument is returned. If both arguments are

 * {@code non-null}, a new {@code AWTEventMulticaster} is created using

 * the two arguments and returned.

 * <p>

 * For the {@code remove} methods that take two arguments, the following is

 * returned:

 * <ul>

 *   <li>{@code null}, if the first argument is {@code null}, or

 *       the arguments are equal, by way of {@code ==}.

 *   <li>the first argument, if the first argument is not an instance of

 *       {@code AWTEventMulticaster}.

 *   <li>result of invoking {@code remove(EventListener)} on the

 *       first argument, supplying the second argument to the

 *       {@code remove(EventListener)} method.

 * </ul>

 * <p>Swing makes use of

 * {@link javax.swing.event.EventListenerList EventListenerList} for

 * similar logic. Refer to it for details.

 *

 * @see javax.swing.event.EventListenerList

 *

 * @author      John Rose

 * @author      Amy Fowler

 * @since       1.1

 */

public class AWTEventMulticaster implements

    ComponentListener, ContainerListener, FocusListener, KeyListener,

    MouseListener, MouseMotionListener, WindowListener, WindowFocusListener,

    WindowStateListener, ActionListener, ItemListener, AdjustmentListener,

    TextListener, InputMethodListener, HierarchyListener,

    HierarchyBoundsListener, MouseWheelListener {

    protected final EventListener a, b;

    /**

     * Creates an event multicaster instance which chains listener-a

     * with listener-b. Input parameters <code>a</code> and <code>b</code>

     * should not be <code>null</code>, though implementations may vary in

     * choosing whether or not to throw <code>NullPointerException</code>

     * in that case.

     * @param a listener-a

     * @param b listener-b

     */

    protected AWTEventMulticaster(EventListener a, EventListener b) {

        this.a = a; this.b = b;

    }

    /**

     * Removes a listener from this multicaster.

     * <p>

     * The returned multicaster contains all the listeners in this

     * multicaster with the exception of all occurrences of {@code oldl}.

     * If the resulting multicaster contains only one regular listener

     * the regular listener may be returned.  If the resulting multicaster

     * is empty, then {@code null} may be returned instead.

     * <p>

     * No exception is thrown if {@code oldl} is {@code null}.

     *

     * @param oldl the listener to be removed

     * @return resulting listener

     */

    protected EventListener remove(EventListener oldl) {

        if (oldl == a)  return b;

        if (oldl == b)  return a;

        EventListener a2 = removeInternal(a, oldl);

        EventListener b2 = removeInternal(b, oldl);

        if (a2 == a && b2 == b) {

            return this;        // it's not here

        }

        return addInternal(a2, b2);

    }

    /**

     * Handles the componentResized event by invoking the

     * componentResized methods on listener-a and listener-b.

     * @param e the component event

     */

    public void componentResized(ComponentEvent e) {

        ((ComponentListener)a).componentResized(e);

        ((ComponentListener)b).componentResized(e);

    }

    /**

     * Handles the componentMoved event by invoking the

     * componentMoved methods on listener-a and listener-b.

     * @param e the component event

     */

    public void componentMoved(ComponentEvent e) {

        ((ComponentListener)a).componentMoved(e);

        ((ComponentListener)b).componentMoved(e);

    }

    /**

     * Handles the componentShown event by invoking the

     * componentShown methods on listener-a and listener-b.

     * @param e the component event

     */

    public void componentShown(ComponentEvent e) {

        ((ComponentListener)a).componentShown(e);

        ((ComponentListener)b).componentShown(e);

    }

    /**

     * Handles the componentHidden event by invoking the

     * componentHidden methods on listener-a and listener-b.

     * @param e the component event

     */

    public void componentHidden(ComponentEvent e) {

        ((ComponentListener)a).componentHidden(e);

        ((ComponentListener)b).componentHidden(e);

    }

    /**

     * Handles the componentAdded container event by invoking the

     * componentAdded methods on listener-a and listener-b.

     * @param e the component event

     */

    public void componentAdded(ContainerEvent e) {

        ((ContainerListener)a).componentAdded(e);

        ((ContainerListener)b).componentAdded(e);

    }

    /**

     * Handles the componentRemoved container event by invoking the

     * componentRemoved methods on listener-a and listener-b.

     * @param e the component event

     */

    public void componentRemoved(ContainerEvent e) {

        ((ContainerListener)a).componentRemoved(e);

        ((ContainerListener)b).componentRemoved(e);

    }

    /**

     * Handles the focusGained event by invoking the

     * focusGained methods on listener-a and listener-b.

     * @param e the focus event

     */

    public void focusGained(FocusEvent e) {

        ((FocusListener)a).focusGained(e);

        ((FocusListener)b).focusGained(e);

    }

    /**

     * Handles the focusLost event by invoking the

     * focusLost methods on listener-a and listener-b.

     * @param e the focus event

     */

    public void focusLost(FocusEvent e) {

        ((FocusListener)a).focusLost(e);

        ((FocusListener)b).focusLost(e);

    }

    /**

     * Handles the keyTyped event by invoking the

     * keyTyped methods on listener-a and listener-b.

     * @param e the key event

     */

    public void keyTyped(KeyEvent e) {

        ((KeyListener)a).keyTyped(e);

        ((KeyListener)b).keyTyped(e);

    }

    /**

     * Handles the keyPressed event by invoking the

     * keyPressed methods on listener-a and listener-b.

     * @param e the key event

     */

    public void keyPressed(KeyEvent e) {

        ((KeyListener)a).keyPressed(e);

        ((KeyListener)b).keyPressed(e);

    }

    /**

     * Handles the keyReleased event by invoking the

     * keyReleased methods on listener-a and listener-b.

     * @param e the key event

     */

    public void keyReleased(KeyEvent e) {

        ((KeyListener)a).keyReleased(e);

        ((KeyListener)b).keyReleased(e);

    }

    /**

     * Handles the mouseClicked event by invoking the

     * mouseClicked methods on listener-a and listener-b.

     * @param e the mouse event

     */

    public void mouseClicked(MouseEvent e) {

        ((MouseListener)a).mouseClicked(e);

        ((MouseListener)b).mouseClicked(e);

    }

    /**

     * Handles the mousePressed event by invoking the

     * mousePressed methods on listener-a and listener-b.

     * @param e the mouse event

     */

    public void mousePressed(MouseEvent e) {

        ((MouseListener)a).mousePressed(e);

        ((MouseListener)b).mousePressed(e);

    }

    /**

     * Handles the mouseReleased event by invoking the

     * mouseReleased methods on listener-a and listener-b.

     * @param e the mouse event

     */

    public void mouseReleased(MouseEvent e) {

        ((MouseListener)a).mouseReleased(e);

        ((MouseListener)b).mouseReleased(e);

    }

    /**

     * Handles the mouseEntered event by invoking the

     * mouseEntered methods on listener-a and listener-b.

     * @param e the mouse event

     */

    public void mouseEntered(MouseEvent e) {

        ((MouseListener)a).mouseEntered(e);

        ((MouseListener)b).mouseEntered(e);

    }

    /**

     * Handles the mouseExited event by invoking the

     * mouseExited methods on listener-a and listener-b.

     * @param e the mouse event

     */

    public void mouseExited(MouseEvent e) {

        ((MouseListener)a).mouseExited(e);

        ((MouseListener)b).mouseExited(e);

    }

    /**

     * Handles the mouseDragged event by invoking the

     * mouseDragged methods on listener-a and listener-b.

     * @param e the mouse event

     */

    public void mouseDragged(MouseEvent e) {

        ((MouseMotionListener)a).mouseDragged(e);

        ((MouseMotionListener)b).mouseDragged(e);

    }

    /**

     * Handles the mouseMoved event by invoking the

     * mouseMoved methods on listener-a and listener-b.

     * @param e the mouse event

     */

    public void mouseMoved(MouseEvent e) {

        ((MouseMotionListener)a).mouseMoved(e);

        ((MouseMotionListener)b).mouseMoved(e);

    }

    /**

     * Handles the windowOpened event by invoking the

     * windowOpened methods on listener-a and listener-b.

     * @param e the window event

     */

    public void windowOpened(WindowEvent e) {

        ((WindowListener)a).windowOpened(e);

        ((WindowListener)b).windowOpened(e);

    }

    /**

     * Handles the windowClosing event by invoking the

     * windowClosing methods on listener-a and listener-b.

     * @param e the window event

     */

    public void windowClosing(WindowEvent e) {

        ((WindowListener)a).windowClosing(e);

        ((WindowListener)b).windowClosing(e);

    }

    /**

     * Handles the windowClosed event by invoking the

     * windowClosed methods on listener-a and listener-b.

     * @param e the window event

     */

    public void windowClosed(WindowEvent e) {

        ((WindowListener)a).windowClosed(e);

        ((WindowListener)b).windowClosed(e);

    }

    /**

     * Handles the windowIconified event by invoking the

     * windowIconified methods on listener-a and listener-b.

     * @param e the window event

     */

    public void windowIconified(WindowEvent e) {

        ((WindowListener)a).windowIconified(e);

        ((WindowListener)b).windowIconified(e);

    }

    /**

     * Handles the windowDeiconfied event by invoking the

     * windowDeiconified methods on listener-a and listener-b.

     * @param e the window event

     */

    public void windowDeiconified(WindowEvent e) {

        ((WindowListener)a).windowDeiconified(e);

        ((WindowListener)b).windowDeiconified(e);

    }

    /**

     * Handles the windowActivated event by invoking the

     * windowActivated methods on listener-a and listener-b.

     * @param e the window event

     */

    public void windowActivated(WindowEvent e) {

        ((WindowListener)a).windowActivated(e);

        ((WindowListener)b).windowActivated(e);

    }

    /**

     * Handles the windowDeactivated event by invoking the

     * windowDeactivated methods on listener-a and listener-b.

     * @param e the window event

     */

    public void windowDeactivated(WindowEvent e) {

        ((WindowListener)a).windowDeactivated(e);

        ((WindowListener)b).windowDeactivated(e);

    }

    /**

     * Handles the windowStateChanged event by invoking the

     * windowStateChanged methods on listener-a and listener-b.

     * @param e the window event

     * @since 1.4

     */

    public void windowStateChanged(WindowEvent e) {

        ((WindowStateListener)a).windowStateChanged(e);

        ((WindowStateListener)b).windowStateChanged(e);

    }

    /**

     * Handles the windowGainedFocus event by invoking the windowGainedFocus

     * methods on listener-a and listener-b.

     * @param e the window event

     * @since 1.4

     */

    public void windowGainedFocus(WindowEvent e) {

        ((WindowFocusListener)a).windowGainedFocus(e);

        ((WindowFocusListener)b).windowGainedFocus(e);

    }

    /**

     * Handles the windowLostFocus event by invoking the windowLostFocus

     * methods on listener-a and listener-b.

     * @param e the window event

     * @since 1.4

     */

    public void windowLostFocus(WindowEvent e) {

        ((WindowFocusListener)a).windowLostFocus(e);

        ((WindowFocusListener)b).windowLostFocus(e);

    }

    /**

     * Handles the actionPerformed event by invoking the

     * actionPerformed methods on listener-a and listener-b.

     * @param e the action event

     */

    public void actionPerformed(ActionEvent e) {

        ((ActionListener)a).actionPerformed(e);

        ((ActionListener)b).actionPerformed(e);

    }

    /**

     * Handles the itemStateChanged event by invoking the

     * itemStateChanged methods on listener-a and listener-b.

     * @param e the item event

     */

    public void itemStateChanged(ItemEvent e) {

        ((ItemListener)a).itemStateChanged(e);

        ((ItemListener)b).itemStateChanged(e);

    }

    /**

     * Handles the adjustmentValueChanged event by invoking the

     * adjustmentValueChanged methods on listener-a and listener-b.

     * @param e the adjustment event

     */

    public void adjustmentValueChanged(AdjustmentEvent e) {

        ((AdjustmentListener)a).adjustmentValueChanged(e);

        ((AdjustmentListener)b).adjustmentValueChanged(e);

    }

    public void textValueChanged(TextEvent e) {

        ((TextListener)a).textValueChanged(e);

        ((TextListener)b).textValueChanged(e);

    }

    /**

     * Handles the inputMethodTextChanged event by invoking the

     * inputMethodTextChanged methods on listener-a and listener-b.

     * @param e the item event

     */

    public void inputMethodTextChanged(InputMethodEvent e) {

       ((InputMethodListener)a).inputMethodTextChanged(e);

       ((InputMethodListener)b).inputMethodTextChanged(e);

    }

    /**

     * Handles the caretPositionChanged event by invoking the

     * caretPositionChanged methods on listener-a and listener-b.

     * @param e the item event

     */

    public void caretPositionChanged(InputMethodEvent e) {

       ((InputMethodListener)a).caretPositionChanged(e);

       ((InputMethodListener)b).caretPositionChanged(e);

    }

    /**

     * Handles the hierarchyChanged event by invoking the

     * hierarchyChanged methods on listener-a and listener-b.

     * @param e the item event

     * @since 1.3

     */

    public void hierarchyChanged(HierarchyEvent e) {

        ((HierarchyListener)a).hierarchyChanged(e);

        ((HierarchyListener)b).hierarchyChanged(e);

    }

    /**

     * Handles the ancestorMoved event by invoking the

     * ancestorMoved methods on listener-a and listener-b.

     * @param e the item event

     * @since 1.3

     */

    public void ancestorMoved(HierarchyEvent e) {

        ((HierarchyBoundsListener)a).ancestorMoved(e);

        ((HierarchyBoundsListener)b).ancestorMoved(e);

    }

    /**

     * Handles the ancestorResized event by invoking the

     * ancestorResized methods on listener-a and listener-b.

     * @param e the item event

     * @since 1.3

     */

    public void ancestorResized(HierarchyEvent e) {

        ((HierarchyBoundsListener)a).ancestorResized(e);

        ((HierarchyBoundsListener)b).ancestorResized(e);

    }

    /**

     * Handles the mouseWheelMoved event by invoking the

     * mouseWheelMoved methods on listener-a and listener-b.

     * @param e the mouse event

     * @since 1.4