/*
 * Copyright (c) 1996, 2013, 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;


AWTEventMulticaster implements efficient and thread-safe multi-cast event dispatching for the AWT events defined in the java.awt.event package.

The following example illustrates how to use this class:


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());
        }
    }
}
The important point to note is the first argument to the add and remove methods is the field maintaining the listeners. In addition you must assign the result of the add and remove methods to the field maintaining the listeners.

AWTEventMulticaster is implemented as a pair of EventListeners that are set at construction time. AWTEventMulticaster is immutable. The add and remove methods do not alter AWTEventMulticaster in anyway. If necessary, a new 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.

All of the add methods allow null arguments. If the first argument is null, the second argument is returned. If the first argument is not null and the second argument is null, the first argument is returned. If both arguments are non-null, a new AWTEventMulticaster is created using the two arguments and returned.

For the remove methods that take two arguments, the following is returned:

  • null, if the first argument is null, or the arguments are equal, by way of ==.
  • the first argument, if the first argument is not an instance of AWTEventMulticaster.
  • result of invoking remove(EventListener) on the first argument, supplying the second argument to the remove(EventListener) method.

Swing makes use of EventListenerList for similar logic. Refer to it for details.

Author: John Rose, Amy Fowler
See Also:
Since: 1.1
/** * {@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 a and b should not be null, though implementations may vary in choosing whether or not to throw NullPointerException in that case.
Params:
  • a – listener-a
  • b – listener-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.

The returned multicaster contains all the listeners in this multicaster with the exception of all occurrences of oldl. If the resulting multicaster contains only one regular listener the regular listener may be returned. If the resulting multicaster is empty, then null may be returned instead.

No exception is thrown if oldl is null.

Params:
  • oldl – the listener to be removed
Returns:resulting listener
/** * 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.
Params:
  • e – the component event
/** * 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.
Params:
  • e – the component event
/** * 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.
Params:
  • e – the component event
/** * 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.
Params:
  • e – the component event
/** * 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.
Params:
  • e – the component event
/** * 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.
Params:
  • e – the component event
/** * 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.
Params:
  • e – the focus event
/** * 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.
Params:
  • e – the focus event
/** * 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.
Params:
  • e – the key event
/** * 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.
Params:
  • e – the key event
/** * 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.
Params:
  • e – the key event
/** * 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.
Params:
  • e – the mouse event
/** * 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.
Params:
  • e – the mouse event
/** * 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.
Params:
  • e – the mouse event
/** * 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.
Params:
  • e – the mouse event
/** * 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.
Params:
  • e – the mouse event
/** * 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.
Params:
  • e – the mouse event
/** * 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.
Params:
  • e – the mouse event
/** * 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.
Params:
  • e – the window event
/** * 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.
Params:
  • e – the window event
/** * 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.
Params:
  • e – the window event
/** * 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.
Params:
  • e – the window event
/** * 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.
Params:
  • e – the window event
/** * 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.
Params:
  • e – the window event
/** * 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.
Params:
  • e – the window event
/** * 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.
Params:
  • e – the window event
Since:1.4
/** * 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.
Params:
  • e – the window event
Since:1.4
/** * 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.
Params:
  • e – the window event
Since:1.4
/** * 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.
Params:
  • e – the action event
/** * 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.
Params:
  • e – the item event
/** * 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.
Params:
  • e – the adjustment event
/** * 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.
Params:
  • e – the item event
/** * 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.
Params:
  • e – the item event
/** * 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.
Params:
  • e – the item event
Since:1.3
/** * 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.
Params:
  • e – the item event
Since:1.3
/** * 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.
Params:
  • e – the item event
Since:1.3
/** * 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.
Params:
  • e – the mouse event
Since:1.4
/** * Handles the mouseWheelMoved event by invoking the * mouseWheelMoved methods on listener-a and listener-b. * @param e the mouse event * @since 1.4 */
public void mouseWheelMoved(MouseWheelEvent e) { ((MouseWheelListener)a).mouseWheelMoved(e); ((MouseWheelListener)b).mouseWheelMoved(e); }
Adds component-listener-a with component-listener-b and returns the resulting multicast listener.
Params:
  • a – component-listener-a
  • b – component-listener-b
