javafx.beans.binding.MapBinding Maven / Gradle / Ivy
Show all versions of openjfx-78-backport Show documentation
/*
* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javafx.beans.binding;
import com.sun.javafx.binding.BindingHelperObserver;
import com.sun.javafx.binding.MapExpressionHelper;
import com.sun.javafx.collections.annotations.ReturnsUnmodifiableCollection;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.property.ReadOnlyBooleanProperty;
import javafx.beans.property.ReadOnlyBooleanPropertyBase;
import javafx.beans.property.ReadOnlyIntegerProperty;
import javafx.beans.property.ReadOnlyIntegerPropertyBase;
import javafx.beans.value.ChangeListener;
import javafx.collections.FXCollections;
import javafx.collections.MapChangeListener;
import javafx.collections.ObservableList;
import javafx.collections.ObservableMap;
/**
* Base class that provides most of the functionality needed to implement a
* {@link Binding} of an {@link javafx.collections.ObservableMap}.
*
* {@code MapBinding} provides a simple invalidation-scheme. An extending
* class can register dependencies by calling {@link #bind(Observable...)}.
* If one of the registered dependencies becomes invalid, this
* {@code MapBinding} is marked as invalid. With
* {@link #unbind(Observable...)} listening to dependencies can be stopped.
*
* To provide a concrete implementation of this class, the method
* {@link #computeValue()} has to be implemented to calculate the value of this
* binding based on the current state of the dependencies. It is called when
* {@link #get()} is called for an invalid binding.
*
* See {@link DoubleBinding} for an example how this base class can be extended.
*
* @see Binding
* @see MapExpression
*
* @param
* the type of the key elements
* @param
* the type of the value elements
* @since JavaFX 2.1
*/
public abstract class MapBinding extends MapExpression implements Binding> {
private final MapChangeListener mapChangeListener = new MapChangeListener() {
@Override
public void onChanged(Change change) {
invalidateProperties();
onInvalidating();
MapExpressionHelper.fireValueChangedEvent(helper, change);
}
};
private ObservableMap value;
private boolean valid = false;
private BindingHelperObserver observer;
private MapExpressionHelper helper = null;
private SizeProperty size0;
private EmptyProperty empty0;
@Override
public ReadOnlyIntegerProperty sizeProperty() {
if (size0 == null) {
size0 = new SizeProperty();
}
return size0;
}
private class SizeProperty extends ReadOnlyIntegerPropertyBase {
@Override
public int get() {
return size();
}
@Override
public Object getBean() {
return MapBinding.this;
}
@Override
public String getName() {
return "size";
}
protected void fireValueChangedEvent() {
super.fireValueChangedEvent();
}
}
@Override
public ReadOnlyBooleanProperty emptyProperty() {
if (empty0 == null) {
empty0 = new EmptyProperty();
}
return empty0;
}
private class EmptyProperty extends ReadOnlyBooleanPropertyBase {
@Override
public boolean get() {
return isEmpty();
}
@Override
public Object getBean() {
return MapBinding.this;
}
@Override
public String getName() {
return "empty";
}
protected void fireValueChangedEvent() {
super.fireValueChangedEvent();
}
}
@Override
public void addListener(InvalidationListener listener) {
helper = MapExpressionHelper.addListener(helper, this, listener);
}
@Override
public void removeListener(InvalidationListener listener) {
helper = MapExpressionHelper.removeListener(helper, listener);
}
@Override
public void addListener(ChangeListener> listener) {
helper = MapExpressionHelper.addListener(helper, this, listener);
}
@Override
public void removeListener(ChangeListener> listener) {
helper = MapExpressionHelper.removeListener(helper, listener);
}
@Override
public void addListener(MapChangeListener listener) {
helper = MapExpressionHelper.addListener(helper, this, listener);
}
@Override
public void removeListener(MapChangeListener listener) {
helper = MapExpressionHelper.removeListener(helper, listener);
}
/**
* Start observing the dependencies for changes. If the value of one of the
* dependencies changes, the binding is marked as invalid.
*
* @param dependencies
* the dependencies to observe
*/
protected final void bind(Observable... dependencies) {
if ((dependencies != null) && (dependencies.length > 0)) {
if (observer == null) {
observer = new BindingHelperObserver(this);
}
for (final Observable dep : dependencies) {
if (dep != null) {
dep.addListener(observer);
}
}
}
}
/**
* Stop observing the dependencies for changes.
*
* @param dependencies
* the dependencies to stop observing
*/
protected final void unbind(Observable... dependencies) {
if (observer != null) {
for (final Observable dep : dependencies) {
if (dep != null) {
dep.removeListener(observer);
}
}
observer = null;
}
}
/**
* A default implementation of {@code dispose()} that is empty.
*/
@Override
public void dispose() {
}
/**
* A default implementation of {@code getDependencies()} that returns an
* empty {@link javafx.collections.ObservableList}.
*
* @return an empty {@code ObservableList}
*/
@Override
@ReturnsUnmodifiableCollection
public ObservableList getDependencies() {
return FXCollections.emptyObservableList();
}
/**
* Returns the result of {@link #computeValue()}. The method
* {@code computeValue()} is only called if the binding is invalid. The
* result is cached and returned if the binding did not become invalid since
* the last call of {@code get()}.
*
* @return the current value
*/
@Override
public final ObservableMap get() {
if (!valid) {
value = computeValue();
valid = true;
if (value != null) {
value.addListener(mapChangeListener);
}
}
return value;
}
/**
* The method onInvalidating() can be overridden by extending classes to
* react, if this binding becomes invalid. The default implementation is
* empty.
*/
protected void onInvalidating() {
}
private void invalidateProperties() {
if (size0 != null) {
size0.fireValueChangedEvent();
}
if (empty0 != null) {
empty0.fireValueChangedEvent();
}
}
@Override
public final void invalidate() {
if (valid) {
if (value != null) {
value.removeListener(mapChangeListener);
}
valid = false;
invalidateProperties();
onInvalidating();
MapExpressionHelper.fireValueChangedEvent(helper);
}
}
@Override
public final boolean isValid() {
return valid;
}
/**
* Calculates the current value of this binding.
*
* Classes extending {@code MapBinding} have to provide an implementation
* of {@code computeValue}.
*
* @return the current value
*/
protected abstract ObservableMap computeValue();
/**
* Returns a string representation of this {@code MapBinding} object.
* @return a string representation of this {@code MapBinding} object.
*/
@Override
public String toString() {
return valid ? "MapBinding [value: " + get() + "]"
: "MapBinding [invalid]";
}
}