This looks good. I wonder if we should make this (massive) change
before we lambda graphics and controls? Probably doesn't matter. We'll
need a JIRA and someone assigned to it in order to track the work.
Steve
On 2014-03-21 12:53 PM, Tom Schindl wrote:
Hi Richard,
Coming back to this old thread and now that we are using lamdas all over
I guess we could take one more look into that.
I've prototyped an initial version by introducing a new internal type
named InvalidatedSimpleObjectProperty (not the best name ever!) - see
code pasted below.
And now one can write code like this:
public final ObjectProperty<Rectangle2D> viewportProperty() {
if (viewport == null) {
viewport = new InvalidatedSimpleObjectProperty<>(this, "viewport",
(o) -> {
invalidateWidthHeight();
impl_markDirty(DirtyBits.NODE_VIEWPORT);
impl_geomChanged();
} );
}
return viewport;
}
instead of
public final ObjectProperty<Rectangle2D> viewportProperty() {
if (viewport == null) {
viewport = new ObjectPropertyBase<Rectangle2D>() {
@Override
protected void invalidated() {
invalidateWidthHeight();
impl_markDirty(DirtyBits.NODE_VIEWPORT);
impl_geomChanged();
}
@Override
public Object getBean() {
return ImageView.this;
}
@Override
public String getName() {
return "viewport";
}
};
}
return viewport;
}
Which allows us to get rid of most of the ObjectPropertyBase sublcasses.
Tom
package com.sun.javafx.property;
import java.util.function.Consumer;
import javafx.beans.property.SimpleObjectProperty;
public final class InvalidatedSimpleObjectProperty<T> extends
SimpleObjectProperty<T> {
private final Consumer<InvalidatedSimpleObjectProperty<T>>
invalidationConsumer;
/**
* The constructor of {@code ObjectProperty}
*
* @param initialValue
* the initial value of the wrapped value
* @param invalidationConsumer
* the consumer to be called when the bean is
invalidated
*/
public InvalidatedSimpleObjectProperty(T initialValue, final
Consumer<InvalidatedSimpleObjectProperty<T>> invalidationConsumer) {
super(initialValue);
if( invalidationConsumer == null ) {
throw new IllegalArgumentException("Consumer can not be null");
}
this.invalidationConsumer = invalidationConsumer;
}
/**
* The constructor of {@code ObjectProperty}
*
* @param bean
* the bean of this {@code ObjectProperty}
* @param name
* the name of this {@code ObjectProperty}
* @param invalidationConsumer
* the consumer to be called when the bean is
invalidated
*/
public InvalidatedSimpleObjectProperty(Object bean, String name, final
Consumer<InvalidatedSimpleObjectProperty<T>> invalidationConsumer) {
super(bean, name);
if( invalidationConsumer == null ) {
throw new IllegalArgumentException("Consumer can not be null");
}
this.invalidationConsumer = invalidationConsumer;
}
/**
* The constructor of {@code ObjectProperty}
*
* @param bean
* the bean of this {@code ObjectProperty}
* @param name
* the name of this {@code ObjectProperty}
* @param initialValue
* the initial value of the wrapped value
* @param invalidationConsumer
* the consumer to be called when the bean is
invalidated
*/
public InvalidatedSimpleObjectProperty(Object bean, String name, T initialValue, final
Consumer<InvalidatedSimpleObjectProperty<T>> invalidationConsumer) {
super(bean,name,initialValue);
if( invalidationConsumer == null ) {
throw new IllegalArgumentException("Consumer can not be null");
}
this.invalidationConsumer = invalidationConsumer;
}
@Override
protected void invalidated() {
invalidationConsumer.accept(this);
}
}
On 22.01.13 10:30, Richard Bair wrote:
Is the Java8 plan still there if not should the current Simple*Property
subclasses who overload invalidated be changed to PropertyBase?
It is unlikely that we'll be able to do anything major here in Java 8 just
because we don't really have Lambda yet that we can play with, and changing
over every property is a big job. Unless we knew it would be a major win. I
would say, if you encounter a Simple* property that has been subclassed, then
we should fix it up as we go to be a PropertyBase* guy instead.
