Updates this value and notifies all listeners. This will notify the listeners regardless of
whether the supplied value differs from the current value.
422023
public void update (T value)
    {
        // store our new current value
        _value = value;

        // notify our listeners; we snapshot our listeners before iterating to avoid problems if
        // listeners add or remove themselves while we're dispatching this notification
        for (Listener<T> listener : new ArrayList<Listener<T>>(_listeners)) {
            listener.valueChanged(value);
        }
    }
714915
protected void fireValueChange() {
		if (this.listeners != null) {
			final ProgressionEvent event = new ProgressionEvent(this, isRootModel());
			for (final ProgressionListener listener : this.listeners.getListeners(ProgressionListener.class)) {
				listener.onProgressionValueChanged(event);
			}
		}
	}
302715
void fireUpdated(Object source) {
		if (updateDisable) {
			return;
		}
		
		if (source == maxSpinner) {
			if (getMax() < getMin()) {
				setMin(getMax());
			}
		}
		if (source == minSpinner) {
			if (getMax() < getMin()) {
				setMax(getMin());
			}
		}
		
		for (int i=0;i<listeners.size();i++) {
			((InputPanelListener) listeners.get(i)).minMaxUpdated(this);
		}
	}
141404
def update(self, value=None, label=None):
        
        if label:
            self.label = label

        super(ProgressBar, self).update(value)
71938
def add_listener(self, listener, question):
        """"""
        now = current_time_millis()
        self.listeners.append(listener)
        if question is not None:
            for record in self.cache.entries_with_name(question.name):
                if question.answered_by(record) and not record.is_expired(now):
                    listener.update_record(self, now, record)
        self.notify_all()
511173
@Override
	public void update() {
		synchronized (this) {
			long currentTime = System.currentTimeMillis();
			if (currentTime - lastUpdateTime > updateInterval) {
				lastUpdateTime = currentTime;
				fetchMetrics();
			}
		}
	}
966825
public void update() {
        if (this.measures == null || this.measures.length == 0) {
            // no measures to show -> empty entries
            for (int i = 0; i < this.currentValues.length; i++) {
                this.currentValues[i].setText("-");
                this.meanValues[i].setText("-");
            }
            return;
        }
        
        DecimalFormat d = new DecimalFormat("0.00");
        
        MeasureCollection mc;
        if (this.measures.length > this.measureCollectionSelected) {
        	mc = this.measures[this.measureCollectionSelected];
        }
        else {
        	mc = this.measures[0];
        }
        
        for (int i = 0; i < this.currentValues.length; i++) {
            // set current value
            if(Double.isNaN(mc.getLastValue(i))) {
                this.currentValues[i].setText("-");
            } else {
                this.currentValues[i].setText(d.format(mc.getLastValue(i)));
            }
            
            // set mean value
            if(Double.isNaN(mc.getMean(i))) {
                this.meanValues[i].setText("-");
            } else {
                this.meanValues[i].setText(d.format(mc.getMean(i)));
            }
        } 
    }
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);
        }
    }
195202
def set(self, value: Optional[bool]):
        
        prev_value = self._value
        self._value = value
        if self._value != prev_value:
            # notify all watchers that this check was changed
            for event in self._events:
                event.set()
24381
private void addListeners() {
	    this.min.xProperty().addListener((observable, oldValue, nValue) -> {
            final int currentMin = nValue.intValue();
            final int currentMax = getMaxX();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                maxXProperty().set(currentMin);
            }
        });
        this.min.yProperty().addListener((observable, oValue, nValue) -> {
            final int currentMin = nValue.intValue();
            final int currentMax = getMaxY();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                maxYProperty().set(currentMin);
            }
        });
        this.min.zProperty().addListener((observable, oValue, nValue) -> {
            final int currentMin = nValue.intValue();
            final int currentMax = getMaxZ();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                maxZProperty().set(currentMin);
            }
        });
        this.max.xProperty().addListener((observable, oValue, nValue) -> {
            final int currentMax = nValue.intValue();
            final int currentMin = getMinX();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                minXProperty().set(currentMax);
            }
        });
        this.max.yProperty().addListener((observable, oValue, nValue) -> {
            final int currentMax = nValue.intValue();
            final int currentMin = getMinY();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                minYProperty().set(currentMax);
            }
        });
        this.max.zProperty().addListener((observable, oValue, nValue) -> {
            final int currentMax = nValue.intValue();
            final int currentMin = getMinZ();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                minZProperty().set(currentMax);
            }
        });
    }
789386
public void notifyChanged() {
        if (listeners != null) {
            synchronized (notifyLock) {
                if (listeners != null) {
                    if (notifyThread == null) {
                        notifyThread = new NotifyThread(this);
                        notifyThread.setDaemon(true);
                        notifyThread.start();
                    }
                    notifyThread.queue(listeners.toArray(new EventListener[listeners.size()]));
                }
            }
        }
    }
425143
void updateListenersWithNewConfiguration(T newConfiguration) {
        for (ConfigurationListener<T> listener : listeners) {
            try {
                listener.updated(newConfiguration);
            } catch (Exception e) {
                logger.error("Updating a listener with new configuration failed.", e);
            }
        }
    }
569491
private void updateValue() {
        if (table != null) {
            int oldCount = this.count;
            this.count = table.getRowCount();
            maybeNotifyListeners(oldCount, count);
        }
    }
887384
protected void doNotifyListenersOfAddedValues(Map<K, R> newValues) {
        List<MapValueChangeListener<K, R>> listenersCopy = new ArrayList<MapValueChangeListener<K, R>>(listeners);
        Map<K, R> unmodifiable = Collections.unmodifiableMap(newValues);
        for (MapValueChangeListener<K, R> listener : listenersCopy) {
            listener.valuesAdded(this, unmodifiable);
        }
    }
94511
private void updateAttackHit()
    {
        if (!attacking)
        {
            for (final AttackerListener listener : listeners)
            {
                listener.notifyAttackStarted(target);
            }
            attacking = true;
            attacked = false;
        }
        // Hit when frame attack reached
        if (animator.getFrame() >= frameAttack)
        {
            attacking = false;
            for (final AttackerListener listener : listeners)
            {
                listener.notifyAttackEnded(damages.getRandom(), target);
            }
            attacked = true;
            tick.restart();
        }
    }
1300741
function(value) {

		Lava.suspendListener(this._property_changed_listener);
		this._view.set(this._property_name, value);
		Lava.resumeListener(this._property_changed_listener);

		this._queueForRefresh();

	}
1337077
protected void notifyListeners() {
		Iterator it = listeners.iterator();
		while (it.hasNext()) {
			((ComponentListener) it.next()).componentActivated(this);
		}
	}