public PropertyChangeSupport(Object sourceBean) 
{
                           
        if (sourceBean == null) {
            throw new NullPointerException();
        }
        source = sourceBean;
}

Constructs a PropertyChangeSupport object.

Parameters:

sourceBean - The bean to be given as the source for any events.

 public  void addPropertyChangeListener(PropertyChangeListener listener) 
{
        if (listener == null) {
            return;
        }
        if (listener instanceof PropertyChangeListenerProxy) {
            PropertyChangeListenerProxy proxy =
                   (PropertyChangeListenerProxy)listener;
            // Call two argument add method.
            addPropertyChangeListener(proxy.getPropertyName(),
                                      proxy.getListener());
        } else {
            this.map.add(null, listener);
        }
}

Add a PropertyChangeListener to the listener list. The listener is registered for all properties. The same listener object may be added more than once, and will be called as many times as it is added. If listener is null, no exception is thrown and no action is taken.

 public  void addPropertyChangeListener(String propertyName,
    PropertyChangeListener listener) 
{
        if (listener == null || propertyName == null) {
            return;
        }
        listener = this.map.extract(listener);
        if (listener != null) {
            this.map.add(propertyName, listener);
        }
}

Add a PropertyChangeListener for a specific property. The listener will be invoked only when a call on firePropertyChange names that specific property. The same listener object may be added more than once. For each property, the listener will be invoked the number of times it was added for that property. If propertyName or listener is null, no exception is thrown and no action is taken.

 public  void fireIndexedPropertyChange(String propertyName,
    int index,
    Object oldValue,
    Object newValue) 
{
        firePropertyChange(new IndexedPropertyChangeEvent
            (source, propertyName, oldValue, newValue, index));
}

Report a bound indexed property update to any registered listeners.

No event is fired if old and new values are equal and non-null.

This is merely a convenience wrapper around the more general firePropertyChange method that takes {@code PropertyChangeEvent} value.

 public  void fireIndexedPropertyChange(String propertyName,
    int index,
    int oldValue,
    int newValue) 
{
        if (oldValue == newValue) {
            return;
        }
        fireIndexedPropertyChange(propertyName, index,
                                  Integer.valueOf(oldValue),
                                  Integer.valueOf(newValue));
}

Report an int bound indexed property update to any registered listeners.

No event is fired if old and new values are equal.

This is merely a convenience wrapper around the more general fireIndexedPropertyChange method which takes Object values.

 public  void fireIndexedPropertyChange(String propertyName,
    int index,
    boolean oldValue,
    boolean newValue) 
{
        if (oldValue == newValue) {
            return;
        }
        fireIndexedPropertyChange(propertyName, index, Boolean.valueOf(oldValue),
                                  Boolean.valueOf(newValue));
}

Report a boolean bound indexed property update to any registered listeners.

No event is fired if old and new values are equal.

This is merely a convenience wrapper around the more general fireIndexedPropertyChange method which takes Object values.

 public  void firePropertyChange(PropertyChangeEvent evt) 
{
        Object oldValue = evt.getOldValue();
        Object newValue = evt.getNewValue();
        String propertyName = evt.getPropertyName();
        if (oldValue != null && newValue != null && oldValue.equals(newValue)) {
            return;
        }
        PropertyChangeListener[] common = this.map.get(null);
        PropertyChangeListener[] named = (propertyName != null)
                    ? this.map.get(propertyName)
                    : null;
        fire(common, evt);
        fire(named, evt);
}

Fire an existing PropertyChangeEvent to any registered listeners. No event is fired if the given event's old and new values are equal and non-null.

 public  void firePropertyChange(String propertyName,
    Object oldValue,
    Object newValue) 
{
        if (oldValue != null && newValue != null && oldValue.equals(newValue)) {
            return;
        }
        firePropertyChange(new PropertyChangeEvent(source, propertyName,
                                                   oldValue, newValue));
}

Report a bound property update to any registered listeners. No event is fired if old and new are equal and non-null.

This is merely a convenience wrapper around the more general firePropertyChange method that takes {@code PropertyChangeEvent} value.

 public  void firePropertyChange(String propertyName,
    int oldValue,
    int newValue) 
{
        if (oldValue == newValue) {
            return;
        }
        firePropertyChange(propertyName, Integer.valueOf(oldValue), Integer.valueOf(newValue));
}

Report an int bound property update to any registered listeners. No event is fired if old and new are equal.

This is merely a convenience wrapper around the more general firePropertyChange method that takes Object values.

 public  void firePropertyChange(String propertyName,
    boolean oldValue,
    boolean newValue) 
{
        if (oldValue == newValue) {
            return;
        }
        firePropertyChange(propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
}

Report a boolean bound property update to any registered listeners. No event is fired if old and new are equal.

This is merely a convenience wrapper around the more general firePropertyChange method that takes Object values.

 public PropertyChangeListener[] getPropertyChangeListeners() 
{
        return this.map.getListeners();
}

Returns an array of all the listeners that were added to the PropertyChangeSupport object with addPropertyChangeListener().

If some listeners have been added with a named property, then the returned array will be a mixture of PropertyChangeListeners and PropertyChangeListenerProxys. If the calling method is interested in distinguishing the listeners then it must test each element to see if it's a PropertyChangeListenerProxy, perform the cast, and examine the parameter.

PropertyChangeListener[] listeners = bean.getPropertyChangeListeners();
for (int i = 0; i < listeners.length; i++) {
if (listeners[i] instanceof PropertyChangeListenerProxy) {
PropertyChangeListenerProxy proxy =
(PropertyChangeListenerProxy)listeners[i];
if (proxy.getPropertyName().equals("foo")) {
// proxy is a PropertyChangeListener which was associated
// with the property named "foo"
}
}
}

 public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) 
{
        return this.map.getListeners(propertyName);
}

Returns an array of all the listeners which have been associated with the named property.

 public boolean hasListeners(String propertyName) 
{
        return this.map.hasListeners(propertyName);
}

Check if there are any listeners for a specific property, including those registered on all properties. If propertyName is null, only check for listeners registered on all properties.

 public  void removePropertyChangeListener(PropertyChangeListener listener) 
{
        if (listener == null) {
            return;
        }
        if (listener instanceof PropertyChangeListenerProxy) {
            PropertyChangeListenerProxy proxy =
                    (PropertyChangeListenerProxy)listener;
            // Call two argument remove method.
            removePropertyChangeListener(proxy.getPropertyName(),
                                         proxy.getListener());
        } else {
            this.map.remove(null, listener);
        }
}

Remove a PropertyChangeListener from the listener list. This removes a PropertyChangeListener that was registered for all properties. If listener was added more than once to the same event source, it will be notified one less time after being removed. If listener is null, or was never added, no exception is thrown and no action is taken.

 public  void removePropertyChangeListener(String propertyName,
    PropertyChangeListener listener) 
{
        if (listener == null || propertyName == null) {
            return;
        }
        listener = this.map.extract(listener);
        if (listener != null) {
            this.map.remove(propertyName, listener);
        }
}

Remove a PropertyChangeListener for a specific property. If listener was added more than once to the same event source for the specified property, it will be notified one less time after being removed. If propertyName is null, no exception is thrown and no action is taken. If listener is null, or was never added for the specified property, no exception is thrown and no action is taken.