/** * Adds component-listener-a with component-listener-b and * returns the resulting multicast listener. * @param a component-listener-a * @param b component-listener-b */
public static ComponentListener add(ComponentListener a, ComponentListener b) { return (ComponentListener)addInternal(a, b); }
Adds container-listener-a with container-listener-b and returns the resulting multicast listener.
Params:
  • a – container-listener-a
  • b – container-listener-b
/** * Adds container-listener-a with container-listener-b and * returns the resulting multicast listener. * @param a container-listener-a * @param b container-listener-b */
public static ContainerListener add(ContainerListener a, ContainerListener b) { return (ContainerListener)addInternal(a, b); }
Adds focus-listener-a with focus-listener-b and returns the resulting multicast listener.
Params:
  • a – focus-listener-a
  • b – focus-listener-b
/** * Adds focus-listener-a with focus-listener-b and * returns the resulting multicast listener. * @param a focus-listener-a * @param b focus-listener-b */
public static FocusListener add(FocusListener a, FocusListener b) { return (FocusListener)addInternal(a, b); }
Adds key-listener-a with key-listener-b and returns the resulting multicast listener.
Params:
  • a – key-listener-a
  • b – key-listener-b
/** * Adds key-listener-a with key-listener-b and * returns the resulting multicast listener. * @param a key-listener-a * @param b key-listener-b */
public static KeyListener add(KeyListener a, KeyListener b) { return (KeyListener)addInternal(a, b); }
Adds mouse-listener-a with mouse-listener-b and returns the resulting multicast listener.
Params:
  • a – mouse-listener-a
  • b – mouse-listener-b
/** * Adds mouse-listener-a with mouse-listener-b and * returns the resulting multicast listener. * @param a mouse-listener-a * @param b mouse-listener-b */
public static MouseListener add(MouseListener a, MouseListener b) { return (MouseListener)addInternal(a, b); }
Adds mouse-motion-listener-a with mouse-motion-listener-b and returns the resulting multicast listener.
Params:
  • a – mouse-motion-listener-a
  • b – mouse-motion-listener-b
/** * Adds mouse-motion-listener-a with mouse-motion-listener-b and * returns the resulting multicast listener. * @param a mouse-motion-listener-a * @param b mouse-motion-listener-b */
public static MouseMotionListener add(MouseMotionListener a, MouseMotionListener b) { return (MouseMotionListener)addInternal(a, b); }
Adds window-listener-a with window-listener-b and returns the resulting multicast listener.
Params:
  • a – window-listener-a
  • b – window-listener-b
/** * Adds window-listener-a with window-listener-b and * returns the resulting multicast listener. * @param a window-listener-a * @param b window-listener-b */
public static WindowListener add(WindowListener a, WindowListener b) { return (WindowListener)addInternal(a, b); }
Adds window-state-listener-a with window-state-listener-b and returns the resulting multicast listener.
Params:
  • a – window-state-listener-a
  • b – window-state-listener-b
Since:1.4
/** * Adds window-state-listener-a with window-state-listener-b * and returns the resulting multicast listener. * @param a window-state-listener-a * @param b window-state-listener-b * @since 1.4 */
public static WindowStateListener add(WindowStateListener a, WindowStateListener b) { return (WindowStateListener)addInternal(a, b); }
Adds window-focus-listener-a with window-focus-listener-b and returns the resulting multicast listener.
Params:
  • a – window-focus-listener-a
  • b – window-focus-listener-b
Since:1.4
/** * Adds window-focus-listener-a with window-focus-listener-b * and returns the resulting multicast listener. * @param a window-focus-listener-a * @param b window-focus-listener-b * @since 1.4 */
public static WindowFocusListener add(WindowFocusListener a, WindowFocusListener b) { return (WindowFocusListener)addInternal(a, b); }
Adds action-listener-a with action-listener-b and returns the resulting multicast listener.
Params:
  • a – action-listener-a
  • b – action-listener-b
/** * Adds action-listener-a with action-listener-b and * returns the resulting multicast listener. * @param a action-listener-a * @param b action-listener-b */
public static ActionListener add(ActionListener a, ActionListener b) { return (ActionListener)addInternal(a, b); }
Adds item-listener-a with item-listener-b and returns the resulting multicast listener.
Params:
  • a – item-listener-a
  • b – item-listener-b
