Fires a change event to all listeners for the given path in mChangeListeners.

@param {object} mChangeListeners A map of change listeners by path
@param {string} sPropertyPath The path
@param {any} vValue The value to report to the listeners
422691
function (mChangeListeners, sPropertyPath, vValue) {
			var aListeners = mChangeListeners[sPropertyPath],
				i;

			if (aListeners) {
				for (i = 0; i < aListeners.length; i += 1) {
					aListeners[i].onChange(vValue);
				}
			}
		}
199054
public void propertyChange(PropertyChangeEvent event)
	{
		if (contains(event.getSource()) && "beanContext".equals(event.getPropertyName()) && event.getOldValue() == getBeanContextPeer())
		{
			remove(event.getSource(), false);
		}
	}
107777
public void setValueChangeListener(MethodBinding valueChangeListener) {

        ValueChangeListener[] curListeners = getValueChangeListeners();
        // see if we need to null-out, or replace an existing listener
        if (null != curListeners) {
            for (int i = 0; i < curListeners.length; i++) {
                // if we want to remove the valueChangeListener
                if (null == valueChangeListener) {
                    // We are guaranteed to have at most one instance of
                    // MethodBindingValueChangeListener in the curListeners
                    // list.
                    if (MethodBindingValueChangeListener.class ==
                         curListeners[i].getClass()) {
                        removeFacesListener(curListeners[i]);
                        return;
                    }
                }
                // if we want to replace the valueChangeListener
                else //noinspection ObjectEquality
                    if (valueChangeListener == curListeners[i]) {
                    removeFacesListener(curListeners[i]);
                    break;
                }
            }
        }
        addValueChangeListener(new MethodBindingValueChangeListener(valueChangeListener));
    }
1268725
function(el,prop,val,ret,args,action)
            {
              var e = new _changeEvent(el,prop,val,ret,args,action,'update');
              
              if(el.__kb !== undefined)
              {
                var localAttrListeners = el.__kb._attrUpdateListeners,
                    localStyleListeners = el.__kb._styleUpdateListeners,
                    localParentAttrListeners = el.__kb._parentAttrUpdateListeners,
                    localParentStyleListeners = el.__kb._parentStyleUpdateListeners;
              
                if(localAttrListeners[prop] !== undefined)
                {
                  loopListener(localAttrListeners[prop],e);
                }

                if(e._stopPropogation === undefined && localStyleListeners[prop] !== undefined)
                {
                  loopListener(localStyleListeners[prop],e);
                }
                
                if(e._stopPropogation === undefined && localAttrListeners[_all] !== undefined)
                {
                  loopListener(localAttrListeners[_all],e);
                  if(e._stopPropogation === undefined)
                  {
                    loopListener(localStyleListeners[_all],e);
                  }
                }
                
                if(e._stopPropogation === undefined && localParentAttrListeners[prop] !== undefined)
                {
                  loopParentListener(localParentAttrListeners[prop],e);
                }

                if(e._stopPropogation === undefined && localParentStyleListeners[prop] !== undefined)
                {
                  loopParentListener(localParentStyleListeners[prop],e);
                }
                
                if(e._stopPropogation === undefined && localParentAttrListeners[_all] !== undefined)
                {
                  loopParentListener(localParentAttrListeners[_all],e);

                  if(e._stopPropogation === undefined)
                  {
                    loopParentListener(localParentStyleListeners[_all],e);
                  }
                }
              
              }
              
              if(e._stopPropogation === undefined && _attrUpdateListeners[prop] !== undefined)
              {
                loopListener(_attrUpdateListeners[prop],e);
              }

              if(e._stopPropogation === undefined && _styleUpdateListeners[prop] !== undefined)
              {
                loopListener(_styleUpdateListeners[prop],e);
              }
              
              if(e._stopPropogation === undefined && _attrUpdateListeners[_all] !== undefined)
              {
                loopListener(_attrUpdateListeners[_all],e);
                if(e._stopPropogation === undefined)
                {
                  loopListener(_styleUpdateListeners[_all],e);
                }
              }

              if(e._preventDefault !== undefined) return false;

              return true;
            }
820834
private void slidersValueChangeListeners() {
        colorPickerLayout.getRedSlider().addValueChangeListener(new ValueChangeListener() {
            private static final long serialVersionUID = 1L;

            @Override
            public void valueChange(final ValueChangeEvent event) {
                final double red = (Double) event.getProperty().getValue();
                final Color newColor = new Color((int) red, colorPickerLayout.getSelectedColor().getGreen(),
                        colorPickerLayout.getSelectedColor().getBlue());
                setColorToComponents(newColor);
            }
        });
        colorPickerLayout.getGreenSlider().addValueChangeListener(new ValueChangeListener() {
            private static final long serialVersionUID = 1L;

            @Override
            public void valueChange(final ValueChangeEvent event) {
                final double green = (Double) event.getProperty().getValue();
                final Color newColor = new Color(colorPickerLayout.getSelectedColor().getRed(), (int) green,
                        colorPickerLayout.getSelectedColor().getBlue());
                setColorToComponents(newColor);
            }
        });
        colorPickerLayout.getBlueSlider().addValueChangeListener(new ValueChangeListener() {
            private static final long serialVersionUID = 1L;

            @Override
            public void valueChange(final ValueChangeEvent event) {
                final double blue = (Double) event.getProperty().getValue();
                final Color newColor = new Color(colorPickerLayout.getSelectedColor().getRed(),
                        colorPickerLayout.getSelectedColor().getGreen(), (int) blue);
                setColorToComponents(newColor);
            }
        });
    }
