Notify all listeners that a property has changed.

@param property
the property whose value has changed
984
private void firePropertyChanged(T property)
    {
        PropertyEvent<T> event = null;

        for (PropertyListener<T> l : listeners)
        {
            if (event == null)
            {
                event = new PropertyEvent<T>(this, property);
            }

            l.changed(event);
        }
    }
512430
public void propertyChange(PropertyChangeEvent evt) {
		if (evt.getPropertyName() == HAS_ERRORS_PROPERTY)
			updateErrors();
		else if (evt.getPropertyName() == HAS_WARNINGS_PROPERTY)
			updateWarnings();
		else if (evt.getPropertyName() == HAS_INFO_PROPERTY)
			updateInfo();
	}
1332904
private void doNotifyListeners(R oldValue, R newValue) {
        List<ValueChangeListener<R>> listenersCopy = new ArrayList<ValueChangeListener<R>>(listeners);
        notifyingListeners = true;
        for (ValueChangeListener<R> listener : listenersCopy) {
            listener.valueChanged(this, oldValue, newValue);
        }
        notifyingListeners = false;
    }
1348940
private void notifyListenersIfUninhibited(R oldValue, R newValue) {
        if (inhibited) {
            inhibitCount++;
            lastInhibitedValue = newValue;
        } else {
            lastInhibitedValue = newValue; // Just in case, even though not really necessary
            lastNonInhibitedValue = newValue;
            doNotifyListeners(oldValue, newValue);
        }
    }
1233270
public void setProperty(String key, String val) {

	ArrayList list  = null;
	Object oldValue = null;

	oldValue = getProperty(key);

	appProps.setProperty(key, val);
	if (listeners.containsKey(key)) {
	  list = (ArrayList)listeners.get(key);
	  int len = list.size();
	  if (len > 0) {
		PropertyChangeEvent evt = new PropertyChangeEvent(this, key, oldValue, val);
          for (Object aList : list) {
              if (aList instanceof PropertyChangeListener)
                  ((PropertyChangeListener) aList).propertyChange(evt);
          }
	  }
	}

  }
1156419
protected final void notifyChanged() {
        for (int i = mObservers.size() - 1; i >= 0; i--) {
            mObservers.get(i).onChanged();
        }
    }
906437
function () {
		var properties = this.properties;
		_.forEach(properties, function (prop, name) {
			prop = this.getProperty(name);
			this.stopListening(prop, EVENT_CHANGE);
		}, this);
	}
1371490
public void propertyChange(PropertyChangeEvent evt) {
		originalValue = getValue();
		if (deliverValueChangeEvents) {
			mediatedValueHolder.setValue(originalValue);
			updateDirtyState();
		}
	}
82852
public void propertyChange(PropertyChangeEvent evt)
    {
        if (JCalendarPopup.DATE_PARAM.equalsIgnoreCase(evt.getPropertyName()))
            if (evt.getNewValue() instanceof java.util.Date)
        {
            this.setControlValue(evt.getNewValue());
        }
    }
1098286
protected void notifyUpdate(String key, Object value) {
        for (ISharedObjectListener listener : listeners) {
            listener.onSharedObjectUpdate(this, key, value);
        }
    }
801636
@ObjectiveCName("subscribeWithListener:notify:")
    public void subscribe(ValueChangedListener<T> listener, boolean notify) {
        // im.actor.runtime.Runtime.checkMainThread();

        if (listeners.contains(listener)) {
            return;
        }
        listeners.add(listener);
        if (notify) {
            listener.onChanged(get(), this);
        }
    }
1154612
@SuppressWarnings("unchecked")
	protected void set(String property, Object value, boolean notify) {
		
		// remove listener on the current value if there is one yet
		uninstallListener(property);

		JsonEntity entity = null;
		// install listener to be aware of changes
		if (value instanceof JsonValue) {
			entity = getEntity((JsonValue) value);
		} else if (value instanceof JsonEntity) {
			entity = (JsonEntity) value;
		}
		
		if (entity != null && !listeners.containsKey(property)) {
			installListener(property, entity);
		}

		V oldValue = properties.get(property);
		properties.put(property, (V) value);
		appendSortOrder(property);
		
		if (notify) {
			firePropertyChange(property, oldValue, (V) value);
		}
	}
340083
def on_property_change(self, name, old_value, new_value):
        
        if self._registration is not None:
            # use the registration to trigger the service event
            self._registration.set_properties({name: new_value})
814542
function on(property, callback, thisArg){
    thisArg = thisArg || this;
    getListeners(property).push(callback);
    track(property, thisArg);
  }
755447
public synchronized void removePropertyChangeListener(java.beans.PropertyChangeListener listener)
    {
        if (propertyChange != null)
            propertyChange.removePropertyChangeListener(listener);
    }
1261698
public void registerListenersOnEverything(final Object object) {
        try {
            // the removeListener() call ensures that the listener is not added more than once
            new PropertyVisitor(object) {
                @Override
                protected boolean visitSingleValueProperty(final Property<?> fieldValue) {
                    fieldValue.removeListener(propertyListener);
                    fieldValue.addListener(propertyListener);
                    return true;
                }

                @Override
                protected boolean visitCollectionProperty(final ListProperty<?> fieldValue) {
                    fieldValue.removeListener(listListener);
                    fieldValue.addListener(listListener);
                    return true;
                }

                @Override
                protected boolean visitCollectionProperty(final MapProperty<?, ?> fieldValue) {
                    fieldValue.removeListener(mapListener);
                    fieldValue.addListener(mapListener);
                    return true;
                }

                @Override
                protected boolean visitCollectionProperty(final SetProperty<?> fieldValue) {
                    fieldValue.removeListener(setListener);
                    fieldValue.addListener(setListener);
                    return false;
                }
            };
        } catch (final IllegalAccessException e) {
            topology.onError(new SynchronizeFXException(e));
        } catch (final SecurityException e) {
            topology.onError(new SynchronizeFXException(
                    "Maybe you're JVM doesn't allow reflection for this application?", e));
        }
    }
937964
private void notifyScriptChanged(ScriptWrapper script) {
		for (ScriptEventListener listener : this.listeners) {
			try {
				listener.scriptChanged(script);
			} catch (Exception e) {
				logScriptEventListenerException(listener, script, e);
			}
		}
	}