/** * Adds item-listener-a with item-listener-b and * returns the resulting multicast listener. * @param a item-listener-a * @param b item-listener-b */
public static ItemListener add(ItemListener a, ItemListener b) { return (ItemListener)addInternal(a, b); }
Adds adjustment-listener-a with adjustment-listener-b and returns the resulting multicast listener.
Params:
  • a – adjustment-listener-a
  • b – adjustment-listener-b
/** * Adds adjustment-listener-a with adjustment-listener-b and * returns the resulting multicast listener. * @param a adjustment-listener-a * @param b adjustment-listener-b */
public static AdjustmentListener add(AdjustmentListener a, AdjustmentListener b) { return (AdjustmentListener)addInternal(a, b); } public static TextListener add(TextListener a, TextListener b) { return (TextListener)addInternal(a, b); }
Adds input-method-listener-a with input-method-listener-b and returns the resulting multicast listener.
Params:
  • a – input-method-listener-a
  • b – input-method-listener-b
/** * Adds input-method-listener-a with input-method-listener-b and * returns the resulting multicast listener. * @param a input-method-listener-a * @param b input-method-listener-b */
public static InputMethodListener add(InputMethodListener a, InputMethodListener b) { return (InputMethodListener)addInternal(a, b); }
Adds hierarchy-listener-a with hierarchy-listener-b and returns the resulting multicast listener.
Params:
  • a – hierarchy-listener-a
  • b – hierarchy-listener-b
Since:1.3
/** * Adds hierarchy-listener-a with hierarchy-listener-b and * returns the resulting multicast listener. * @param a hierarchy-listener-a * @param b hierarchy-listener-b * @since 1.3 */
public static HierarchyListener add(HierarchyListener a, HierarchyListener b) { return (HierarchyListener)addInternal(a, b); }
Adds hierarchy-bounds-listener-a with hierarchy-bounds-listener-b and returns the resulting multicast listener.
Params:
  • a – hierarchy-bounds-listener-a
  • b – hierarchy-bounds-listener-b
Since:1.3
/** * Adds hierarchy-bounds-listener-a with hierarchy-bounds-listener-b and * returns the resulting multicast listener. * @param a hierarchy-bounds-listener-a * @param b hierarchy-bounds-listener-b * @since 1.3 */
public static HierarchyBoundsListener add(HierarchyBoundsListener a, HierarchyBoundsListener b) { return (HierarchyBoundsListener)addInternal(a, b); }
Adds mouse-wheel-listener-a with mouse-wheel-listener-b and returns the resulting multicast listener.
Params:
  • a – mouse-wheel-listener-a
  • b – mouse-wheel-listener-b
Since:1.4
/** * Adds mouse-wheel-listener-a with mouse-wheel-listener-b and * returns the resulting multicast listener. * @param a mouse-wheel-listener-a * @param b mouse-wheel-listener-b * @since 1.4 */
public static MouseWheelListener add(MouseWheelListener a, MouseWheelListener b) { return (MouseWheelListener)addInternal(a, b); }
Removes the old component-listener from component-listener-l and returns the resulting multicast listener.
Params:
  • l – component-listener-l
  • oldl – the component-listener being removed
/** * Removes the old component-listener from component-listener-l and * returns the resulting multicast listener. * @param l component-listener-l * @param oldl the component-listener being removed */
public static ComponentListener remove(ComponentListener l, ComponentListener oldl) { return (ComponentListener) removeInternal(l, oldl); }
Removes the old container-listener from container-listener-l and returns the resulting multicast listener.
Params:
  • l – container-listener-l
  • oldl – the container-listener being removed
/** * Removes the old container-listener from container-listener-l and * returns the resulting multicast listener. * @param l container-listener-l * @param oldl the container-listener being removed */
public static ContainerListener remove(ContainerListener l, ContainerListener oldl) { return (ContainerListener) removeInternal(l, oldl); }
Removes the old focus-listener from focus-listener-l and returns the resulting multicast listener.
Params:
  • l – focus-listener-l
  • oldl – the focus-listener being removed
