/**
* Registers a listener which will be notified when the
* logging properties are re-read.
*/
public synchronized void addPropertyChangeListener(PropertyChangeListener listener)
{
/* do not register null. */
listener.getClass();
pcs.addPropertyChangeListener(listener);
}
/**
* Add a {@code PropertyChangeListener}, which will be invoked when the properties are reread.
*
* @param l the {@code PropertyChangeListener} to be added.
*/
public void addPropertyChangeListener(PropertyChangeListener l) {
if (l == null) {
throw new NullPointerException();
}
checkAccess();
listeners.addPropertyChangeListener(l);
}
/**
* Adds an event listener to be invoked when the logging properties are re-read. Adding multiple
* instances of the same event Listener results in multiple entries in the property event listener
* table.
*
* @param l event listener
* @exception SecurityException if a security manager exists and if the caller does not have
* LoggingPermission("control").
* @exception NullPointerException if the PropertyChangeListener is null.
*/
public void addPropertyChangeListener(PropertyChangeListener l) throws SecurityException {
if (l == null) {
throw new NullPointerException();
}
checkPermission();
changes.addPropertyChangeListener(l);
}
/**
* Add a property change listener to this application. Changes to certain elements of the state
* will cause all registered property listeners to be notified.
*/
public void addPropertyChangeListener(PropertyChangeListener listener) {
if (_propertyChangeSupport == null) {
_propertyChangeSupport = new PropertyChangeSupport(this);
}
_propertyChangeSupport.addPropertyChangeListener(listener);
}
/**
* Adds a property change listener.
*
* @param p The class which will listen for property changes.
*/
public final void addListener(PropertyChangeListener p) {
if (pcl == null) {
pcl = new PropertyChangeSupport(this);
}
LOG.debug("addPropertyChangeListener(" + p + ")");
pcl.addPropertyChangeListener(p);
}
public NbListenerRef addModelUpdateListener(final ProjectModelUpdatedListener listener) {
ExceptionHelper.checkNotNullArgument(listener, "listener");
final PropertyChangeListener forwarder =
new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
listener.onUpdateProject((NbGradleModel) evt.getNewValue());
}
};
updateListeners.addPropertyChangeListener(forwarder);
return new NbListenerRef() {
private volatile boolean registered = true;
@Override
public boolean isRegistered() {
return registered;
}
@Override
public void unregister() {
updateListeners.removePropertyChangeListener(forwarder);
registered = true;
}
};
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
listeners.addPropertyChangeListener(listener);
Property[] subProperties = getSubProperties();
if (subProperties != null)
for (int i = 0; i < subProperties.length; ++i)
subProperties[i].addPropertyChangeListener(listener);
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
List<PropertyChangeListener> listeners =
Arrays.asList(propertyChangeSupport.getPropertyChangeListeners());
if (!listeners.contains(listener)) {
propertyChangeSupport.addPropertyChangeListener(listener);
}
}
/**
* Adds a property change listener.Static for simplicity of use.
*
* @param key The specific key to listen for.
* @param p The class which will listen for property changes.
*/
public final void addListener(ConfigurationKey key, PropertyChangeListener p) {
if (pcl == null) {
pcl = new PropertyChangeSupport(this);
}
LOG.debug("addPropertyChangeListener(" + key.getKey() + ")");
pcl.addPropertyChangeListener(key.getKey(), p);
}
/**
* Adds a bound property listener to the dialog
*
* @param listener a listener for dialog events
*/
@Override
public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
if (listeners == null) {
listeners = new PropertyChangeSupport(this);
}
listeners.addPropertyChangeListener(listener);
}
OpFooter(OpControl control, List<LayerMode> layerModes) {
super(BoxLayout.X_AXIS);
layerControls = new LayerControls(control, layerModes, pcs);
invertRegionSwitch = new InvertRegionCheckBox(control, pcs);
colorControls = new ColorSelectionControls(control, pcs);
Box blendBox = Box.createVerticalBox();
blendBox.add(Box.createVerticalStrut(5));
blendBox.add(layerControls);
blendBox.add(invertRegionSwitch);
blendBox.setBackground(LightZoneSkin.Colors.ToolPanesBackground);
layerControls.setAlignmentX(Component.LEFT_ALIGNMENT);
invertRegionSwitch.setAlignmentX(Component.LEFT_ALIGNMENT);
tabPane = new JTabbedPane();
tabPane.setFont(LightZoneSkin.fontSet.getSmallFont());
tabPane.add(LOCALE.get("ToolSettingsTabName"), blendBox);
tabPane.add(LOCALE.get("ColorSelectionTabName"), colorControls);
tabPane.setIconAt(0, getThemeIcon(orangeScheme, true));
tabPane.setIconAt(1, getThemeIcon(orangeScheme, false));
add(tabPane, BorderLayout.NORTH);
setBackground(LightZoneSkin.Colors.ToolPanesBackground);
pcs.addPropertyChangeListener(this);
}
/**
* Adds the given <CODE>PropertyChangeListener</CODE> to the module.
*
* @param l The <CODE>PropertyChangeListener</CODE> to add to the module.
*/
public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
createPropertyChangeSupport();
propertyChangeSupport.addPropertyChangeListener(l);
// if (!propertyChangeListeners.contains(l))
// {
// propertyChangeListeners.add(l);
// }
}
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {
s.defaultReadObject();
Object listenerOrNull;
while (null != (listenerOrNull = s.readObject())) {
addPropertyChangeListener((PropertyChangeListener) listenerOrNull);
}
}
@Override
public void addPropertyChangeListener(PropertyChangeListener listener) {
// Ignore duplicate method calls.
for (PropertyChangeListener l : pcs.getPropertyChangeListeners()) {
if (l == listener) return;
}
pcs.addPropertyChangeListener(listener);
}
public void testAddingOneListenerTwice() {
Object bean = new Object();
PropertyChangeSupport support = new PropertyChangeSupport(bean);
EventLog log = new EventLog();
support.addPropertyChangeListener("a", log);
support.addPropertyChangeListener(log);
support.addPropertyChangeListener(log);
support.addPropertyChangeListener("a", log);
PropertyChangeEvent eventA = new PropertyChangeEvent(bean, "a", false, true);
PropertyChangeEvent eventB = new PropertyChangeEvent(bean, "b", false, true);
support.firePropertyChange(eventA);
support.firePropertyChange(eventB);
assertEquals(Arrays.asList(eventA, eventA, eventA, eventA, eventB, eventB), log.log);
}
/**
* Adds a PropertyChangeListener. The specified PropertyChangeListener's <b>propertyChange</b>
* method is called each time the value of any bound property is changed.
*
* @see #removePropertyChangeListener
* @param listener The PropertyChangeListener.
*/
public void addPropertyChangeListener(PropertyChangeListener listener) {
if (listener == null) throw new NullPointerException("listener");
if (changes_ == null) changes_ = new PropertyChangeSupport(this); // @CRS
changes_.addPropertyChangeListener(listener);
// must call the parents change listener since it is
// in a different package.
super.addPropertyChangeListener(listener);
}
/**
* Add a property change listener.
*
* @param l the listener to add
*/
public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
if (support == null)
synchronized (this) {
// new test under synchronized block
if (support == null) support = new PropertyChangeSupport(element);
}
support.addPropertyChangeListener(l);
}
public void testSerialize() {
String s =
"aced0005737200206a6176612e6265616e732e50726f70657274794368616e67"
+ "65537570706f727458d5d264574860bb03000349002a70726f706572747943686"
+ "16e6765537570706f727453657269616c697a65644461746156657273696f6e4c"
+ "00086368696c6472656e7400154c6a6176612f7574696c2f486173687461626c6"
+ "53b4c0006736f757263657400124c6a6176612f6c616e672f4f626a6563743b78"
+ "7000000002737200136a6176612e7574696c2e486173687461626c6513bb0f252"
+ "14ae4b803000246000a6c6f6164466163746f724900097468726573686f6c6478"
+ "703f4000000000000877080000000b00000001740001617371007e00000000000"
+ "2707400046265616e7372003a6c6962636f72652e6a6176612e7574696c2e6265"
+ "616e732e50726f70657274794368616e6765537570706f7274546573742445766"
+ "56e744c6f67b92667637d0b6f450200024c00036c6f677400104c6a6176612f75"
+ "74696c2f4c6973743b4c00046e616d657400124c6a6176612f6c616e672f53747"
+ "2696e673b7870737200136a6176612e7574696c2e41727261794c6973747881d2"
+ "1d99c7619d03000149000473697a6578700000000077040000000a7874000b6c6"
+ "97374656e6572546f4171007e000c70787871007e00087371007e00097371007e"
+ "000d0000000077040000000a7874000d6c697374656e6572546f416c6c7078";
Object bean = "bean";
PropertyChangeSupport support = new PropertyChangeSupport(bean);
EventLog listenerToAll = new EventLog();
listenerToAll.name = "listenerToAll";
EventLog listenerToA = new EventLog();
listenerToA.name = "listenerToA";
support.addPropertyChangeListener(listenerToAll);
support.addPropertyChangeListener("a", listenerToA);
support.addPropertyChangeListener("a", listenerToA);
new SerializationTester<PropertyChangeSupport>(support, s) {
@Override
protected boolean equals(PropertyChangeSupport a, PropertyChangeSupport b) {
return describe(a.getPropertyChangeListeners())
.equals(describe(b.getPropertyChangeListeners()));
}
@Override
protected void verify(PropertyChangeSupport deserialized) {
assertEquals(
"[a to listenerToA, a to listenerToA, listenerToAll]",
describe(deserialized.getPropertyChangeListeners()));
}
}.test();
}
/**
* Adds a PropertyChangeListener to the listener list for a specific property. The specified
* property may be one of the following:
*
* <ul>
* <li>if this AppContext is disposed ("disposed")
* </ul>
*
* <ul>
* <li>if this AppContext's unowned Windows have been disposed ("guidisposed"). Code to cleanup
* after the GUI is disposed (such as LookAndFeel.uninitialize()) should execute in response
* to this property being fired. Notifications for the "guidisposed" property are sent on
* the event dispatch thread.
* </ul>
*
* <p>If listener is null, no exception is thrown and no action is performed.
*
* @param propertyName one of the property names listed above
* @param listener the PropertyChangeListener to be added
* @see #removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
* @see #getPropertyChangeListeners(java.lang.String)
* @see #addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
*/
public synchronized void addPropertyChangeListener(
String propertyName, PropertyChangeListener listener) {
if (listener == null) {
return;
}
if (changeSupport == null) {
changeSupport = new PropertyChangeSupport(this);
}
changeSupport.addPropertyChangeListener(propertyName, listener);
}
public void testOldAndNewAreBothNull() {
Object bean = new Object();
PropertyChangeSupport support = new PropertyChangeSupport(bean);
EventLog listener = new EventLog();
support.addPropertyChangeListener(listener);
PropertyChangeEvent nullToNull = new PropertyChangeEvent(bean, "a", null, null);
support.firePropertyChange(nullToNull);
assertEquals(Arrays.<PropertyChangeEvent>asList(nullToNull), listener.log);
}
public void testOldAndNewAreTheSame() {
Object bean = new Object();
PropertyChangeSupport support = new PropertyChangeSupport(bean);
EventLog listener = new EventLog();
support.addPropertyChangeListener(listener);
PropertyChangeEvent xToX = new PropertyChangeEvent(bean, "a", "x", new String("x"));
support.firePropertyChange(xToX);
assertEquals(Arrays.<PropertyChangeEvent>asList(), listener.log);
}
public VertexCreationFormLayout(
final Set metaInstance,
final Set containerInstance,
final MultitabPanel parent,
final Action action) {
this.metaInstance = metaInstance;
this.containerInstance = containerInstance;
this.parent = parent;
this.action = action;
createInputForm();
changeSupport = new PropertyChangeSupport(this);
changeSupport.addPropertyChangeListener(EditorController.getInstance());
}
/**
* Test that we need to do our own equals() work to manually unwrap an arbitrary number of
* proxies.
*/
public void testRemoveWithProxies() {
Object bean = new Object();
PropertyChangeSupport support = new PropertyChangeSupport(bean);
EventLog all = new EventLog();
support.addPropertyChangeListener(all);
assertEquals(1, support.getPropertyChangeListeners().length);
EventLog proxiedA = new EventLog();
support.addPropertyChangeListener(new PropertyChangeListenerProxy("a", proxiedA));
assertEquals(2, support.getPropertyChangeListeners().length);
EventLog addA = new EventLog();
support.addPropertyChangeListener("a", addA);
assertEquals(3, support.getPropertyChangeListeners().length);
EventLog addAProxiedB = new EventLog();
support.addPropertyChangeListener("a", new PropertyChangeListenerProxy("b", addAProxiedB));
assertEquals(4, support.getPropertyChangeListeners().length);
EventLog proxiedAB = new EventLog();
PropertyChangeListenerProxy proxyAB =
new PropertyChangeListenerProxy("a", new PropertyChangeListenerProxy("b", proxiedAB));
support.addPropertyChangeListener(proxyAB);
assertEquals(5, support.getPropertyChangeListeners().length);
EventLog proxiedAAC = new EventLog();
support.addPropertyChangeListener(
new PropertyChangeListenerProxy(
"a",
new PropertyChangeListenerProxy(
"a", new PropertyChangeListenerProxy("c", proxiedAAC))));
assertEquals(6, support.getPropertyChangeListeners().length);
support.removePropertyChangeListener(all);
assertEquals(5, support.getPropertyChangeListeners().length);
support.removePropertyChangeListener("a", proxiedA);
assertEquals(4, support.getPropertyChangeListeners().length);
support.removePropertyChangeListener(new PropertyChangeListenerProxy("a", addA));
assertEquals(3, support.getPropertyChangeListeners().length);
support.removePropertyChangeListener("a", new PropertyChangeListenerProxy("b", addAProxiedB));
assertEquals(2, support.getPropertyChangeListeners().length);
support.removePropertyChangeListener(proxyAB);
assertEquals(1, support.getPropertyChangeListeners().length);
support.removePropertyChangeListener(proxiedAAC);
support.removePropertyChangeListener(new PropertyChangeListenerProxy("a", proxiedAAC));
support.removePropertyChangeListener("a", new PropertyChangeListenerProxy("c", proxiedAAC));
support.removePropertyChangeListener(
"a",
new PropertyChangeListenerProxy("c", new PropertyChangeListenerProxy("a", proxiedAAC)));
assertEquals(1, support.getPropertyChangeListeners().length);
support.removePropertyChangeListener(
"a",
new PropertyChangeListenerProxy("a", new PropertyChangeListenerProxy("c", proxiedAAC)));
assertEquals(0, support.getPropertyChangeListeners().length);
}
protected void init() {
log.fine("No service implementation instance available, initializing...");
try {
// The actual instance we ware going to use and hold a reference to (1:1 instance for manager)
serviceImpl = createServiceInstance();
// How the implementation instance will tell us about property changes
propertyChangeSupport = createPropertyChangeSupport(serviceImpl);
propertyChangeSupport.addPropertyChangeListener(createPropertyChangeListener(serviceImpl));
} catch (Exception ex) {
throw new RuntimeException("Could not initialize implementation: " + ex, ex);
}
}
/**
* 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 <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 PropertyChangeListener to be added
*/
public synchronized void addPropertyChangeListener(
String propertyName, PropertyChangeListener listener) {
if (listener == null || propertyName == null) {
return;
}
if (children == null) {
children = new java.util.Hashtable();
}
PropertyChangeSupport child = (PropertyChangeSupport) children.get(propertyName);
if (child == null) {
child = new PropertyChangeSupport(source);
children.put(propertyName, child);
}
child.addPropertyChangeListener(listener);
}
@Test
public void setFireGet() throws Exception {
LastChange lc = new LastChange(new RenderingControlLastChangeParser());
lc.setEventedValue(0, new RenderingControlVariable.PresetNameList("foo"));
lc.setEventedValue(0, new RenderingControlVariable.PresetNameList("foobar")); // Double set!
lc.setEventedValue(
0, new RenderingControlVariable.Volume(new ChannelVolume(Channel.Master, 123)));
lc.setEventedValue(
1, new RenderingControlVariable.Brightness(new UnsignedIntegerTwoBytes(456)));
final String[] lcValue = new String[1];
PropertyChangeSupport pcs = new PropertyChangeSupport(this);
pcs.addPropertyChangeListener(
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent ev) {
if (ev.getPropertyName().equals("LastChange")) lcValue[0] = (String) ev.getNewValue();
}
});
lc.fire(pcs);
// Check it's clear
assertEquals(lc.getEventedValue(0, RenderingControlVariable.PresetNameList.class), null);
assertEquals(lc.toString(), "");
// Set something again, it's not fired, so it has no consequence on further assertions
lc.setEventedValue(0, new RenderingControlVariable.PresetNameList("foo"));
// Read the XML string instead
lc = new LastChange(new RenderingControlLastChangeParser(), lcValue[0]);
assertEquals(
lc.getEventedValue(0, RenderingControlVariable.PresetNameList.class).getValue(), "foobar");
assertEquals(
lc.getEventedValue(0, RenderingControlVariable.Volume.class).getValue().getChannel(),
Channel.Master);
assertEquals(
lc.getEventedValue(0, RenderingControlVariable.Volume.class).getValue().getVolume(),
new Integer(123));
assertEquals(
lc.getEventedValue(1, RenderingControlVariable.Brightness.class).getValue(),
new UnsignedIntegerTwoBytes(456));
}
public void testAddingAListenerActuallyAddsAProxy() {
Object bean = new Object();
PropertyChangeSupport support = new PropertyChangeSupport(bean);
PropertyChangeListener listener =
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent event) {}
};
support.addPropertyChangeListener("a", listener);
PropertyChangeListenerProxy p1 =
(PropertyChangeListenerProxy) support.getPropertyChangeListeners()[0];
assertEquals(PropertyChangeListenerProxy.class, p1.getClass());
assertTrue(p1 != listener); // weird but consistent with the RI
assertEquals("a", p1.getPropertyName());
assertEquals(listener, p1.getListener());
}
/**
* 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 <code>listener</code> is null, no exception is thrown and no action is
* taken.
*
* @param listener The PropertyChangeListener to be added
*/
public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
if (listener == null) {
return;
}
if (listener instanceof PropertyChangeListenerProxy) {
PropertyChangeListenerProxy proxy = (PropertyChangeListenerProxy) listener;
// Call two argument add method.
addPropertyChangeListener(
proxy.getPropertyName(), (PropertyChangeListener) proxy.getListener());
} else {
if (listeners == null) {
listeners = new EventListenerAggregate(PropertyChangeListener.class);
}
listeners.add(listener);
}
}
public void testEventsFilteredByProxies() {
Object bean = new Object();
PropertyChangeEvent eventA = new PropertyChangeEvent(bean, "a", false, true);
PropertyChangeEvent eventB = new PropertyChangeEvent(bean, "b", false, true);
PropertyChangeEvent eventC = new PropertyChangeEvent(bean, "c", false, true);
PropertyChangeSupport support = new PropertyChangeSupport(bean);
EventLog all = new EventLog();
support.addPropertyChangeListener(all);
EventLog proxiedA = new EventLog();
support.addPropertyChangeListener(new PropertyChangeListenerProxy("a", proxiedA));
EventLog addA = new EventLog();
support.addPropertyChangeListener("a", addA);
EventLog addAProxiedB = new EventLog();
support.addPropertyChangeListener("a", new PropertyChangeListenerProxy("b", addAProxiedB));
EventLog proxiedAB = new EventLog();
support.addPropertyChangeListener(
new PropertyChangeListenerProxy("a", new PropertyChangeListenerProxy("b", proxiedAB)));
EventLog proxiedAA = new EventLog();
support.addPropertyChangeListener(
new PropertyChangeListenerProxy("a", new PropertyChangeListenerProxy("a", proxiedAA)));
EventLog proxiedAAC = new EventLog();
support.addPropertyChangeListener(
new PropertyChangeListenerProxy(
"a",
new PropertyChangeListenerProxy(
"a", new PropertyChangeListenerProxy("c", proxiedAAC))));
support.firePropertyChange(eventA);
support.firePropertyChange(eventB);
support.firePropertyChange(eventC);
assertEquals(Arrays.asList(eventA, eventB, eventC), all.log);
assertEquals(Arrays.asList(eventA), proxiedA.log);
assertEquals(Arrays.asList(eventA), addA.log);
assertEquals(Arrays.<PropertyChangeEvent>asList(), addAProxiedB.log);
assertEquals(Arrays.<PropertyChangeEvent>asList(), proxiedAB.log);
assertEquals(Arrays.<PropertyChangeEvent>asList(eventA), proxiedAA.log);
assertEquals(Arrays.<PropertyChangeEvent>asList(), proxiedAAC.log);
}
public void testAddingAProxy() {
Object bean = new Object();
PropertyChangeSupport support = new PropertyChangeSupport(bean);
PropertyChangeListener listener =
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent event) {}
};
PropertyChangeListenerProxy proxy = new PropertyChangeListenerProxy("a", listener);
support.addPropertyChangeListener("b", proxy);
// this proxy sets us up to receive 'b' events
PropertyChangeListenerProxy p1 =
(PropertyChangeListenerProxy) support.getPropertyChangeListeners()[0];
assertEquals(PropertyChangeListenerProxy.class, p1.getClass());
assertEquals("b", p1.getPropertyName());
// this proxy sets us up to receive 'a' events
PropertyChangeListenerProxy p2 = (PropertyChangeListenerProxy) p1.getListener();
assertEquals(PropertyChangeListenerProxy.class, p2.getClass());
assertEquals("a", p2.getPropertyName());
assertEquals(listener, p2.getListener());
}