Hi everyone,
I'm interested in hearing your thoughts on the following proposal,
which could increase the expressiveness of the JavaFX Property API:
Problem
-------
The JavaFX CSS system applies the following order of precedence to
determine the value of a styleable property (in ascending
specificity):
1. user-agent stylesheets
2. values set from code
3. Scene stylesheets
4. Parent stylesheets
5. inline styles
While this system works quite well in general, applications sometimes
need to override individual property values from code. However, this
doesn't work reliably in the presence of Scene or Parent stylesheets.
There are two usual workarounds to solve this problem:
A) Use an inline style instead of setting the property value directly.
This is obviously not a good solution, as you'll lose the strong
typing afforded by the Java language. Additionally, the value must be
a true constant, it can't be an expression or the result of a
computation.
B) Create an `ObservableValue` instance that holds the desired value,
and bind the property to it.
This is a much better solution. However, what we really want is just
the binding semantics: the bound property becomes unmodifiable and has
the highest precedence in the CSS cascade. But the API only gives us
binding semantics if we give it an `ObservableValue`.
Solution
--------
I'm proposing to separate the toggles "binding semantics" and
"observability". While observability requires you to provide an
`ObservableValue`, binding semantics should work with both observable
and regular values.
This is a powerful addition to the Property API, since it increases
the expressiveness of the API in a natural way:
// instead of:
rect.setStyle("-fx-fill: red; -fx-width: 200");
// you can use strongly-typed Java code:
rect.fillProperty().bindConstant(Color.RED);
rect.widthProperty().bindConstant(200);
Since the `bindConstant` method accepts a value of the property type,
all features of the Java language can be used to fill in the value.
Implementation
--------------
The following method will be added to the `Property` interface:
default void bindConstant(T value) {
bind(ObjectConstant.valueOf(value));
}
Specialized methods will be added to `BooleanProperty`,
`DoubleProperty`, `FloatProperty`, `IntegerProperty`, and
`LongProperty`, each with one of the preexisting constant wrappers
that are already in the framework.
Some wrappers can be deduplicated (we only ever need two wrapper
instances for boolean values).