/** * Removes the old focus-listener from focus-listener-l and * returns the resulting multicast listener. * @param l focus-listener-l * @param oldl the focus-listener being removed */
public static FocusListener remove(FocusListener l, FocusListener oldl) { return (FocusListener) removeInternal(l, oldl); }
Removes the old key-listener from key-listener-l and returns the resulting multicast listener.
Params:
  • l – key-listener-l
  • oldl – the key-listener being removed
/** * Removes the old key-listener from key-listener-l and * returns the resulting multicast listener. * @param l key-listener-l * @param oldl the key-listener being removed */
public static KeyListener remove(KeyListener l, KeyListener oldl) { return (KeyListener) removeInternal(l, oldl); }
Removes the old mouse-listener from mouse-listener-l and returns the resulting multicast listener.
Params:
  • l – mouse-listener-l
  • oldl – the mouse-listener being removed
/** * Removes the old mouse-listener from mouse-listener-l and * returns the resulting multicast listener. * @param l mouse-listener-l * @param oldl the mouse-listener being removed */
public static MouseListener remove(MouseListener l, MouseListener oldl) { return (MouseListener) removeInternal(l, oldl); }
Removes the old mouse-motion-listener from mouse-motion-listener-l and returns the resulting multicast listener.
Params:
  • l – mouse-motion-listener-l
  • oldl – the mouse-motion-listener being removed
/** * Removes the old mouse-motion-listener from mouse-motion-listener-l * and returns the resulting multicast listener. * @param l mouse-motion-listener-l * @param oldl the mouse-motion-listener being removed */
public static MouseMotionListener remove(MouseMotionListener l, MouseMotionListener oldl) { return (MouseMotionListener) removeInternal(l, oldl); }
Removes the old window-listener from window-listener-l and returns the resulting multicast listener.
Params:
  • l – window-listener-l
  • oldl – the window-listener being removed
/** * Removes the old window-listener from window-listener-l and * returns the resulting multicast listener. * @param l window-listener-l * @param oldl the window-listener being removed */
public static WindowListener remove(WindowListener l, WindowListener oldl) { return (WindowListener) removeInternal(l, oldl); }
Removes the old window-state-listener from window-state-listener-l and returns the resulting multicast listener.
Params:
  • l – window-state-listener-l
  • oldl – the window-state-listener being removed
Since:1.4
/** * Removes the old window-state-listener from window-state-listener-l * and returns the resulting multicast listener. * @param l window-state-listener-l * @param oldl the window-state-listener being removed * @since 1.4 */
public static WindowStateListener remove(WindowStateListener l, WindowStateListener oldl) { return (WindowStateListener) removeInternal(l, oldl); }
Removes the old window-focus-listener from window-focus-listener-l and returns the resulting multicast listener.
Params:
  • l – window-focus-listener-l
  • oldl – the window-focus-listener being removed
Since:1.4
/** * Removes the old window-focus-listener from window-focus-listener-l * and returns the resulting multicast listener. * @param l window-focus-listener-l * @param oldl the window-focus-listener being removed * @since 1.4 */
public static WindowFocusListener remove(WindowFocusListener l, WindowFocusListener oldl) { return (WindowFocusListener) removeInternal(l, oldl); }
Removes the old action-listener from action-listener-l and returns the resulting multicast listener.
Params:
  • l – action-listener-l
  • oldl – the action-listener being removed
/** * Removes the old action-listener from action-listener-l and * returns the resulting multicast listener. * @param l action-listener-l * @param oldl the action-listener being removed */
public static ActionListener remove(ActionListener l, ActionListener oldl) { return (ActionListener) removeInternal(l, oldl); }
Removes the old item-listener from item-listener-l and returns the resulting multicast listener.
Params:
  • l – item-listener-l
  • oldl – the item-listener being removed
/** * Removes the old item-listener from item-listener-l and * returns the resulting multicast listener. * @param l item-listener-l * @param oldl the item-listener being removed */
public static ItemListener remove(ItemListener l, ItemListener oldl) { return (ItemListener) removeInternal(l, oldl); }
Removes the old adjustment-listener from adjustment-listener-l and returns the resulting multicast listener.
Params:
  • l – adjustment-listener-l
  • oldl – the adjustment-listener being removed
