Re: add calculating methods to bind
That would be nice. Don't forget to add it to JIRA!
-Martin
On 23.5.2014 07:11, Tom Eugelink wrote:
I feel the standard binding should offer an easy hook option
heightProperty().multiply(3.4).calc( value - { snap(vallue); }
).add(5.0)
On 2014-5-21 22:00, Tomas Mikula wrote:
Just a side note, you could use
EasyBind.map(heightProperty(), value -
NodeUtil.snapXY(value.doubleValue() * 0.2));
instead of
snap(heightProperty().multiply(0.2))
and you don't need your custom DoubleBinding implementation. But note
that it returns BindingDouble, not DoubleBinding.
EasyBind is at http://www.fxmisc.org/easybind/
Tomas
On Wed, May 21, 2014 at 9:47 PM, Tomas Mikula
tomas.mik...@gmail.com wrote:
Yeah, and you could also eliminate Observable... dependencies from
snap's signature, since now you are not using them to invalidate your
binding.
On Wed, May 21, 2014 at 9:36 PM, Tom Eugelink t...@tbee.org wrote:
Found it! Slightly different DoubleBinding was required (copied it
from
negate).
private DoubleBinding snap(final ObservableNumberValue value,
final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(value);
}
@Override
public void dispose() {
super.unbind(value);
}
@Override
protected double computeValue() {
return NodeUtil.snapXY(value.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return FXCollections.singletonObservableList(value);
}
};
}
On 2014-5-21 21:34, Tomas Mikula wrote:
Hi Tom,
it seems to me that in your custom DoubleBinding implementation
`other` is not its dependency, thus it does not react to it's
invalidations.
Tomas
On Wed, May 21, 2014 at 9:25 PM, Tom Eugelink t...@tbee.org wrote:
I came up with this:
startXProperty().bind( *snap(*heightProperty().multiply(0.2)) )
And then:
private DoubleBinding snap(final ObservableNumberValue
other, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(dependencies);
}
@Override
public void dispose() {
super.unbind(dependencies);
}
@Override
protected double computeValue() {
return NodeUtil.snap(other.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return new
ImmutableObservableListObservable(dependencies);
}
};
}
But that always returns 0... I feel this should have worked.
Tom
Re: add calculating methods to bind
https://javafx-jira.kenai.com/browse/RT-37255
On 2014-5-23 8:05, Martin Sladecek wrote:
That would be nice. Don't forget to add it to JIRA!
-Martin
On 23.5.2014 07:11, Tom Eugelink wrote:
I feel the standard binding should offer an easy hook option
heightProperty().multiply(3.4).calc( value - { snap(vallue); } ).add(5.0)
On 2014-5-21 22:00, Tomas Mikula wrote:
Just a side note, you could use
EasyBind.map(heightProperty(), value -
NodeUtil.snapXY(value.doubleValue() * 0.2));
instead of
snap(heightProperty().multiply(0.2))
and you don't need your custom DoubleBinding implementation. But note
that it returns BindingDouble, not DoubleBinding.
EasyBind is at http://www.fxmisc.org/easybind/
Tomas
On Wed, May 21, 2014 at 9:47 PM, Tomas Mikula tomas.mik...@gmail.com wrote:
Yeah, and you could also eliminate Observable... dependencies from
snap's signature, since now you are not using them to invalidate your
binding.
On Wed, May 21, 2014 at 9:36 PM, Tom Eugelink t...@tbee.org wrote:
Found it! Slightly different DoubleBinding was required (copied it from
negate).
private DoubleBinding snap(final ObservableNumberValue value, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(value);
}
@Override
public void dispose() {
super.unbind(value);
}
@Override
protected double computeValue() {
return NodeUtil.snapXY(value.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return FXCollections.singletonObservableList(value);
}
};
}
On 2014-5-21 21:34, Tomas Mikula wrote:
Hi Tom,
it seems to me that in your custom DoubleBinding implementation
`other` is not its dependency, thus it does not react to it's
invalidations.
Tomas
On Wed, May 21, 2014 at 9:25 PM, Tom Eugelink t...@tbee.org wrote:
I came up with this:
startXProperty().bind( *snap(*heightProperty().multiply(0.2)) )
And then:
private DoubleBinding snap(final ObservableNumberValue other, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(dependencies);
}
@Override
public void dispose() {
super.unbind(dependencies);
}
@Override
protected double computeValue() {
return NodeUtil.snap(other.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return new
ImmutableObservableListObservable(dependencies);
}
};
}
But that always returns 0... I feel this should have worked.
Tom
Re: add calculating methods to bind
I feel the standard binding should offer an easy hook option
heightProperty().multiply(3.4).calc( value - { snap(vallue); } ).add(5.0)
On 2014-5-21 22:00, Tomas Mikula wrote:
Just a side note, you could use
EasyBind.map(heightProperty(), value -
NodeUtil.snapXY(value.doubleValue() * 0.2));
instead of
snap(heightProperty().multiply(0.2))
and you don't need your custom DoubleBinding implementation. But note
that it returns BindingDouble, not DoubleBinding.
EasyBind is at http://www.fxmisc.org/easybind/
Tomas
On Wed, May 21, 2014 at 9:47 PM, Tomas Mikula tomas.mik...@gmail.com wrote:
Yeah, and you could also eliminate Observable... dependencies from
snap's signature, since now you are not using them to invalidate your
binding.
On Wed, May 21, 2014 at 9:36 PM, Tom Eugelink t...@tbee.org wrote:
Found it! Slightly different DoubleBinding was required (copied it from
negate).
private DoubleBinding snap(final ObservableNumberValue value, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(value);
}
@Override
public void dispose() {
super.unbind(value);
}
@Override
protected double computeValue() {
return NodeUtil.snapXY(value.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return FXCollections.singletonObservableList(value);
}
};
}
On 2014-5-21 21:34, Tomas Mikula wrote:
Hi Tom,
it seems to me that in your custom DoubleBinding implementation
`other` is not its dependency, thus it does not react to it's
invalidations.
Tomas
On Wed, May 21, 2014 at 9:25 PM, Tom Eugelink t...@tbee.org wrote:
I came up with this:
startXProperty().bind( *snap(*heightProperty().multiply(0.2)) )
And then:
private DoubleBinding snap(final ObservableNumberValue other, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(dependencies);
}
@Override
public void dispose() {
super.unbind(dependencies);
}
@Override
protected double computeValue() {
return NodeUtil.snap(other.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return new
ImmutableObservableListObservable(dependencies);
}
};
}
But that always returns 0... I feel this should have worked.
Tom
Re: add calculating methods to bind
Hi Tom,
it seems to me that in your custom DoubleBinding implementation
`other` is not its dependency, thus it does not react to it's
invalidations.
Tomas
On Wed, May 21, 2014 at 9:25 PM, Tom Eugelink t...@tbee.org wrote:
I came up with this:
startXProperty().bind( *snap(*heightProperty().multiply(0.2)) )
And then:
private DoubleBinding snap(final ObservableNumberValue other, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(dependencies);
}
@Override
public void dispose() {
super.unbind(dependencies);
}
@Override
protected double computeValue() {
return NodeUtil.snap(other.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return new
ImmutableObservableListObservable(dependencies);
}
};
}
But that always returns 0... I feel this should have worked.
Tom
Re: add calculating methods to bind
Found it! Slightly different DoubleBinding was required (copied it from negate).
private DoubleBinding snap(final ObservableNumberValue value, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(value);
}
@Override
public void dispose() {
super.unbind(value);
}
@Override
protected double computeValue() {
return NodeUtil.snapXY(value.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return FXCollections.singletonObservableList(value);
}
};
}
On 2014-5-21 21:34, Tomas Mikula wrote:
Hi Tom,
it seems to me that in your custom DoubleBinding implementation
`other` is not its dependency, thus it does not react to it's
invalidations.
Tomas
On Wed, May 21, 2014 at 9:25 PM, Tom Eugelink t...@tbee.org wrote:
I came up with this:
startXProperty().bind( *snap(*heightProperty().multiply(0.2)) )
And then:
private DoubleBinding snap(final ObservableNumberValue other, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(dependencies);
}
@Override
public void dispose() {
super.unbind(dependencies);
}
@Override
protected double computeValue() {
return NodeUtil.snap(other.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return new
ImmutableObservableListObservable(dependencies);
}
};
}
But that always returns 0... I feel this should have worked.
Tom
Re: add calculating methods to bind
Yeah, and you could also eliminate Observable... dependencies from
snap's signature, since now you are not using them to invalidate your
binding.
On Wed, May 21, 2014 at 9:36 PM, Tom Eugelink t...@tbee.org wrote:
Found it! Slightly different DoubleBinding was required (copied it from
negate).
private DoubleBinding snap(final ObservableNumberValue value, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(value);
}
@Override
public void dispose() {
super.unbind(value);
}
@Override
protected double computeValue() {
return NodeUtil.snapXY(value.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return FXCollections.singletonObservableList(value);
}
};
}
On 2014-5-21 21:34, Tomas Mikula wrote:
Hi Tom,
it seems to me that in your custom DoubleBinding implementation
`other` is not its dependency, thus it does not react to it's
invalidations.
Tomas
On Wed, May 21, 2014 at 9:25 PM, Tom Eugelink t...@tbee.org wrote:
I came up with this:
startXProperty().bind( *snap(*heightProperty().multiply(0.2)) )
And then:
private DoubleBinding snap(final ObservableNumberValue other, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(dependencies);
}
@Override
public void dispose() {
super.unbind(dependencies);
}
@Override
protected double computeValue() {
return NodeUtil.snap(other.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return new
ImmutableObservableListObservable(dependencies);
}
};
}
But that always returns 0... I feel this should have worked.
Tom
Re: add calculating methods to bind
Just a side note, you could use
EasyBind.map(heightProperty(), value -
NodeUtil.snapXY(value.doubleValue() * 0.2));
instead of
snap(heightProperty().multiply(0.2))
and you don't need your custom DoubleBinding implementation. But note
that it returns BindingDouble, not DoubleBinding.
EasyBind is at http://www.fxmisc.org/easybind/
Tomas
On Wed, May 21, 2014 at 9:47 PM, Tomas Mikula tomas.mik...@gmail.com wrote:
Yeah, and you could also eliminate Observable... dependencies from
snap's signature, since now you are not using them to invalidate your
binding.
On Wed, May 21, 2014 at 9:36 PM, Tom Eugelink t...@tbee.org wrote:
Found it! Slightly different DoubleBinding was required (copied it from
negate).
private DoubleBinding snap(final ObservableNumberValue value, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(value);
}
@Override
public void dispose() {
super.unbind(value);
}
@Override
protected double computeValue() {
return NodeUtil.snapXY(value.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return FXCollections.singletonObservableList(value);
}
};
}
On 2014-5-21 21:34, Tomas Mikula wrote:
Hi Tom,
it seems to me that in your custom DoubleBinding implementation
`other` is not its dependency, thus it does not react to it's
invalidations.
Tomas
On Wed, May 21, 2014 at 9:25 PM, Tom Eugelink t...@tbee.org wrote:
I came up with this:
startXProperty().bind( *snap(*heightProperty().multiply(0.2)) )
And then:
private DoubleBinding snap(final ObservableNumberValue other, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(dependencies);
}
@Override
public void dispose() {
super.unbind(dependencies);
}
@Override
protected double computeValue() {
return NodeUtil.snap(other.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return new
ImmutableObservableListObservable(dependencies);
}
};
}
But that always returns 0... I feel this should have worked.
Tom
Re: add calculating methods to bind
If I ever write a real application, I'm most definitely will use EasyBind. But
this is for sharping up Agenda in JFXtras. I try to minimize the dependencies.
Tom
On 2014-5-21 22:00, Tomas Mikula wrote:
Just a side note, you could use
EasyBind.map(heightProperty(), value -
NodeUtil.snapXY(value.doubleValue() * 0.2));
instead of
snap(heightProperty().multiply(0.2))
and you don't need your custom DoubleBinding implementation. But note
that it returns BindingDouble, not DoubleBinding.
EasyBind is at http://www.fxmisc.org/easybind/
Tomas
On Wed, May 21, 2014 at 9:47 PM, Tomas Mikula tomas.mik...@gmail.com wrote:
Yeah, and you could also eliminate Observable... dependencies from
snap's signature, since now you are not using them to invalidate your
binding.
On Wed, May 21, 2014 at 9:36 PM, Tom Eugelink t...@tbee.org wrote:
Found it! Slightly different DoubleBinding was required (copied it from
negate).
private DoubleBinding snap(final ObservableNumberValue value, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(value);
}
@Override
public void dispose() {
super.unbind(value);
}
@Override
protected double computeValue() {
return NodeUtil.snapXY(value.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return FXCollections.singletonObservableList(value);
}
};
}
On 2014-5-21 21:34, Tomas Mikula wrote:
Hi Tom,
it seems to me that in your custom DoubleBinding implementation
`other` is not its dependency, thus it does not react to it's
invalidations.
Tomas
On Wed, May 21, 2014 at 9:25 PM, Tom Eugelink t...@tbee.org wrote:
I came up with this:
startXProperty().bind( *snap(*heightProperty().multiply(0.2)) )
And then:
private DoubleBinding snap(final ObservableNumberValue other, final
Observable... dependencies) {
return new DoubleBinding() {
{
super.bind(dependencies);
}
@Override
public void dispose() {
super.unbind(dependencies);
}
@Override
protected double computeValue() {
return NodeUtil.snap(other.doubleValue());
}
@Override
public ObservableList? getDependencies() {
return new
ImmutableObservableListObservable(dependencies);
}
};
}
But that always returns 0... I feel this should have worked.
Tom
