Called when a Characteristic property has changed.
320116
def properties_changed(self, properties, changed_properties, invalidated_properties):
        value = changed_properties.get('Value')
        
        if value is not None:
            self.service.device.characteristic_value_updated(characteristic=self, value=bytes(value))
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);
        }
    }
1096652
def runtime_values_changed(self, model, prop_name, info):
        """"""
        if ("_input_runtime_value" in info.method_name or
                info.method_name in ['use_runtime_value_input_data_ports',
                                     'input_data_port_runtime_values']) and \
                self.model is model:
            self._data_ports_changed(model)
987834
private void modifyTenantProperties(TenantDefinition oldTenantDef, TenantDefinition newTenantDef) {
        // _CreatedOn must be the same. _ModifiedOn must be updated.
        newTenantDef.setProperty(CREATED_ON_PROP, oldTenantDef.getProperty(CREATED_ON_PROP));
        newTenantDef.setProperty(MODIFIED_ON_PROP, Utils.formatDate(new Date().getTime()));
    }
391436
def _on_properties(self, properties):
        
        self._bold, self._italic, self._underline, self._overstrike = properties
        self._on_change()
406098
private function changed()
    {
        if ($this->isDirty) {
            return;
        }

        $this->isDirty = true;

        if (!$this->needsSchedulingForDirtyCheck()) {
            return;
        }

        $this->uow->scheduleForDirtyCheck($this->owner);
    }
248436
def _notify_change(self, model, attr, old, new, hint=None, setter=None, callback_invoker=None):
        ''' 

        '''
        # if name changes, update by-name index
        if attr == 'name':
            if old is not None:
                self._all_models_by_name.remove_value(old, model)
            if new is not None:
                self._all_models_by_name.add_value(new, model)

        if hint is None:
            serializable_new = model.lookup(attr).serializable_value(model)
        else:
            serializable_new = None

        event = ModelChangedEvent(self, model, attr, old, new, serializable_new, hint, setter, callback_invoker)
        self._trigger_on_change(event)
1231559
public void propertyChange(PropertyChangeEvent evt)
    {
        if (MenuConstants.DATE.equalsIgnoreCase(evt.getPropertyName()))
            if (evt.getNewValue() instanceof java.util.Date)
                this.setDateTime((java.util.Date)evt.getNewValue(), true, DBConstants.SCREEN_MOVE);
    }
1081076
def change (properties, feature, value = None):
    
    assert is_iterable_typed(properties, basestring)
    assert isinstance(feature, basestring)
    assert isinstance(value, (basestring, type(None)))
    result = []

    feature = add_grist (feature)

    for p in properties:
        if get_grist (p) == feature:
            if value:
                result.append (replace_grist (value, feature))

        else:
            result.append (p)

    return result
945803
protected void notifyPropertiesChanged(Properties oldProperties) {
        PropertiesReloadedEvent event = new PropertiesReloadedEvent(this, oldProperties);
        for (IReloadablePropertiesListener listener : listeners) {
            listener.propertiesReloaded(event);
        }
    }
666052
protected function propertyHasChanged()
    {
        foreach ($this->dbFields as $field => $value) {
            if (isset($this->fields[$field]) && ($this->fields[$field] != $value)) {
                return true;
            }
        }

        return false;
    }
922268
public void handleChange(Object propertyId) {

        try {
            lockOnChange(propertyId);
        } catch (CmsException e) {
            LOG.debug(e);
        }
        if (isDescriptorProperty(propertyId)) {
            m_descriptorHasChanges = true;
        }
        if (isBundleProperty(propertyId)) {
            m_changedTranslations.add(getLocale());
        }

    }
89359
public void propertyChange(PropertyChangeEvent evt) {
        // monitor "beanContext" property
        if ("beanContext".equals(evt.getPropertyName()) && contains(evt.getSource())) {
            BeanContext bc = (BeanContext) getPeer();
            if (bc.equals(evt.getOldValue()) && !bc.equals(evt.getNewValue())) {
                internalRemove(evt.getSource(), false);
            }
        }
    }
539967
function stopWatchingForValueChange() {
  if (!activeElement) {
    return;
  }

  // delete restores the original property definition
  delete activeElement.value;
  activeElement.detachEvent('onpropertychange', handlePropertyChange);

  activeElement = null;
  activeElementID = null;
  activeElementValue = null;
  activeElementValueProp = null;
}
383597
protected void valueChanged()
	{
		String newValue = fViewer.getDocument().get();
		if (!newValue.equals(fOldValue))
		{
			fOldValue = newValue;

		}
		refreshValidState();
	}
201070
function (attrName, oldVal, newVal) {

            var property = vcomet.util.hyphenToCamelCase(attrName);

            // The onAttributeChanged callback is triggered whether its observed or as a reflection of a property
            if (el.__observeAttributes[attrName] || el.__reflectProperties[property]) {
                vcomet.triggerAllCallbackEvents(el, config, "onAttributeChanged", [attrName, oldVal, newVal]);
            }

            // The onPropertyChanged callback is triggered when the attribute has changed and its reflect by a property
            if (el.__reflectProperties[property]) {
                el["__" + property] = newVal;
                vcomet.triggerAllCallbackEvents(el, config, "onPropertyChanged", [property, oldVal, newVal]);
            }

        }
492390
private static <T> void  setIfNew(Property<T> prop, T newValue)
  {
    if(!Objects.equals(prop.getValue(), newValue))
    {
      prop.setValue(newValue);
    }
  }