Java WritableValue类代码示例

import javafx.beans.value.WritableValue; //导入依赖的package包/类
private void animateValue(double from,
                          double to,
                          Duration duration,
                          Interpolator interpolator, DoubleConsumer consumer,
                          EventHandler<ActionEvent> l) {
	timeline.stop();
	timeline.getKeyFrames().clear();
	KeyValue keyValue = new KeyValue(new WritableValue<Double>() {
		@Override
		public Double getValue() {
			return from;
		}
		@Override
		public void setValue(Double value) {
			consumer.accept(value);
		}
	}, to, interpolator == null ? Interpolator.LINEAR : interpolator);
	timeline.getKeyFrames().add(new KeyFrame(duration, keyValue));
	timeline.setOnFinished(l);
	timeline.play();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
private static <T> T setIfUpdate(ObservableMap<? extends String, ? extends Object> map,
        String key, WritableValue<T>... props) {
    T newValue = (T) map.get(key);
    if (newValue != null) {
        boolean stringEmpty = false;
        if (newValue instanceof String) {
            String newStr = (String) newValue;
            stringEmpty = newStr.isEmpty();
        }
        for (WritableValue<T> prop : props) {
            if (stringEmpty) {
                if (prop.getValue() == null) {
                    prop.setValue(newValue);
                }
            } else {
                prop.setValue(newValue);
            }
        }
    }
    return newValue;
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
protected <T extends Enum<T>> Supplier<WritableValue<String>> enumToString(Class<T> enumClass, ObjectProperty<T> property) {
    return () -> {
        val stringProperty = new SimpleStringProperty();
        stringProperty.bindBidirectional(property, new StringConverter<T>() {
            @Override
            public String toString(T object) {
                if (object == null) {
                    return "null";
                }
                return object.name();
            }

            @Override
            public T fromString(String string) {
                if ("null".equals(string)) {
                    return null;
                }
                try {
                    return Enum.valueOf(enumClass, string);
                } catch (IllegalArgumentException e) {
                    try {
                        val number = (int) Double.parseDouble(string);
                        return enumClass.cast(EnumSet.allOf(enumClass).toArray()[number]);
                    } catch (Exception ex) {
                        throw new HotaruRuntimeException("No constant " + string
                                + " for type " + enumClass.getSimpleName());
                    }
                }
            }
        });
        return stringProperty;
    };
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
public void propertyCopy(Node from, Node to) throws Exception {
	Method[] fromMethods = from.getClass().getMethods();

	Class<? extends Node> class1 = to.getClass();
	for (Method fromMethod : fromMethods) {
		String methodName = fromMethod.getName();
		if (methodName.endsWith("Property")) {

			Method targetMethod = class1.getMethod(methodName);
			targetMethod.setAccessible(true);
			if (targetMethod != null) {
				Object fromPropertValue = fromMethod.invoke(from);
				Object toPropertValue = targetMethod.invoke(from);

				if (Property.class.isAssignableFrom(fromPropertValue.getClass())) {
					if (WritableValue.class.isAssignableFrom(fromPropertValue.getClass())) {

						// System.out.println("Writable : " +
						// fromPropertValue);
						// if
						// (StyleConverter.class.isAssignableFrom(fromPropertValue.getClass()))
						// {

						Property fromProp = (Property) fromPropertValue;
						Property toProp = (Property) toPropertValue;
						Object value = fromProp.getValue();
						if (value == null)
							continue;
						System.out.println("set value : " + fromProp.getValue());
						toProp.setValue(fromProp.getValue());
					}

					// }
				}
			}

		}
	}

}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
public PropertyTimeline<T> setIfEmptyThenGet(Supplier<WritableValue<T>> supplier) {
    return setIfEmpty(wrap(supplier)).get();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
private Supplier<PropertyTimeline<T>> wrap(Supplier<WritableValue<T>> supplier) {
    return () -> new PropertyTimeline<>(supplier.get());
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
public PropertyTimeline(WritableValue<T> property) {
    this.property = property;
    keyFrames = new TreeMap<>();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
    WritableValue<T> property = createProperty();
    final T value = (T) context.convertAnother(null, readType(reader));
    property.setValue(value);
    return property;
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
@Override
protected WritableValue<Boolean> createProperty() {
    return new SimpleBooleanProperty();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
@Override
protected WritableValue<String> createProperty() {
    return new SimpleStringProperty();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
@Override
protected WritableValue<Number> createProperty() {
    return new SimpleLongProperty();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
@Override
protected WritableValue<Number> createProperty() {
    return new SimpleIntegerProperty();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
@Override
protected WritableValue<Object> createProperty() {
    return new SimpleObjectProperty();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
@Override
protected WritableValue<Number> createProperty() {
    return new SimpleDoubleProperty();
}
 

import javafx.beans.value.WritableValue; //导入依赖的package包/类
public void setProperty(Node node, String name, Object value) {
	try {
		if (value == null)
			return;
		Method method = node.getClass().getMethod(name + "Property");
		if (method == null)
			return;

		method.setAccessible(true);

		Object fromPropertValue = method.invoke(node);
		if (Property.class.isAssignableFrom(fromPropertValue.getClass())) {
			if (WritableValue.class.isAssignableFrom(fromPropertValue.getClass())) {

				Method setMethod = null;
				if (fromPropertValue instanceof BooleanProperty || fromPropertValue instanceof DoubleProperty) {
					setMethod = fromPropertValue.getClass().getMethod("setValue", Object.class);
				} else {
					setMethod = fromPropertValue.getClass().getMethod("set", Object.class);
				}

				if (setMethod != null) {
					setMethod.setAccessible(true);
					if (value.getClass().isPrimitive()) {
						setMethod.invoke(fromPropertValue, value.getClass());
					} else {
						setMethod.invoke(fromPropertValue, value);
					}

				}
			}
			else
			{
				
			}
		}
		else
		{
			System.out.println(fromPropertValue);
		}
	} catch (Exception e) {
		System.out.println("error prop name : " + name + " value : " + value + " value type : " + value.getClass());
		// e.printStackTrace();
	}

}