protected AWTEventMulticaster(EventListener a,
    EventListener b) 
{
        this.a = a; this.b = 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.

Parameters:

a - listener-a

b - listener-b

 public  void actionPerformed(ActionEvent e) 
{
        ((ActionListener)a).actionPerformed(e);
        ((ActionListener)b).actionPerformed(e);
}

Handles the actionPerformed event by invoking the actionPerformed methods on listener-a and listener-b.

 public static ComponentListener add(ComponentListener a,
    ComponentListener b) 
{
        return (ComponentListener)addInternal(a, b);
}

Adds component-listener-a with component-listener-b and returns the resulting multicast listener.

 public static ContainerListener add(ContainerListener a,
    ContainerListener b) 
{
        return (ContainerListener)addInternal(a, b);
}

Adds container-listener-a with container-listener-b and returns the resulting multicast listener.

 public static FocusListener add(FocusListener a,
    FocusListener b) 
{
        return (FocusListener)addInternal(a, b);
}

Adds focus-listener-a with focus-listener-b and returns the resulting multicast listener.

 public static KeyListener add(KeyListener a,
    KeyListener b) 
{
        return (KeyListener)addInternal(a, b);
}

Adds key-listener-a with key-listener-b and returns the resulting multicast listener.

 public static MouseListener add(MouseListener a,
    MouseListener b) 
{
        return (MouseListener)addInternal(a, b);
}

Adds mouse-listener-a with mouse-listener-b and returns the resulting multicast listener.

 public static MouseMotionListener add(MouseMotionListener a,
    MouseMotionListener b) 
{
        return (MouseMotionListener)addInternal(a, b);
}

Adds mouse-motion-listener-a with mouse-motion-listener-b and returns the resulting multicast listener.

 public static WindowListener add(WindowListener a,
    WindowListener b) 
{
        return (WindowListener)addInternal(a, b);
}

Adds window-listener-a with window-listener-b and returns the resulting multicast listener.

 public static WindowStateListener add(WindowStateListener a,
    WindowStateListener b) 
{
        return (WindowStateListener)addInternal(a, b);
}

Adds window-state-listener-a with window-state-listener-b and returns the resulting multicast listener.

 public static WindowFocusListener add(WindowFocusListener a,
    WindowFocusListener b) 
{
        return (WindowFocusListener)addInternal(a, b);
}

Adds window-focus-listener-a with window-focus-listener-b and returns the resulting multicast listener.

 public static ActionListener add(ActionListener a,
    ActionListener b) 
{
        return (ActionListener)addInternal(a, b);
}

Adds action-listener-a with action-listener-b and returns the resulting multicast listener.

 public static ItemListener add(ItemListener a,
    ItemListener b) 
{
        return (ItemListener)addInternal(a, b);
}

Adds item-listener-a with item-listener-b and returns the resulting multicast listener.

 public static AdjustmentListener add(AdjustmentListener a,
    AdjustmentListener b) 
{
        return (AdjustmentListener)addInternal(a, b);
}

Adds adjustment-listener-a with adjustment-listener-b and returns the resulting multicast listener.

 public static TextListener add(TextListener a,
    TextListener b) 
{
        return (TextListener)addInternal(a, b);
}

 public static InputMethodListener add(InputMethodListener a,
    InputMethodListener b) 
{
        return (InputMethodListener)addInternal(a, b);
}

Adds input-method-listener-a with input-method-listener-b and returns the resulting multicast listener.

 public static HierarchyListener add(HierarchyListener a,
    HierarchyListener b) 
{
        return (HierarchyListener)addInternal(a, b);
}

Adds hierarchy-listener-a with hierarchy-listener-b and returns the resulting multicast listener.

 public static HierarchyBoundsListener add(HierarchyBoundsListener a,
    HierarchyBoundsListener b) 
{
        return (HierarchyBoundsListener)addInternal(a, b);
}

Adds hierarchy-bounds-listener-a with hierarchy-bounds-listener-b and returns the resulting multicast listener.

 public static MouseWheelListener add(MouseWheelListener a,
    MouseWheelListener b) 
{
        return (MouseWheelListener)addInternal(a, b);
}

Adds mouse-wheel-listener-a with mouse-wheel-listener-b and returns the resulting multicast listener.

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

 public  void adjustmentValueChanged(AdjustmentEvent e) 
{
        ((AdjustmentListener)a).adjustmentValueChanged(e);
        ((AdjustmentListener)b).adjustmentValueChanged(e);
}

Handles the adjustmentValueChanged event by invoking the adjustmentValueChanged methods on listener-a and listener-b.

 public  void ancestorMoved(HierarchyEvent e) 
{
        ((HierarchyBoundsListener)a).ancestorMoved(e);
        ((HierarchyBoundsListener)b).ancestorMoved(e);
}

Handles the ancestorMoved event by invoking the ancestorMoved methods on listener-a and listener-b.

 public  void ancestorResized(HierarchyEvent e) 
{
        ((HierarchyBoundsListener)a).ancestorResized(e);
        ((HierarchyBoundsListener)b).ancestorResized(e);
}

Handles the ancestorResized event by invoking the ancestorResized methods on listener-a and listener-b.

 public  void caretPositionChanged(InputMethodEvent e) 
{
       ((InputMethodListener)a).caretPositionChanged(e);
       ((InputMethodListener)b).caretPositionChanged(e);
}

Handles the caretPositionChanged event by invoking the caretPositionChanged methods on listener-a and listener-b.

 public  void componentAdded(ContainerEvent e) 
{
        ((ContainerListener)a).componentAdded(e);
        ((ContainerListener)b).componentAdded(e);
}

Handles the componentAdded container event by invoking the componentAdded methods on listener-a and listener-b.

 public  void componentHidden(ComponentEvent e) 
{
        ((ComponentListener)a).componentHidden(e);
        ((ComponentListener)b).componentHidden(e);
}

Handles the componentHidden event by invoking the componentHidden methods on listener-a and listener-b.

 public  void componentMoved(ComponentEvent e) 
{
        ((ComponentListener)a).componentMoved(e);
        ((ComponentListener)b).componentMoved(e);
}

Handles the componentMoved event by invoking the componentMoved methods on listener-a and listener-b.

 public  void componentRemoved(ContainerEvent e) 
{
        ((ContainerListener)a).componentRemoved(e);
        ((ContainerListener)b).componentRemoved(e);
}

Handles the componentRemoved container event by invoking the componentRemoved methods on listener-a and listener-b.

 public  void componentResized(ComponentEvent e) 
{
        ((ComponentListener)a).componentResized(e);
        ((ComponentListener)b).componentResized(e);
}

Handles the componentResized event by invoking the componentResized methods on listener-a and listener-b.

 public  void componentShown(ComponentEvent e) 
{
        ((ComponentListener)a).componentShown(e);
        ((ComponentListener)b).componentShown(e);
}

Handles the componentShown event by invoking the componentShown methods on listener-a and listener-b.

 public  void focusGained(FocusEvent e) 
{
        ((FocusListener)a).focusGained(e);
        ((FocusListener)b).focusGained(e);
}

Handles the focusGained event by invoking the focusGained methods on listener-a and listener-b.

 public  void focusLost(FocusEvent e) 
{
        ((FocusListener)a).focusLost(e);
        ((FocusListener)b).focusLost(e);
}

Handles the focusLost event by invoking the focusLost methods on listener-a and listener-b.

 public static T[] getListeners(EventListener l,
    Class 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;
}

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 chanined, this method returns an empty array.

 public  void hierarchyChanged(HierarchyEvent e) 
{
        ((HierarchyListener)a).hierarchyChanged(e);
        ((HierarchyListener)b).hierarchyChanged(e);
}

Handles the hierarchyChanged event by invoking the hierarchyChanged methods on listener-a and listener-b.

 public  void inputMethodTextChanged(InputMethodEvent e) 
{
       ((InputMethodListener)a).inputMethodTextChanged(e);
       ((InputMethodListener)b).inputMethodTextChanged(e);
}

Handles the inputMethodTextChanged event by invoking the inputMethodTextChanged methods on listener-a and listener-b.

 public  void itemStateChanged(ItemEvent e) 
{
        ((ItemListener)a).itemStateChanged(e);
        ((ItemListener)b).itemStateChanged(e);
}

Handles the itemStateChanged event by invoking the itemStateChanged methods on listener-a and listener-b.

 public  void keyPressed(KeyEvent e) 
{
        ((KeyListener)a).keyPressed(e);
        ((KeyListener)b).keyPressed(e);
}

Handles the keyPressed event by invoking the keyPressed methods on listener-a and listener-b.

 public  void keyReleased(KeyEvent e) 
{
        ((KeyListener)a).keyReleased(e);
        ((KeyListener)b).keyReleased(e);
}

Handles the keyReleased event by invoking the keyReleased methods on listener-a and listener-b.

 public  void keyTyped(KeyEvent e) 
{
        ((KeyListener)a).keyTyped(e);
        ((KeyListener)b).keyTyped(e);
}

Handles the keyTyped event by invoking the keyTyped methods on listener-a and listener-b.

 public  void mouseClicked(MouseEvent e) 
{
        ((MouseListener)a).mouseClicked(e);
        ((MouseListener)b).mouseClicked(e);
}

Handles the mouseClicked event by invoking the mouseClicked methods on listener-a and listener-b.

 public  void mouseDragged(MouseEvent e) 
{
        ((MouseMotionListener)a).mouseDragged(e);
        ((MouseMotionListener)b).mouseDragged(e);
}

Handles the mouseDragged event by invoking the mouseDragged methods on listener-a and listener-b.

 public  void mouseEntered(MouseEvent e) 
{
        ((MouseListener)a).mouseEntered(e);
        ((MouseListener)b).mouseEntered(e);
}

Handles the mouseEntered event by invoking the mouseEntered methods on listener-a and listener-b.

 public  void mouseExited(MouseEvent e) 
{
        ((MouseListener)a).mouseExited(e);
        ((MouseListener)b).mouseExited(e);
}

Handles the mouseExited event by invoking the mouseExited methods on listener-a and listener-b.

 public  void mouseMoved(MouseEvent e) 
{
        ((MouseMotionListener)a).mouseMoved(e);
        ((MouseMotionListener)b).mouseMoved(e);
}

Handles the mouseMoved event by invoking the mouseMoved methods on listener-a and listener-b.

 public  void mousePressed(MouseEvent e) 
{
        ((MouseListener)a).mousePressed(e);
        ((MouseListener)b).mousePressed(e);
}

Handles the mousePressed event by invoking the mousePressed methods on listener-a and listener-b.

 public  void mouseReleased(MouseEvent e) 
{
        ((MouseListener)a).mouseReleased(e);
        ((MouseListener)b).mouseReleased(e);
}

Handles the mouseReleased event by invoking the mouseReleased methods on listener-a and listener-b.

 public  void mouseWheelMoved(MouseWheelEvent e) 
{
        ((MouseWheelListener)a).mouseWheelMoved(e);
        ((MouseWheelListener)b).mouseWheelMoved(e);
}

Handles the mouseWheelMoved event by invoking the mouseWheelMoved methods on listener-a and listener-b.

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

Removes a listener from this multicaster.

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.

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

 public static ComponentListener remove(ComponentListener l,
    ComponentListener oldl) 
{
        return (ComponentListener) removeInternal(l, oldl);
}

Removes the old component-listener from component-listener-l and returns the resulting multicast listener.

 public static ContainerListener remove(ContainerListener l,
    ContainerListener oldl) 
{
        return (ContainerListener) removeInternal(l, oldl);
}

Removes the old container-listener from container-listener-l and returns the resulting multicast listener.

 public static FocusListener remove(FocusListener l,
    FocusListener oldl) 
{
        return (FocusListener) removeInternal(l, oldl);
}

Removes the old focus-listener from focus-listener-l and returns the resulting multicast listener.

 public static KeyListener remove(KeyListener l,
    KeyListener oldl) 
{
        return (KeyListener) removeInternal(l, oldl);
}

Removes the old key-listener from key-listener-l and returns the resulting multicast listener.

 public static MouseListener remove(MouseListener l,
    MouseListener oldl) 
{
        return (MouseListener) removeInternal(l, oldl);
}

Removes the old mouse-listener from mouse-listener-l and returns the resulting multicast listener.

 public static MouseMotionListener remove(MouseMotionListener l,
    MouseMotionListener oldl) 
{
        return (MouseMotionListener) removeInternal(l, oldl);
}

Removes the old mouse-motion-listener from mouse-motion-listener-l and returns the resulting multicast listener.

 public static WindowListener remove(WindowListener l,
    WindowListener oldl) 
{
        return (WindowListener) removeInternal(l, oldl);
}

Removes the old window-listener from window-listener-l and returns the resulting multicast listener.

 public static WindowStateListener remove(WindowStateListener l,
    WindowStateListener oldl) 
{
        return (WindowStateListener) removeInternal(l, oldl);
}

Removes the old window-state-listener from window-state-listener-l and returns the resulting multicast listener.

 public static WindowFocusListener remove(WindowFocusListener l,
    WindowFocusListener oldl) 
{
        return (WindowFocusListener) removeInternal(l, oldl);
}

Removes the old window-focus-listener from window-focus-listener-l and returns the resulting multicast listener.

 public static ActionListener remove(ActionListener l,
    ActionListener oldl) 
{
        return (ActionListener) removeInternal(l, oldl);
}

Removes the old action-listener from action-listener-l and returns the resulting multicast listener.

 public static ItemListener remove(ItemListener l,
    ItemListener oldl) 
{
        return (ItemListener) removeInternal(l, oldl);
}

Removes the old item-listener from item-listener-l and returns the resulting multicast listener.

 public static AdjustmentListener remove(AdjustmentListener l,
    AdjustmentListener oldl) 
{
        return (AdjustmentListener) removeInternal(l, oldl);
}

Removes the old adjustment-listener from adjustment-listener-l and returns the resulting multicast listener.

 public static TextListener remove(TextListener l,
    TextListener oldl) 
{
        return (TextListener) removeInternal(l, oldl);
}

 public static InputMethodListener remove(InputMethodListener l,
    InputMethodListener oldl) 
{
        return (InputMethodListener) removeInternal(l, oldl);
}

Removes the old input-method-listener from input-method-listener-l and returns the resulting multicast listener.

 public static HierarchyListener remove(HierarchyListener l,
    HierarchyListener oldl) 
{
        return (HierarchyListener) removeInternal(l, oldl);
}

Removes the old hierarchy-listener from hierarchy-listener-l and returns the resulting multicast listener.

 public static HierarchyBoundsListener remove(HierarchyBoundsListener l,
    HierarchyBoundsListener oldl) 
{
        return (HierarchyBoundsListener) removeInternal(l, oldl);
}

Removes the old hierarchy-bounds-listener from hierarchy-bounds-listener-l and returns the resulting multicast listener.

 public static MouseWheelListener remove(MouseWheelListener l,
    MouseWheelListener oldl) 
{
      return (MouseWheelListener) removeInternal(l, oldl);
}

Removes the old mouse-wheel-listener from mouse-wheel-listener-l and returns the resulting multicast listener.

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

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.

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

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

 public  void textValueChanged(TextEvent e) 
{
        ((TextListener)a).textValueChanged(e);
        ((TextListener)b).textValueChanged(e);
}

 public  void windowActivated(WindowEvent e) 
{
        ((WindowListener)a).windowActivated(e);
        ((WindowListener)b).windowActivated(e);
}

Handles the windowActivated event by invoking the windowActivated methods on listener-a and listener-b.

 public  void windowClosed(WindowEvent e) 
{
        ((WindowListener)a).windowClosed(e);
        ((WindowListener)b).windowClosed(e);
}

Handles the windowClosed event by invoking the windowClosed methods on listener-a and listener-b.

 public  void windowClosing(WindowEvent e) 
{
        ((WindowListener)a).windowClosing(e);
        ((WindowListener)b).windowClosing(e);
}

Handles the windowClosing event by invoking the windowClosing methods on listener-a and listener-b.

 public  void windowDeactivated(WindowEvent e) 
{
        ((WindowListener)a).windowDeactivated(e);
        ((WindowListener)b).windowDeactivated(e);
}

Handles the windowDeactivated event by invoking the windowDeactivated methods on listener-a and listener-b.

 public  void windowDeiconified(WindowEvent e) 
{
        ((WindowListener)a).windowDeiconified(e);
        ((WindowListener)b).windowDeiconified(e);
}

Handles the windowDeiconfied event by invoking the windowDeiconified methods on listener-a and listener-b.

 public  void windowGainedFocus(WindowEvent e) 
{
        ((WindowFocusListener)a).windowGainedFocus(e);
        ((WindowFocusListener)b).windowGainedFocus(e);
}

Handles the windowGainedFocus event by invoking the windowGainedFocus methods on listener-a and listener-b.

 public  void windowIconified(WindowEvent e) 
{
        ((WindowListener)a).windowIconified(e);
        ((WindowListener)b).windowIconified(e);
}

Handles the windowIconified event by invoking the windowIconified methods on listener-a and listener-b.

 public  void windowLostFocus(WindowEvent e) 
{
        ((WindowFocusListener)a).windowLostFocus(e);
        ((WindowFocusListener)b).windowLostFocus(e);
}

Handles the windowLostFocus event by invoking the windowLostFocus methods on listener-a and listener-b.

 public  void windowOpened(WindowEvent e) 
{
        ((WindowListener)a).windowOpened(e);
        ((WindowListener)b).windowOpened(e);
}

Handles the windowOpened event by invoking the windowOpened methods on listener-a and listener-b.

 public  void windowStateChanged(WindowEvent e) 
{
        ((WindowStateListener)a).windowStateChanged(e);
        ((WindowStateListener)b).windowStateChanged(e);
}

Handles the windowStateChanged event by invoking the windowStateChanged methods on listener-a and listener-b.