/* * Copyright (c) 1996, 2011, 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.beans; import java.io.Serializable;import java.io.ObjectStreamField;import java.io.ObjectOutputStream;import java.io.ObjectInputStream;import java.io.IOException;import java.util.Hashtable;import java.util.Map.Entry; /** * This is a utility class that can be used by beans that support constrained * properties. It manages a list of listeners and dispatches * {@link PropertyChangeEvent}s to them. You can use an instance of this class * as a member field of your bean and delegate these types of work to it. * The {@link VetoableChangeListener} can be registered for all properties * or for a property specified by name. * <p> * Here is an example of {@code VetoableChangeSupport} usage that follows * the rules and recommendations laid out in the JavaBeans™ specification: * <pre> * public class MyBean { * private final VetoableChangeSupport vcs = new VetoableChangeSupport(this); * * public void addVetoableChangeListener(VetoableChangeListener listener) { * this.vcs.addVetoableChangeListener(listener); * } * * public void removeVetoableChangeListener(VetoableChangeListener listener) { * this.vcs.removeVetoableChangeListener(listener); * } * * private String value; * * public String getValue() { * return this.value; * } * * public void setValue(String newValue) throws PropertyVetoException { * String oldValue = this.value; * this.vcs.fireVetoableChange("value", oldValue, newValue); * this.value = newValue; * } * * [...] * } * </pre> * <p> * A {@code VetoableChangeSupport} instance is thread-safe. * <p> * This class is serializable. When it is serialized it will save * (and restore) any listeners that are themselves serializable. Any * non-serializable listeners will be skipped during serialization. * * @see PropertyChangeSupport */public class VetoableChangeSupport implements Serializable { private VetoableChangeListenerMap map = new VetoableChangeListenerMap(); /** * Constructs a <code>VetoableChangeSupport</code> object. * * @param sourceBean The bean to be given as the source for any events. */ public VetoableChangeSupport(Object sourceBean) { if (sourceBean == null) { throw new NullPointerException(); } source = sourceBean; } /** * Add a VetoableChangeListener 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 <code>listener</code> is null, no exception is thrown and no action * is taken. * * @param listener The VetoableChangeListener to be added */ public void addVetoableChangeListener(VetoableChangeListener listener) { if (listener == null) { return; } if (listener instanceof VetoableChangeListenerProxy) { VetoableChangeListenerProxy proxy = (VetoableChangeListenerProxy)listener; // Call two argument add method. addVetoableChangeListener(proxy.getPropertyName(), proxy.getListener()); } else { this.map.add(null, listener); } } /** * Remove a VetoableChangeListener from the listener list. * This removes a VetoableChangeListener that was registered * for all properties. * If <code>listener</code> was added more than once to the same event * source, it will be notified one less time after being removed. * If <code>listener</code> is null, or was never added, no exception is * thrown and no action is taken. * * @param listener The VetoableChangeListener to be removed */ public void removeVetoableChangeListener(VetoableChangeListener listener) { if (listener == null) { return; } if (listener instanceof VetoableChangeListenerProxy) { VetoableChangeListenerProxy proxy = (VetoableChangeListenerProxy)listener; // Call two argument remove method. removeVetoableChangeListener(proxy.getPropertyName(), proxy.getListener()); } else { this.map.remove(null, listener); } } /** * Returns an array of all the listeners that were added to the * VetoableChangeSupport object with addVetoableChangeListener(). * <p> * If some listeners have been added with a named property, then * the returned array will be a mixture of VetoableChangeListeners * and <code>VetoableChangeListenerProxy</code>s. If the calling * method is interested in distinguishing the listeners then it must * test each element to see if it's a * <code>VetoableChangeListenerProxy</code>, perform the cast, and examine * the parameter. * * <pre> * VetoableChangeListener[] listeners = bean.getVetoableChangeListeners(); * for (int i = 0; i < listeners.length; i++) { * if (listeners[i] instanceof VetoableChangeListenerProxy) { * VetoableChangeListenerProxy proxy = * (VetoableChangeListenerProxy)listeners[i]; * if (proxy.getPropertyName().equals("foo")) { * // proxy is a VetoableChangeListener which was associated * // with the property named "foo" * } * } * } *</pre> * * @see VetoableChangeListenerProxy * @return all of the <code>VetoableChangeListeners</code> added or an * empty array if no listeners have been added * @since 1.4 */ public VetoableChangeListener[] getVetoableChangeListeners(){ return this.map.getListeners(); } /** * Add a VetoableChangeListener for a specific property. The listener * will be invoked only when a call on fireVetoableChange 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 <code>propertyName</code> or <code>listener</code> is null, no * exception is thrown and no action is taken. * * @param propertyName The name of the property to listen on. * @param listener The VetoableChangeListener to be added */ public void addVetoableChangeListener( String propertyName, VetoableChangeListener listener) { if (listener == null || propertyName == null) { return; } listener = this.map.extract(listener); if (listener != null) { this.map.add(propertyName, listener); } } /** * Remove a VetoableChangeListener for a specific property. * If <code>listener</code> 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 <code>propertyName</code> is null, no exception is thrown and no * action is taken. * If <code>listener</code> is null, or was never added for the specified * property, no exception is thrown and no action is taken. * * @param propertyName The name of the property that was listened on. * @param listener The VetoableChangeListener to be removed */ public void removeVetoableChangeListener( String propertyName, VetoableChangeListener listener) { if (listener == null || propertyName == null) { return; } listener = this.map.extract(listener); if (listener != null) { this.map.remove(propertyName, listener); } } /** * Returns an array of all the listeners which have been associated * with the named property. * * @param propertyName The name of the property being listened to * @return all the <code>VetoableChangeListeners</code> associated with * the named property. If no such listeners have been added, * or if <code>propertyName</code> is null, an empty array is * returned. * @since 1.4 */ public VetoableChangeListener[] getVetoableChangeListeners(String propertyName) { return this.map.getListeners(propertyName); } /** * Reports a constrained property update to listeners * that have been registered to track updates of * all properties or a property with the specified name. * <p> * Any listener can throw a {@code PropertyVetoException} to veto the update. * If one of the listeners vetoes the update, this method passes * a new "undo" {@code PropertyChangeEvent} that reverts to the old value * to all listeners that already confirmed this update * and throws the {@code PropertyVetoException} again. * <p> * No event is fired if old and new values are equal and non-null. * <p> * This is merely a convenience wrapper around the more general * {@link #fireVetoableChange(PropertyChangeEvent)} method. * * @param propertyName the programmatic name of the property that is about to change * @param oldValue the old value of the property * @param newValue the new value of the property * @throws PropertyVetoException if one of listeners vetoes the property update */ public void fireVetoableChange(String propertyName, Object oldValue, Object newValue) throws PropertyVetoException { if (oldValue == null || newValue == null || !oldValue.equals(newValue)) { fireVetoableChange(new PropertyChangeEvent(this.source, propertyName, oldValue, newValue)); } } /** * Reports an integer constrained property update to listeners * that have been registered to track updates of * all properties or a property with the specified name. * <p> * Any listener can throw a {@code PropertyVetoException} to veto the update. * If one of the listeners vetoes the update, this method passes * a new "undo" {@code PropertyChangeEvent} that reverts to the old value * to all listeners that already confirmed this update * and throws the {@code PropertyVetoException} again. * <p> * No event is fired if old and new values are equal. * <p> * This is merely a convenience wrapper around the more general * {@link #fireVetoableChange(String, Object, Object)} method. * * @param propertyName the programmatic name of the property that is about to change * @param oldValue the old value of the property * @param newValue the new value of the property * @throws PropertyVetoException if one of listeners vetoes the property update */ public void fireVetoableChange(String propertyName, int oldValue, int newValue) throws PropertyVetoException { if (oldValue != newValue) { fireVetoableChange(propertyName, Integer.valueOf(oldValue), Integer.valueOf(newValue)); } } /** * Reports a boolean constrained property update to listeners * that have been registered to track updates of * all properties or a property with the specified name. * <p> * Any listener can throw a {@code PropertyVetoException} to veto the update. * If one of the listeners vetoes the update, this method passes * a new "undo" {@code PropertyChangeEvent} that reverts to the old value * to all listeners that already confirmed this update * and throws the {@code PropertyVetoException} again. * <p> * No event is fired if old and new values are equal. * <p> * This is merely a convenience wrapper around the more general * {@link #fireVetoableChange(String, Object, Object)} method. * * @param propertyName the programmatic name of the property that is about to change * @param oldValue the old value of the property * @param newValue the new value of the property * @throws PropertyVetoException if one of listeners vetoes the property update */ public void fireVetoableChange(String propertyName, boolean oldValue, boolean newValue) throws PropertyVetoException { if (oldValue != newValue) { fireVetoableChange(propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue)); } } /** * Fires a property change event to listeners * that have been registered to track updates of * all properties or a property with the specified name. * <p> * Any listener can throw a {@code PropertyVetoException} to veto the update. * If one of the listeners vetoes the update, this method passes * a new "undo" {@code PropertyChangeEvent} that reverts to the old value * to all listeners that already confirmed this update * and throws the {@code PropertyVetoException} again. * <p> * No event is fired if the given event's old and new values are equal and non-null. * * @param event the {@code PropertyChangeEvent} to be fired * @throws PropertyVetoException if one of listeners vetoes the property update */ public void fireVetoableChange(PropertyChangeEvent event) throws PropertyVetoException { Object oldValue = event.getOldValue(); Object newValue = event.getNewValue(); if (oldValue == null || newValue == null || !oldValue.equals(newValue)) { String name = event.getPropertyName(); VetoableChangeListener[] common = this.map.get(null); VetoableChangeListener[] named = (name != null) ? this.map.get(name) : null; VetoableChangeListener[] listeners; if (common == null) { listeners = named; } else if (named == null) { listeners = common; } else { listeners = new VetoableChangeListener[common.length + named.length]; System.arraycopy(common, 0, listeners, 0, common.length); System.arraycopy(named, 0, listeners, common.length, named.length); } if (listeners != null) { int current = 0; try { while (current < listeners.length) { listeners[current].vetoableChange(event); current++; } } catch (PropertyVetoException veto) { event = new PropertyChangeEvent(this.source, name, newValue, oldValue); for (int i = 0; i < current; i++) { try { listeners[i].vetoableChange(event); } catch (PropertyVetoException exception) { // ignore exceptions that occur during rolling back } } throw veto; // rethrow the veto exception } } } } /** * Check if there are any listeners for a specific property, including * those registered on all properties. If <code>propertyName</code> * is null, only check for listeners registered on all properties. * * @param propertyName the property name. * @return true if there are one or more listeners for the given property */ public boolean hasListeners(String propertyName) { return this.map.hasListeners(propertyName); } /** * @serialData Null terminated list of <code>VetoableChangeListeners</code>. * <p> * At serialization time we skip non-serializable listeners and * only serialize the serializable listeners. */ private void writeObject(ObjectOutputStream s) throws IOException { Hashtable<String, VetoableChangeSupport> children = null; VetoableChangeListener[] listeners = null; synchronized (this.map) { for (Entry<String, VetoableChangeListener[]> entry : this.map.getEntries()) { String property = entry.getKey(); if (property == null) { listeners = entry.getValue(); } else { if (children == null) { children = new Hashtable<String, VetoableChangeSupport>(); } VetoableChangeSupport vcs = new VetoableChangeSupport(this.source); vcs.map.set(null, entry.getValue()); children.put(property, vcs); } } } ObjectOutputStream.PutField fields = s.putFields(); fields.put("children", children); fields.put("source", this.source); fields.put("vetoableChangeSupportSerializedDataVersion", 2); s.writeFields(); if (listeners != null) { for (VetoableChangeListener l : listeners) { if (l instanceof Serializable) { s.writeObject(l); } } } s.writeObject(null); } private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException { this.map = new VetoableChangeListenerMap(); ObjectInputStream.GetField fields = s.readFields(); Hashtable<String, VetoableChangeSupport> children = (Hashtable<String, VetoableChangeSupport>) fields.get("children", null); this.source = fields.get("source", null); fields.get("vetoableChangeSupportSerializedDataVersion", 2); Object listenerOrNull; while (null != (listenerOrNull = s.readObject())) { this.map.add(null, (VetoableChangeListener)listenerOrNull); } if (children != null) { for (Entry<String, VetoableChangeSupport> entry : children.entrySet()) { for (VetoableChangeListener listener : entry.getValue().getVetoableChangeListeners()) { this.map.add(entry.getKey(), listener); } } } } /** * The object to be provided as the "source" for any generated events. */ private Object source; /** * @serialField children Hashtable * @serialField source Object * @serialField vetoableChangeSupportSerializedDataVersion int */ private static final ObjectStreamField[] serialPersistentFields = { new ObjectStreamField("children", Hashtable.class), new ObjectStreamField("source", Object.class), new ObjectStreamField("vetoableChangeSupportSerializedDataVersion", Integer.TYPE) }; /** * Serialization version ID, so we're compatible with JDK 1.1 */ static final long serialVersionUID = -5090210921595982017L; /** * This is a {@link ChangeListenerMap ChangeListenerMap} implementation * that works with {@link VetoableChangeListener VetoableChangeListener} objects. */ private static final class VetoableChangeListenerMap extends ChangeListenerMap<VetoableChangeListener> { private static final VetoableChangeListener[] EMPTY = {}; /** * Creates an array of {@link VetoableChangeListener VetoableChangeListener} objects. * This method uses the same instance of the empty array * when {@code length} equals {@code 0}.Lines 1–500 of 525. Load more
/* * Copyright (c) 1996, 2011, 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.beans; import java.io.Serializable; import java.io.ObjectStreamField; import java.io.ObjectOutputStream; import java.io.ObjectInputStream; import java.io.IOException; import java.util.Hashtable; import java.util.Map.Entry; /** * This is a utility class that can be used by beans that support constrained * properties. It manages a list of listeners and dispatches * {@link PropertyChangeEvent}s to them. You can use an instance of this class * as a member field of your bean and delegate these types of work to it. * The {@link VetoableChangeListener} can be registered for all properties * or for a property specified by name. * <p> * Here is an example of {@code VetoableChangeSupport} usage that follows * the rules and recommendations laid out in the JavaBeans™ specification: * <pre> * public class MyBean { * private final VetoableChangeSupport vcs = new VetoableChangeSupport(this); * * public void addVetoableChangeListener(VetoableChangeListener listener) { * this.vcs.addVetoableChangeListener(listener); * } * * public void removeVetoableChangeListener(VetoableChangeListener listener) { * this.vcs.removeVetoableChangeListener(listener); * } * * private String value; * * public String getValue() { * return this.value; * } * * public void setValue(String newValue) throws PropertyVetoException { * String oldValue = this.value; * this.vcs.fireVetoableChange("value", oldValue, newValue); * this.value = newValue; * } * * [...] * } * </pre> * <p> * A {@code VetoableChangeSupport} instance is thread-safe. * <p> * This class is serializable. When it is serialized it will save * (and restore) any listeners that are themselves serializable. Any * non-serializable listeners will be skipped during serialization. * * @see PropertyChangeSupport */ public class VetoableChangeSupport implements Serializable { private VetoableChangeListenerMap map = new VetoableChangeListenerMap(); /** * Constructs a <code>VetoableChangeSupport</code> object. * * @param sourceBean The bean to be given as the source for any events. */ public VetoableChangeSupport(Object sourceBean) { if (sourceBean == null) { throw new NullPointerException(); } source = sourceBean; } /** * Add a VetoableChangeListener 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 <code>listener</code> is null, no exception is thrown and no action * is taken. * * @param listener The VetoableChangeListener to be added */ public void addVetoableChangeListener(VetoableChangeListener listener) { if (listener == null) { return; } if (listener instanceof VetoableChangeListenerProxy) { VetoableChangeListenerProxy proxy = (VetoableChangeListenerProxy)listener; // Call two argument add method. addVetoableChangeListener(proxy.getPropertyName(), proxy.getListener()); } else { this.map.add(null, listener); } } /** * Remove a VetoableChangeListener from the listener list. * This removes a VetoableChangeListener that was registered * for all properties. * If <code>listener</code> was added more than once to the same event * source, it will be notified one less time after being removed. * If <code>listener</code> is null, or was never added, no exception is * thrown and no action is taken. * * @param listener The VetoableChangeListener to be removed */ public void removeVetoableChangeListener(VetoableChangeListener listener) { if (listener == null) { return; } if (listener instanceof VetoableChangeListenerProxy) { VetoableChangeListenerProxy proxy = (VetoableChangeListenerProxy)listener; // Call two argument remove method. removeVetoableChangeListener(proxy.getPropertyName(), proxy.getListener()); } else { this.map.remove(null, listener); } } /** * Returns an array of all the listeners that were added to the * VetoableChangeSupport object with addVetoableChangeListener(). * <p> * If some listeners have been added with a named property, then * the returned array will be a mixture of VetoableChangeListeners * and <code>VetoableChangeListenerProxy</code>s. If the calling * method is interested in distinguishing the listeners then it must * test each element to see if it's a * <code>VetoableChangeListenerProxy</code>, perform the cast, and examine * the parameter. * * <pre> * VetoableChangeListener[] listeners = bean.getVetoableChangeListeners(); * for (int i = 0; i < listeners.length; i++) { * if (listeners[i] instanceof VetoableChangeListenerProxy) { * VetoableChangeListenerProxy proxy = * (VetoableChangeListenerProxy)listeners[i]; * if (proxy.getPropertyName().equals("foo")) { * // proxy is a VetoableChangeListener which was associated * // with the property named "foo" * } * } * } *</pre> * * @see VetoableChangeListenerProxy * @return all of the <code>VetoableChangeListeners</code> added or an * empty array if no listeners have been added * @since 1.4 */ public VetoableChangeListener[] getVetoableChangeListeners(){ return this.map.getListeners(); } /** * Add a VetoableChangeListener for a specific property. The listener * will be invoked only when a call on fireVetoableChange 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 <code>propertyName</code> or <code>listener</code> is null, no * exception is thrown and no action is taken. * * @param propertyName The name of the property to listen on. * @param listener The VetoableChangeListener to be added */ public void addVetoableChangeListener( String propertyName, VetoableChangeListener listener) { if (listener == null || propertyName == null) { return; } listener = this.map.extract(listener); if (listener != null) { this.map.add(propertyName, listener); } } /** * Remove a VetoableChangeListener for a specific property. * If <code>listener</code> 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 <code>propertyName</code> is null, no exception is thrown and no * action is taken. * If <code>listener</code> is null, or was never added for the specified * property, no exception is thrown and no action is taken. * * @param propertyName The name of the property that was listened on. * @param listener The VetoableChangeListener to be removed */ public void removeVetoableChangeListener( String propertyName, VetoableChangeListener listener) { if (listener == null || propertyName == null) { return; } listener = this.map.extract(listener); if (listener != null) { this.map.remove(propertyName, listener); } } /** * Returns an array of all the listeners which have been associated * with the named property. * * @param propertyName The name of the property being listened to * @return all the <code>VetoableChangeListeners</code> associated with * the named property. If no such listeners have been added, * or if <code>propertyName</code> is null, an empty array is * returned. * @since 1.4 */ public VetoableChangeListener[] getVetoableChangeListeners(String propertyName) { return this.map.getListeners(propertyName); } /** * Reports a constrained property update to listeners * that have been registered to track updates of * all properties or a property with the specified name. * <p> * Any listener can throw a {@code PropertyVetoException} to veto the update. * If one of the listeners vetoes the update, this method passes * a new "undo" {@code PropertyChangeEvent} that reverts to the old value * to all listeners that already confirmed this update * and throws the {@code PropertyVetoException} again. * <p> * No event is fired if old and new values are equal and non-null. * <p> * This is merely a convenience wrapper around the more general * {@link #fireVetoableChange(PropertyChangeEvent)} method. * * @param propertyName the programmatic name of the property that is about to change * @param oldValue the old value of the property * @param newValue the new value of the property * @throws PropertyVetoException if one of listeners vetoes the property update */ public void fireVetoableChange(String propertyName, Object oldValue, Object newValue) throws PropertyVetoException { if (oldValue == null || newValue == null || !oldValue.equals(newValue)) { fireVetoableChange(new PropertyChangeEvent(this.source, propertyName, oldValue, newValue)); } } /** * Reports an integer constrained property update to listeners * that have been registered to track updates of * all properties or a property with the specified name. * <p> * Any listener can throw a {@code PropertyVetoException} to veto the update. * If one of the listeners vetoes the update, this method passes * a new "undo" {@code PropertyChangeEvent} that reverts to the old value * to all listeners that already confirmed this update * and throws the {@code PropertyVetoException} again. * <p> * No event is fired if old and new values are equal. * <p> * This is merely a convenience wrapper around the more general * {@link #fireVetoableChange(String, Object, Object)} method. * * @param propertyName the programmatic name of the property that is about to change * @param oldValue the old value of the property * @param newValue the new value of the property * @throws PropertyVetoException if one of listeners vetoes the property update */ public void fireVetoableChange(String propertyName, int oldValue, int newValue) throws PropertyVetoException { if (oldValue != newValue) { fireVetoableChange(propertyName, Integer.valueOf(oldValue), Integer.valueOf(newValue)); } } /** * Reports a boolean constrained property update to listeners * that have been registered to track updates of * all properties or a property with the specified name. * <p> * Any listener can throw a {@code PropertyVetoException} to veto the update. * If one of the listeners vetoes the update, this method passes * a new "undo" {@code PropertyChangeEvent} that reverts to the old value * to all listeners that already confirmed this update * and throws the {@code PropertyVetoException} again. * <p> * No event is fired if old and new values are equal. * <p> * This is merely a convenience wrapper around the more general * {@link #fireVetoableChange(String, Object, Object)} method. * * @param propertyName the programmatic name of the property that is about to change * @param oldValue the old value of the property * @param newValue the new value of the property * @throws PropertyVetoException if one of listeners vetoes the property update */ public void fireVetoableChange(String propertyName, boolean oldValue, boolean newValue) throws PropertyVetoException { if (oldValue != newValue) { fireVetoableChange(propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue)); } } /** * Fires a property change event to listeners * that have been registered to track updates of * all properties or a property with the specified name. * <p> * Any listener can throw a {@code PropertyVetoException} to veto the update. * If one of the listeners vetoes the update, this method passes * a new "undo" {@code PropertyChangeEvent} that reverts to the old value * to all listeners that already confirmed this update * and throws the {@code PropertyVetoException} again. * <p> * No event is fired if the given event's old and new values are equal and non-null. * * @param event the {@code PropertyChangeEvent} to be fired * @throws PropertyVetoException if one of listeners vetoes the property update */ public void fireVetoableChange(PropertyChangeEvent event) throws PropertyVetoException { Object oldValue = event.getOldValue(); Object newValue = event.getNewValue(); if (oldValue == null || newValue == null || !oldValue.equals(newValue)) { String name = event.getPropertyName(); VetoableChangeListener[] common = this.map.get(null); VetoableChangeListener[] named = (name != null) ? this.map.get(name) : null; VetoableChangeListener[] listeners; if (common == null) { listeners = named; } else if (named == null) { listeners = common; } else { listeners = new VetoableChangeListener[common.length + named.length]; System.arraycopy(common, 0, listeners, 0, common.length); System.arraycopy(named, 0, listeners, common.length, named.length); } if (listeners != null) { int current = 0; try { while (current < listeners.length) { listeners[current].vetoableChange(event); current++; } } catch (PropertyVetoException veto) { event = new PropertyChangeEvent(this.source, name, newValue, oldValue); for (int i = 0; i < current; i++) { try { listeners[i].vetoableChange(event); } catch (PropertyVetoException exception) { // ignore exceptions that occur during rolling back } } throw veto; // rethrow the veto exception } } } } /** * Check if there are any listeners for a specific property, including * those registered on all properties. If <code>propertyName</code> * is null, only check for listeners registered on all properties. * * @param propertyName the property name. * @return true if there are one or more listeners for the given property */ public boolean hasListeners(String propertyName) { return this.map.hasListeners(propertyName); } /** * @serialData Null terminated list of <code>VetoableChangeListeners</code>. * <p> * At serialization time we skip non-serializable listeners and * only serialize the serializable listeners. */ private void writeObject(ObjectOutputStream s) throws IOException { Hashtable<String, VetoableChangeSupport> children = null; VetoableChangeListener[] listeners = null; synchronized (this.map) { for (Entry<String, VetoableChangeListener[]> entry : this.map.getEntries()) { String property = entry.getKey(); if (property == null) { listeners = entry.getValue(); } else { if (children == null) { children = new Hashtable<String, VetoableChangeSupport>(); } VetoableChangeSupport vcs = new VetoableChangeSupport(this.source); vcs.map.set(null, entry.getValue()); children.put(property, vcs); } } } ObjectOutputStream.PutField fields = s.putFields(); fields.put("children", children); fields.put("source", this.source); fields.put("vetoableChangeSupportSerializedDataVersion", 2); s.writeFields(); if (listeners != null) { for (VetoableChangeListener l : listeners) { if (l instanceof Serializable) { s.writeObject(l); } } } s.writeObject(null); } private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException { this.map = new VetoableChangeListenerMap(); ObjectInputStream.GetField fields = s.readFields(); Hashtable<String, VetoableChangeSupport> children = (Hashtable<String, VetoableChangeSupport>) fields.get("children", null); this.source = fields.get("source", null); fields.get("vetoableChangeSupportSerializedDataVersion", 2); Object listenerOrNull; while (null != (listenerOrNull = s.readObject())) { this.map.add(null, (VetoableChangeListener)listenerOrNull); } if (children != null) { for (Entry<String, VetoableChangeSupport> entry : children.entrySet()) { for (VetoableChangeListener listener : entry.getValue().getVetoableChangeListeners()) { this.map.add(entry.getKey(), listener); } } } } /** * The object to be provided as the "source" for any generated events. */ private Object source; /** * @serialField children Hashtable * @serialField source Object * @serialField vetoableChangeSupportSerializedDataVersion int */ private static final ObjectStreamField[] serialPersistentFields = { new ObjectStreamField("children", Hashtable.class), new ObjectStreamField("source", Object.class), new ObjectStreamField("vetoableChangeSupportSerializedDataVersion", Integer.TYPE) }; /** * Serialization version ID, so we're compatible with JDK 1.1 */ static final long serialVersionUID = -5090210921595982017L; /** * This is a {@link ChangeListenerMap ChangeListenerMap} implementation * that works with {@link VetoableChangeListener VetoableChangeListener} objects. */ private static final class VetoableChangeListenerMap extends ChangeListenerMap<VetoableChangeListener> { private static final VetoableChangeListener[] EMPTY = {}; /** * Creates an array of {@link VetoableChangeListener VetoableChangeListener} objects. * This method uses the same instance of the empty array * when {@code length} equals {@code 0}.