/** * Removes the old adjustment-listener from adjustment-listener-l and * returns the resulting multicast listener. * @param l adjustment-listener-l * @param oldl the adjustment-listener being removed */
public static AdjustmentListener remove(AdjustmentListener l, AdjustmentListener oldl) { return (AdjustmentListener) removeInternal(l, oldl); } public static TextListener remove(TextListener l, TextListener oldl) { return (TextListener) removeInternal(l, oldl); }
Removes the old input-method-listener from input-method-listener-l and returns the resulting multicast listener.
Params:
  • l – input-method-listener-l
  • oldl – the input-method-listener being removed
/** * Removes the old input-method-listener from input-method-listener-l and * returns the resulting multicast listener. * @param l input-method-listener-l * @param oldl the input-method-listener being removed */
public static InputMethodListener remove(InputMethodListener l, InputMethodListener oldl) { return (InputMethodListener) removeInternal(l, oldl); }
Removes the old hierarchy-listener from hierarchy-listener-l and returns the resulting multicast listener.
Params:
  • l – hierarchy-listener-l
  • oldl – the hierarchy-listener being removed
Since:1.3
/** * Removes the old hierarchy-listener from hierarchy-listener-l and * returns the resulting multicast listener. * @param l hierarchy-listener-l * @param oldl the hierarchy-listener being removed * @since 1.3 */
public static HierarchyListener remove(HierarchyListener l, HierarchyListener oldl) { return (HierarchyListener) removeInternal(l, oldl); }
Removes the old hierarchy-bounds-listener from hierarchy-bounds-listener-l and returns the resulting multicast listener.
Params:
  • l – hierarchy-bounds-listener-l
  • oldl – the hierarchy-bounds-listener being removed
Since:1.3
/** * Removes the old hierarchy-bounds-listener from * hierarchy-bounds-listener-l and returns the resulting multicast * listener. * @param l hierarchy-bounds-listener-l * @param oldl the hierarchy-bounds-listener being removed * @since 1.3 */
public static HierarchyBoundsListener remove(HierarchyBoundsListener l, HierarchyBoundsListener oldl) { return (HierarchyBoundsListener) removeInternal(l, oldl); }
Removes the old mouse-wheel-listener from mouse-wheel-listener-l and returns the resulting multicast listener.
Params:
  • l – mouse-wheel-listener-l
  • oldl – the mouse-wheel-listener being removed
Since:1.4
/** * Removes the old mouse-wheel-listener from mouse-wheel-listener-l * and returns the resulting multicast listener. * @param l mouse-wheel-listener-l * @param oldl the mouse-wheel-listener being removed * @since 1.4 */
public static MouseWheelListener remove(MouseWheelListener l, MouseWheelListener oldl) { return (MouseWheelListener) removeInternal(l, oldl); }
Returns the resulting multicast listener from adding listener-a and listener-b together. If listener-a is null, it returns listener-b; If listener-b is null, it returns listener-a If neither are null, then it creates and returns a new AWTEventMulticaster instance which chains a with b.
Params:
  • a – event listener-a
  • b – event listener-b
/** * Returns the resulting multicast listener from adding listener-a * and listener-b together. * If listener-a is null, it returns listener-b; * If listener-b is null, it returns listener-a * If neither are null, then it creates and returns * a new AWTEventMulticaster instance which chains a with b. * @param a event listener-a * @param b event listener-b */
protected static EventListener addInternal(EventListener a, EventListener b) { if (a == null) return b; if (b == null) return a; return new AWTEventMulticaster(a, b); }
Returns the resulting multicast listener after removing the old listener from listener-l. If listener-l equals the old listener OR listener-l is null, returns null. Else if listener-l is an instance of AWTEventMulticaster, then it removes the old listener from it. Else, returns listener l.
Params:
  • l – the listener being removed from
  • oldl – the listener being removed