546967
function(newValues, oldValues, paths) {
      var name, method, called = {};
      for (var i in oldValues) {
        // note: paths is of form [object, path, object, path]
        name = paths[2 * i + 1];
        method = this.observe[name];
        if (method) {
          var ov = oldValues[i], nv = newValues[i];
          // observes the value if it is an array
          this.observeArrayValue(name, nv, ov);
          if (!called[method]) {
            // only invoke change method if one of ov or nv is not (undefined | null)
            if ((ov !== undefined && ov !== null) || (nv !== undefined && nv !== null)) {
              called[method] = true;
              // TODO(sorvell): call method with the set of values it's expecting;
              // e.g. 'foo bar': 'invalidate' expects the new and old values for
              // foo and bar. Currently we give only one of these and then
              // deliver all the arguments.
              this.invokeMethod(method, [ov, nv, arguments]);
            }
          }
        }
      }
    }
431306
public void firePropertyChange(String propertyName, Object oldValue, Object newValue)
    {
        if (propertyChange != null)
            propertyChange.firePropertyChange(propertyName, oldValue, newValue);
    }
975943
public void propertyChange(PropertyChangeEvent evt) {
        if (evt.getPropertyName().equals("day")) {
            if (popup.isVisible() && jcalendar.getCalendar().get(Calendar.MONTH) == jcalendar.monthChooser.getMonth()) {
                dateSelected = true;
                popup.setVisible(false);
                setDate(jcalendar.getCalendar().getTime());
            }
        } else if (evt.getPropertyName().equals("date")) {
            if (evt.getSource() == dateEditor) {
                firePropertyChange("date", evt.getOldValue(), evt.getNewValue());
            } else {
                setDate((Date) evt.getNewValue());
            }
        }
    }
394309
private void fireFieldChangeEvent(AssignmentField field, Object oldValue, Object newValue)
   {
      //
      // Internal event handling
      //
      switch (field)
      {
         case START:
         case BASELINE_START:
         {
            m_array[AssignmentField.START_VARIANCE.getValue()] = null;
            break;
         }

         case FINISH:
         case BASELINE_FINISH:
         {
            m_array[AssignmentField.FINISH_VARIANCE.getValue()] = null;
            break;
         }

         case BCWP:
         case ACWP:
         {
            m_array[AssignmentField.CV.getValue()] = null;
            m_array[AssignmentField.SV.getValue()] = null;
            break;
         }

         case COST:
         case BASELINE_COST:
         {
            m_array[AssignmentField.COST_VARIANCE.getValue()] = null;
            break;
         }

         case WORK:
         case BASELINE_WORK:
         {
            m_array[AssignmentField.WORK_VARIANCE.getValue()] = null;
            break;
         }

         case ACTUAL_OVERTIME_COST:
         case REMAINING_OVERTIME_COST:
         {
            m_array[AssignmentField.OVERTIME_COST.getValue()] = null;
            break;
         }

         default:
         {
            break;
         }
      }

      //
      // External event handling
      //
      if (m_listeners != null)
      {
         for (FieldListener listener : m_listeners)
         {
            listener.fieldChange(this, field, oldValue, newValue);
         }
      }
   }
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();
	}
1340573
protected final void firePrimitiveChanged(String propertyName, Object oldValue, Object newValue) {
		final BusChangeEvent event = new BusChangeEvent(
				// source of the event
				this,
				// type of the event
				BusChangeEventType.change(getClass()),
				// subobject
				this,
				// index in parent
				indexInParent(),
				propertyName,
				oldValue,
				newValue);
		firePrimitiveChanged(event);
	}
1211504
@Override
    public void valueForPathChanged(TreePath path, Object newValue){
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        for(int i = listeners.length-2; i>=0; i-=2){
            if(e==null)
                e = new TreeModelEvent(this, path.getPath(), null, null);
                ((TreeModelListener)listeners[i+1]).treeNodesChanged(e);
        }
    }
607877
function startWatchingForValueChange(target, targetInst) {
  activeElement = target;
  activeElementInst = targetInst;
  activeElement.attachEvent('onpropertychange', handlePropertyChange);
}
25738
public void add(V value) {
		values.add(value);
		
		if (value instanceof JsonEntity) {
			((JsonEntity)value).addPropertyChangeListener(propListener);
		}
		
		firePropertyChange("#" + (values.size() - 1), null, value);
	}
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);
            }
        }
    }
634227
public void addPropertyChangeListener(PropertyChangeListener listener) {
		if (listener instanceof PropertyChangeListenerProxy) {
			PropertyChangeListenerProxy proxy = (PropertyChangeListenerProxy) listener;
			addPropertyChangeListener(proxy.getPropertyName(), (PropertyChangeListener) proxy.getListener());
		}
		else {
			if (listeners == null) {
				listeners = new EventListenerList();
			}
			listeners.add(PropertyChangeListener.class, listener);
		}
	}
1104393
public void propertyChange(final java.beans.PropertyChangeEvent p1) {
        this.firePropertyChange(p1.getPropertyName(), p1.getOldValue(), p1.getNewValue());
    }