How to use

WritableValue

in

javafx.beans.value

public void applyEndValues() {
  for (JFXKeyValue keyValue : keyValues) {
    if (keyValue.isValid()) {
      final WritableValue target = keyValue.getTarget();
      if (target != null) {
        final Object endValue = keyValue.getEndValue();
        if (endValue != null && !target.getValue().equals(endValue)) {
          target.setValue(endValue);
        }
      }
    }
  }
}

public void applyCloseValues(){
  target.setValue(getCloseValueSupplier().get());
}

void reverse(double now) {
  currentDuration = duration - (currentDuration - now);
  // update initial values
  for (JFXKeyValue keyValue : keyValues) {
    final WritableValue target = keyValue.getTarget();
    if (target != null) {
      initialValuesMap.put(target, target.getValue());
      endValuesMap.put(target, keyValue.getEndValue());
    }
  }
}

public void applyOpenValues() {
  target.setValue(getOpenValueSupplier().get());
}

public void init() {
  finished = false;
  for (JFXKeyValue keyValue : keyValues) {
    if (keyValue.getTarget() != null) {
      // replaced putIfAbsent for mobile compatibility
      if (!initialValuesMap.containsKey(keyValue.getTarget())) {
        initialValuesMap.put(keyValue.getTarget(), keyValue.getTarget().getValue());
      }
      if (!endValuesMap.containsKey(keyValue.getTarget())) {
        endValuesMap.put(keyValue.getTarget(), keyValue.getEndValue());
      }
    }
  }
}

public void animate(double now) {
  if (now <= currentDuration) {
    for (JFXKeyValue keyValue : keyValues) {
      if (keyValue.isValid()) {
        final WritableValue target = keyValue.getTarget();
        final Object endValue = endValuesMap.get(target);
        if (endValue != null && target != null && !target.getValue().equals(endValue)) {
          target.setValue(keyValue.getInterpolator().interpolate(initialValuesMap.get(target), endValue, now / currentDuration));
        }
      }
    }
  } else {
    if (!finished) {
      finished = true;
      for (JFXKeyValue keyValue : keyValues) {
        if (keyValue.isValid()) {
          final WritableValue target = keyValue.getTarget();
          if (target != null) {
            // set updated end value instead of cached
            final Object endValue = keyValue.getEndValue();
            if (endValue != null) {
              target.setValue(endValue);
            }
          }
        }
      }
      currentDuration = duration;
    }
  }
}

  @SuppressWarnings("unchecked")
  @Override
  protected void doSetValue(Object value) {
    property.setValue((T) value);
  }
};

@Override
protected Object doGetValue() {
  return property.getValue();
}

  @Override
  public void setValue(W w) {
    if (!ValueUtils.areEqual(wrapped.getValue(), w)) {
      wrapped.setValue(w);
    }
  }
}

  @Override
  public void changed(ObservableValue<? extends E> observable, E oldValue, E newValue) {
    if (this.syncing) {
      return;
    }
    try {
      this.syncing = true;
      if (observable == fxObs) {
        dbObs.setValue(newValue);
      } else {
        fxObs.setValue(newValue);
      }
    } finally {
      this.syncing = false;
    }
  }
});

@Override
public boolean interpolate(boolean startValue, boolean endValue, double fraction) {
 return condition.getAsBoolean()
   ? interpolator.interpolate(startValue, endValue, fraction)
   : (boolean) target.getValue();
}

public void applyEndValues() {
  for (JFXKeyValue keyValue : keyValues) {
    if (keyValue.isValid()) {
      final WritableValue target = keyValue.getTarget();
      if (target != null) {
        final Object endValue = keyValue.getEndValue();
        if (endValue != null && !target.getValue().equals(endValue)) {
          target.setValue(endValue);
        }
      }
    }
  }
}

public void applyOpenValues() {
  target.setValue(getOpenValueSupplier().get());
}

@Override
public Object interpolate(Object startValue, Object endValue, double fraction) {
 return condition.getAsBoolean()
   ? interpolator.interpolate(startValue, endValue, fraction)
   : target.getValue();
}

public void animate(double now) {
  if (now <= currentDuration) {
    for (JFXKeyValue keyValue : keyValues) {
      if (keyValue.isValid()) {
        final WritableValue target = keyValue.getTarget();
        final Object endValue = endValuesMap.get(target);
        if (endValue != null && target != null && !target.getValue().equals(endValue)) {
          target.setValue(keyValue.getInterpolator().interpolate(initialValuesMap.get(target), endValue, now / currentDuration));
        }
      }
    }
  } else {
    if (!finished) {
      finished = true;
      for (JFXKeyValue keyValue : keyValues) {
        if (keyValue.isValid()) {
          final WritableValue target = keyValue.getTarget();
          if (target != null) {
            // set updated end value instead of cached
            final Object endValue = keyValue.getEndValue();
            if (endValue != null) {
              target.setValue(endValue);
            }
          }
        }
      }
      currentDuration = duration;
    }
  }
}

public void applyCloseValues(){
  target.setValue(getCloseValueSupplier().get());
}

@Override
public double interpolate(double startValue, double endValue, double fraction) {
 return condition.getAsBoolean()
   ? interpolator.interpolate(startValue, endValue, fraction)
   : (double) target.getValue();
}

  @Override
  public <T> Binding to(Property<T> dolphinProperty, Converter<? super T, ? extends S> converter) {
    Assert.requireNonNull(dolphinProperty, "dolphinProperty");
    Assert.requireNonNull(converter, "converter");
    final Subscription subscription = dolphinProperty.onChanged(event -> javaFxValue.setValue(converter.convert(dolphinProperty.get())));
    javaFxValue.setValue(converter.convert(dolphinProperty.get()));
    return () -> subscription.unsubscribe();
  }
}

@Override
public int interpolate(int startValue, int endValue, double fraction) {
 return condition.getAsBoolean()
   ? interpolator.interpolate(startValue, endValue, fraction)
   : (int) target.getValue();
}

  @Override
  public <T> Binding to(final Property<T> remotingProperty, final Converter<? super T, ? extends S> converter) {
    Assert.requireNonNull(remotingProperty, "remotingProperty");
    Assert.requireNonNull(converter, "converter");
    final Subscription subscription = remotingProperty.onChanged(event -> javaFxValue.setValue(converter.convert(remotingProperty.get())));
    javaFxValue.setValue(converter.convert(remotingProperty.get()));
    return () -> subscription.unsubscribe();
  }
}