fire attribute value change fire attribute value change
181623
function __fireAttrChange(self, when, name, prevVal, newVal, subAttrName, attrName, data) {
        attrName = attrName || name;
        return self.fire(whenAttrChangeEventName(when, name), util.mix({
            attrName: attrName,
            subAttrName: subAttrName,
            prevVal: prevVal,
            newVal: newVal
        }, data));
    }
106277
function(options) {
      options || (options = {});
      var changing = this._changing;
      this._changing = true;

      // Silent changes become pending changes.
      for (var attr in this._silent) this._pending[attr] = true;

      // Silent changes are triggered.
      var changes = _.extend({}, options.changes, this._silent);
      this._silent = {};
      for (var attr in changes) {
        this.trigger('change:' + attr, this, this.get(attr), options);
      }
      if (changing) return this;

      // Continue firing `"change"` events while there are pending changes.
      while (!_.isEmpty(this._pending)) {
        this._pending = {};
        this.trigger('change', this, options);
        // Pending and silent changes still remain.
        for (var attr in this.changed) {
          if (this._pending[attr] || this._silent[attr]) continue;
          delete this.changed[attr];
        }
        this._previousAttributes = _.clone(this.attributes);
      }

      this._changing = false;
      return this;
    }
756139
function(id, dateStr) {
		var onSelect,
			target = $(id),
			inst = this._getInst(target[0]);

		dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
		if (inst.input) {
			inst.input.val(dateStr);
		}
		this._updateAlternate(inst);

		onSelect = this._get(inst, "onSelect");
		if (onSelect) {
			onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);  // trigger custom callback
		} else if (inst.input) {
			inst.input.trigger("change"); // fire the change event
		}

		if (inst.inline){
			this._updateDatepicker(inst);
		} else {
			this._hideDatepicker();
			this._lastInput = inst.input[0];
			if (typeof(inst.input[0]) !== "object") {
				inst.input.focus(); // restore focus
			}
			this._lastInput = null;
		}
	}
968785
public void notifyValueChanged (boolean fireEvent) {
		VisValidatableTextField textField = getTextField();
		int cursor = textField.getCursorPosition();
		textField.setCursorPosition(0);
		textField.setText(model.getText());
		textField.setCursorPosition(cursor);

		if (fireEvent) {
			ChangeListener.ChangeEvent changeEvent = Pools.obtain(ChangeListener.ChangeEvent.class);
			fire(changeEvent);
			Pools.free(changeEvent);
		}
	}
202019
def reset_attribute!(attr)
      attr = database_field_name(attr)
      attributes[attr] = changed_attributes.delete(attr) if attribute_changed?(attr)
    end
1157471
public void fireChangeEvent() {

        String result = "";
        // check if there is a radio button selected.
        if (m_group.getSelectedButton() != null) {
            // set the name of the selected radio button.
            result = m_group.getSelectedButton().getName();
        }

        ValueChangeEvent.fire(this, result);
    }
298223
@Override
	public void onAttributeChangeEvent(AttributeChangeEvent event) {
		super.onAttributeChangeEvent(event);
		fireLayerAttributeChangedEvent(new MapLayerAttributeChangeEvent(this, event));
		fireElementChanged();
		if (ATTR_VISIBLE.equals(event.getName())) {
			final AttributeValue nValue = event.getValue();
			boolean cvalue;
			try {
				cvalue = nValue.getBoolean();
			} catch (Exception exception) {
				cvalue = isVisible();
			}
			if (cvalue) {
				final GISLayerContainer<?> container = getContainer();
				if (container instanceof GISBrowsable) {
					((GISBrowsable) container).setVisible(cvalue, false);
				}
			}
		}
	}
1342819
protected void firePropertyChange(PropertyKey propertyKey, Object oldValue, Object newValue)
    {
        // No change support instance means no listeners
        if (_changeSupport == null)
            return;

        _changeSupport.firePropertyChange(propertyKey.getPropertyName(), oldValue, newValue);
    }
1316538
public void setAttribute(String strKey, Object value)
    {
        this.propertyChangeDelegate.firePropertyChange(strKey,
            hmAttributes.put(strKey, value), value);
    }
825181
protected void fireChange(boolean force) {

        String value = getFormValueAsString();
        if (force || !value.equals(m_previousValue)) {
            m_previousValue = value;
            ValueChangeEvent.fire(this, value);
        }
    }
771437
protected void fireValueChangedEvent(boolean inhibitValidation) {

        if (!inhibitValidation) {
            ValueChangeEvent.fire(this, getFormValueAsString());
        } else {
            CmsExtendedValueChangeEvent<String> e = new CmsExtendedValueChangeEvent<String>(getFormValueAsString());
            e.setInhibitValidation(true);
            fireEvent(e);
        }
    }
567464
function(el, attr, val) {
            Y.Dom.batch(el, Y.Dom._setAttribute, { attr: attr, val: val });
        }
732877
protected Attribute setAttributeFromRawValue(String name, AttributeType type, Object value) throws AttributeException {
		AttributeValue oldValue = extractValueForSafe(name);
		if (oldValue != null) {
			if (oldValue.equals(value)) {
				return null;
			}
			// Clone the value for avoid border effects.
			oldValue = new AttributeValueImpl(oldValue);
		}

		final Attribute attr = new AttributeImpl(name, type);
		attr.setValue(type.cast(value));

		saveValue(name, attr);

		this.cache.put(name, attr);

		if (oldValue != null) {
			fireAttributeChangedEvent(name, oldValue, attr);
		} else {
			fireAttributeAddedEvent(name, attr);
		}

		return attr;
	}
1187116
protected void fireAttributeChangedEvent(String name, AttributeValue oldValue, AttributeValue currentValue) {
		if (this.listeners != null && isEventFirable()) {
			final AttributeChangeEvent event = new AttributeChangeEvent(
					//source
					this,
					//type
					Type.VALUE_UPDATE,
					//old name
					name,
					//old value
					oldValue,
					//current name
					name,
					//current value
					currentValue);
			for (final AttributeChangeListener listener : this.listeners) {
				listener.onAttributeChangeEvent(event);
			}
		}
	}
1235817
private void changeSimpleValue(String attributeName, int index, String value, List<String> parentPathElements) {

        CmsAttributeHandler handler = getAttributeHandler(attributeName, parentPathElements);
        handler.changeValue(value, index);
    }
146455
protected synchronized void fireAttributeClearedEvent() {
		if (this.listenerList != null && isEventFirable()) {
			final AttributeChangeListener[] list = new AttributeChangeListener[this.listenerList.size()];
			this.listenerList.toArray(list);
			final AttributeChangeEvent event = new AttributeChangeEvent(
					this,
					Type.REMOVE_ALL,
					null,
					null,
					null,
					null);
			for (final AttributeChangeListener listener : list) {
				listener.onAttributeChangeEvent(event);
			}
		}
	}
118996
def setAttribute(self, attr: str, value: _AttrValueType) -> None:
        """"""
        self._set_attribute(attr, value)