/** * Returns the resulting multicast listener after removing the * old listener from listener-l. * If listener-l equals the old listener OR listener-l is null, * returns null. * Else if listener-l is an instance of AWTEventMulticaster, * then it removes the old listener from it. * Else, returns listener l. * @param l the listener being removed from * @param oldl the listener being removed */
protected static EventListener removeInternal(EventListener l, EventListener oldl) { if (l == oldl || l == null) { return null; } else if (l instanceof AWTEventMulticaster) { return ((AWTEventMulticaster)l).remove(oldl); } else { return l; // it's not here } } /* Serialization support. */ protected void saveInternal(ObjectOutputStream s, String k) throws IOException { if (a instanceof AWTEventMulticaster) { ((AWTEventMulticaster)a).saveInternal(s, k); } else if (a instanceof Serializable) { s.writeObject(k); s.writeObject(a); } if (b instanceof AWTEventMulticaster) { ((AWTEventMulticaster)b).saveInternal(s, k); } else if (b instanceof Serializable) { s.writeObject(k); s.writeObject(b); } } protected static void save(ObjectOutputStream s, String k, EventListener l) throws IOException { if (l == null) { return; } else if (l instanceof AWTEventMulticaster) { ((AWTEventMulticaster)l).saveInternal(s, k); } else if (l instanceof Serializable) { s.writeObject(k); s.writeObject(l); } } /* * Recursive method which returns a count of the number of listeners in * EventListener, handling the (common) case of l actually being an * AWTEventMulticaster. Additionally, only listeners of type listenerType * are counted. Method modified to fix bug 4513402. -bchristi */ private static int getListenerCount(EventListener l, Class<?> listenerType) { if (l instanceof AWTEventMulticaster) { AWTEventMulticaster mc = (AWTEventMulticaster)l; return getListenerCount(mc.a, listenerType) + getListenerCount(mc.b, listenerType); } else { // Only count listeners of correct type return listenerType.isInstance(l) ? 1 : 0; } } /* * Recusive method which populates EventListener array a with EventListeners * from l. l is usually an AWTEventMulticaster. Bug 4513402 revealed that * if l differed in type from the element type of a, an ArrayStoreException * would occur. Now l is only inserted into a if it's of the appropriate * type. -bchristi */ private static int populateListenerArray(EventListener[] a, EventListener l, int index) { if (l instanceof AWTEventMulticaster) { AWTEventMulticaster mc = (AWTEventMulticaster)l; int lhs = populateListenerArray(a, mc.a, index); return populateListenerArray(a, mc.b, lhs); } else if (a.getClass().getComponentType().isInstance(l)) { a[index] = l; return index + 1; } // Skip nulls, instances of wrong class else { return index; } }
Returns an array of all the objects chained as FooListeners by the specified java.util.EventListener. FooListeners are chained by the AWTEventMulticaster using the addFooListener method. If a null listener is specified, this method returns an empty array. If the specified listener is not an instance of AWTEventMulticaster, this method returns an array which contains only the specified listener. If no such listeners are chained, this method returns an empty array.
Params:
  • l – the specified java.util.EventListener
  • listenerType – the type of listeners requested; this parameter should specify an interface that descends from java.util.EventListener
Throws:
Returns:an array of all objects chained as FooListeners by the specified multicast listener, or an empty array if no such listeners have been chained by the specified multicast listener
Since:1.4
/** * Returns an array of all the objects chained as * <code><em>Foo</em>Listener</code>s by the specified * <code>java.util.EventListener</code>. * <code><em>Foo</em>Listener</code>s are chained by the * <code>AWTEventMulticaster</code> using the * <code>add<em>Foo</em>Listener</code> method. * If a <code>null</code> listener is specified, this method returns an * empty array. If the specified listener is not an instance of * <code>AWTEventMulticaster</code>, this method returns an array which * contains only the specified listener. If no such listeners are chained, * this method returns an empty array. * * @param l the specified <code>java.util.EventListener</code> * @param listenerType the type of listeners requested; this parameter * should specify an interface that descends from * <code>java.util.EventListener</code> * @return an array of all objects chained as * <code><em>Foo</em>Listener</code>s by the specified multicast * listener, or an empty array if no such listeners have been * chained by the specified multicast listener * @exception NullPointerException if the specified * {@code listenertype} parameter is {@code null} * @exception ClassCastException if <code>listenerType</code> * doesn't specify a class or interface that implements * <code>java.util.EventListener</code> * * @since 1.4 */
@SuppressWarnings("unchecked") public static <T extends EventListener> T[] getListeners(EventListener l, Class<T> listenerType) { if (listenerType == null) { throw new NullPointerException ("Listener type should not be null"); } int n = getListenerCount(l, listenerType); T[] result = (T[])Array.newInstance(listenerType, n); populateListenerArray(result, l, 0); return result; } }