http://blogs.oracle.com/javafx/entry/javafx_2_0_is_cross

Download:

http://www.oracle.com/technetwork/java/javafx/downloads/devpreview-1429449.html

I think I will take a closer look in a few days…

There are a lot of changes waiting in line. While the 0.7 release will be a huge step, I am really looking forward for 0.8…

So if you want to take a look at the latest changes, just check out the source code at http://code.google.com/p/jfxtras/source/checkout.

At the moment the code is located at a clone that will be integrated as soon as JFXtras 0.7 has been released.

The clone can be accessed there:

https://js-mavenization.googlecode.com/hg/

The package is named “org.jfxtras.bridge”.

the first release candidate for JFXtras 0.7 has been released. This version is (should be) fully functional with JavaFX 1.3
Downloads can be found at http://jfxtras.org/

It has taken me some time to figure out how this could be solved. And at the moment I am in the progress of adding that stuff to the JFXtras project.
This will take some time until I have taken all necessary steps.

Until then i want to give you a quick jar that can be used to try that stuff…

To try it, download that jar and add it to the classpath of your JavaFX project:
bridge-1.0.0-SNAPSHOT-jar-with-dependencies

There are two ways of synchronization. At first it is possible to listen for changes to Java objects and update an JavaFX object accordingly. At the moment I have implemented two ways to listen for updates.

Java to JavaFX

• PropertyChangeEvents: This is the recommended way: Just make your Java bean fire PropertyChangeEvents whenever a property has changed.
• Busy waiting: I have added a hackish way of busy waiting. This should not be used in production code. But it offers a fast way to test things

JavaFX to Java

The reverse way has also two ways implemented:

• Calling of setters: If a JavaFX var is updated, this bridge calls the corresponding setter of your Java object (using reflection or optionally your own optimized implementation).
• PropertyChangeEvents: It is possible to create a bridge that converts the JavaFX binding
  updates to PropertyChangeEvents.

With inverse…

Of course it is also possible (and most of the time necessary) to create bindings with inverse. I give you a small sample how this might work here:

We create our Java “model”:
[cc lang="java"]package fxbindingtest;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

public class JavaClass {
private float amount = 99;

public float getAmount() {
return amount;
}

public void setAmount(float amount) {
pcs.firePropertyChange(“amount”, this.amount, this.amount=amount);
System.out.println(“Changed amount to ” + amount );
}

final PropertyChangeSupport pcs = new PropertyChangeSupport(this);

public void addPropertyChangeListener( PropertyChangeListener listener) {
pcs.addPropertyChangeListener(listener);
}

public void removePropertyChangeListener( PropertyChangeListener listener) {
pcs.removePropertyChangeListener(listener);
}
}
[/cc]

And here comes our JavaFX stage. This stage contains just a slider that is bound to the Java object (with inverse).
Every five seconds the model object is updated (amount+=10) – and reflected by the slider.

[cc lang="c"]package fxbindingtest;

import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.control.Slider;
import com.cedarsoft.fx.JavaFxBridge;
import com.sun.javafx.runtime.FXObject;
import javafx.animation.Timeline;
import javafx.animation.KeyFrame;

/**
* @author johannes
*/
var slider: Slider;

//The java model class. Contains the property “amount” and a PropertyChangeSupport
def javaModel = new JavaClass();

Stage {
title: “Application title”
scene: Scene {
width: 800
height: 600
content: [
slider = Slider {
min: 1
max: 100
snapToTicks: true
}
]
}
}

//Create the binding from the java model to the slider
//Using the defaults:
// Java –> FX: PropertyChangeEvents
// FX –> Java: Calling setters by reflection
JavaFxBridge.bridge( javaModel ).to( slider as FXObject ).connecting(
JavaFxBridge.bind( “amount” ).to( “value” ).withInverse()
); //sorry for the stupid API – needs some polishing…

//Add a timeline to simulate changes to the model
Timeline {
repeatCount: Timeline.INDEFINITE
keyFrames: [
KeyFrame {
time: 5s
action: function() {
println("changing amount on model");
javaModel.setAmount( javaModel.getAmount() + 10 );
}
}
];
}.play();
[/cc]

And here a JNLP to run the demo (open Java Console to see the updates printed to System.out):

Disclaimer:
This is just a working-in-some-situations-prototype. It is not production-ready by far.
But if you have any comments/ideas/bugs, please mail me.

The source code can be downloaded here. But I will add that stuff to JFXtras very soon…

The manual way

Of course you can add on replace triggers on every var and fire your events manually:
[cc lang="c"]
class Customer{
public var name:String = “” on replace old {
pcs.firePropertyChange(“name”, old, name );
};
public var address:String = “” on replace old {
pcs.firePropertyChange(“address”, old, address );
};
public var mail:Email on replace old {
pcs.firePropertyChange(“mail”, old, mail );
};
public-read def pcs = new PropertyChangeSupport( this );
}
[/cc]

This has at least three disadvantages:

• At first your code becomes very ugly. A lot of boilerplate code without any type checking. Very easy to make faults. Very hard to find them.
• But the second problem is even worse – if you don’t know for sure whether there is a listener registered. This approach destroys lazy binding which has been introduced in JavaFX 1.3. Every time the binding is invalidated, the replace trigger forces an update – even if nobody is registered at the PropertyChangeSupport.
• It can’t be “attached” to existing JavaFX classes.

Using an automated bridge

I have created a bridge that can be attached to every JavaFX object. This bridge uses the JavaFX binding stuff and translates the binding updates to PropertyChangeEvents.
There is no reflection involved when vars are updated (just when setting it up). So performance shouldn’t be a problem.
(Of course this approach also prevents lazy bindings since the events have to be created every time the vars change). So only attach the bridge if it is necessary.

The bridge can be used like that:
[cc lang="java"]
* FXObject fxObject = …
* Fx2PropertyChangeEvent bridge = Fx2PropertyChangeEvent.bindProperties( “name”, “id” ).to( fxObject );
* bridge.addPropertyChangeListener( “name”, new PropertyChangeListener(){…} );
[/cc]

Of course the bridge can also be used within your JavaFX scripts/classes.

And here comes the code: Feel free to use it:

[cc lang="java"]
package com.cedarsoft.fx;

import com.sun.javafx.runtime.DependentsManager;
import com.sun.javafx.runtime.FXBase;
import com.sun.javafx.runtime.FXObject;
import com.sun.javafx.runtime.annotation.Public;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.ArrayList;
import java.util.List;

/**
* This is a bridge that connects a PropertyChangeSupport to one or more JavaFX vars.
*

* This bridge does use reflection only to set things up! Whenever a var is updated there no(!) reflection is used!
* Therefore the performance is quite good.
*

*

* The Code might look like that:
*

 * FXObject fxObject = ...
 * Fx2PropertyChangeEvent bridge = Fx2PropertyChangeEvent.bindProperties( "name", "id" ).to( fxObject );
 * bridge.addPropertyChangeListener( "name", new PropertyChangeListener(){...} );
 * 

*/
@Public
public class Fx2PropertyChangeEvent extends FXBase {
@NotNull
private final PropertyChangeSupport pcs;
@NotNull
private final List entries = new ArrayList();
@NotNull
private final FXObject bindee;

public Fx2PropertyChangeEvent( @NotNull FXObject bindee ) {
this( bindee, null );
}

public Fx2PropertyChangeEvent( @NotNull FXObject bindee, @Nullable PropertyChangeSupport pcs ) {
super( false );
this.bindee = bindee;
this.pcs = pcs == null ? new PropertyChangeSupport( this ) : pcs;
initialize$( true );
}

/**
* Convert to property change events.
*
* @param propertyName the name of the property (var)
*/
void bindTo( @NotNull String propertyName ) {
try {
String fieldName = “$” + propertyName;
bindee.getClass().getField( fieldName );
} catch ( Exception ignore ) {
throw new IllegalArgumentException( “Invalid property name <" + propertyName + ">” );
}

try {
String varNumFieldName = “VOFF$” + propertyName;
Integer varNumField = ( Integer ) bindee.getClass().getField( varNumFieldName ).get( null );

int index = addEntry( propertyName, varNumField );
DependentsManager.addDependent( bindee, varNumField, this, index );
} catch ( Exception e ) {
throw new RuntimeException( e );
}
}

@Override
public boolean update$( FXObject src, int depNum, int startPos, int endPos, int newLength, int phase ) {
Entry entry = getEntry( depNum );
if ( phase == 65 ) {
Object oldValue = src.get$( entry.getVarNumField() );
entry.setOldValue( oldValue );
} else if ( phase == 92 ) {
Object newValue = src.get$( entry.getVarNumField() );
pcs.firePropertyChange( new PropertyChangeEvent( src, entry.getPropertyName(), entry.getOldValue(), newValue ) );
} else {
throw new IllegalStateException( “Invalid phase: ” + phase );
}

super.update$( src, depNum, startPos, endPos, newLength, phase );
return true;
}

private int addEntry( @NotNull @NonNls String propertyName, int varNumField ) {
int index = entries.size();
entries.add( new Entry( propertyName, varNumField ) );
return index;
}

@NotNull
private Entry getEntry( int depNum ) {
return entries.get( depNum );
}

public void addPropertyChangeListener( PropertyChangeListener listener ) {
pcs.addPropertyChangeListener( listener );
}

public void removePropertyChangeListener( PropertyChangeListener listener ) {
pcs.removePropertyChangeListener( listener );
}

public void addPropertyChangeListener( String propertyName, PropertyChangeListener listener ) {
pcs.addPropertyChangeListener( propertyName, listener );
}

public void removePropertyChangeListener( String propertyName, PropertyChangeListener listener ) {
pcs.removePropertyChangeListener( propertyName, listener );
}

@NotNull
public FXObject getBindee() {
return bindee;
}

@NotNull
public PropertyChangeSupport getPcs() {
return pcs;
}

public static class Entry {
private final String propertyName;
private final int varNumField;
private Object oldValue;

public Entry( String propertyName, int varNumField ) {
this.propertyName = propertyName;
this.varNumField = varNumField;
}

public String getPropertyName() {
return propertyName;
}

public int getVarNumField() {
return varNumField;
}

public Object getOldValue() {
return oldValue;
}

public void setOldValue( Object oldValue ) {
this.oldValue = oldValue;
}
}

/**
* Binds the given property names
*
* @param propertyNames the property names
* @return the fluent factory used to create a Fx2PropertyChangeEvent
*/
@NotNull
public static FluentFactory bindProperties( @NotNull @NonNls String… propertyNames ) {
return new FluentFactory( propertyNames );
}

/**
* Binds the given property names
*
* @param propertyNames the property names
* @return the fluent factory used to create a Fx2PropertyChangeEvent
*/
@NotNull
public static FluentFactory bind( @NotNull @NonNls String… propertyNames ) {
return bindProperties( propertyNames );
}

/**
* Fluent factory implementation
*/
public static class FluentFactory {
@NotNull
private final String[] propertyNames;

private FluentFactory( @NonNls @NotNull String[] propertyNames ) {
//noinspection AssignmentToCollectionOrArrayFieldFromParameter
this.propertyNames = propertyNames;
}

/**
* Binds the property names to the given bindee
*
* @param bindee the bindee the properties are bound to
* @return the bridge
*
* @noinspection InstanceMethodNamingConvention
*/
@NotNull
public Fx2PropertyChangeEvent to( @NotNull FXObject bindee ) {
if ( propertyNames.length == 0 ) {
throw new IllegalArgumentException( “Need at least one property to bind to” );
}

Fx2PropertyChangeEvent bridge = new Fx2PropertyChangeEvent( bindee );
for ( String propertyName : propertyNames ) {
bridge.bindTo( propertyName );
}
return bridge;
}
}
}

/**
* Copyright (C) cedarsoft GmbH.
*
* Licensed under the GNU General Public License version 3 (the “License”)
* with Classpath Exception; you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.cedarsoft.org/gpl3ce
* (GPL 3 with Classpath Exception)
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 3 only, as
* published by the Free Software Foundation. cedarsoft GmbH designates this
* particular file as subject to the “Classpath” exception as provided
* by cedarsoft GmbH in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 3 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 3 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact cedarsoft GmbH, 72810 Gomaringen, Germany,
* or visit www.cedarsoft.com if you need additional information or
* have any questions.
*/

[/cc]

I will upload a complete project very soon (Monday). This will contain several samples and unit tests….

Today we start to use some of the JavaFX classes by Java. Therefore I just added all JavaFX jars to the classpath.

Extending FXBase

It is a very good idea to extend FXBase. We just have to figure out which methods have to be called for initialization. Following the samples, our class could look like that:

[cc lang="java"]
import com.sun.javafx.runtime.FXBase;
import com.sun.javafx.runtime.FXObject;
import com.sun.javafx.runtime.annotation.Public;

@Public
public class Run extends FXBase implements FXObject {
public static void main( String[] args ) {
System.out.println( “Starting!” );

System.out.println( “Finished” );
}

public Run() {
this( false );
initialize$( true );
}

public Run( boolean paramBoolean ) {
super( paramBoolean );
}
}[/cc]

Approaching that binding stuff

As mentioned yesterday the magic happens within the DependentsManager. Thankfully that sources are available…
One key is the WeakBinderRef that can be stored within each FXObject and be retrieved calling getThisRef$internal$().
There is a static method that creates those refs lazyly: WeakBinderRef.instance().

This WeakBinderRef contains the dependencies for this object. The field bindees contains a chain of Dep instances. Interestingly the WeakBinderRef for test does not contain any bindees as one might have expected. Those are the reverse dependencies!

The “real” dependencies are stored within each object within the field DepChain$internal$ (of type DepChain).
Relevant is the bindeeVarNum. Here is the var num stored that dependency is based upon.

Process of dependency notification

Whenever a var is changed, there are two calls made to notifyDependents$. They can be distinguished by the phase (argument).
That methods uses the DependentsManager to call invalidate on all depending objects. Those simply change the flag so that the next time the var is accessed, it can be resolved again.

While the binding performance in JavaFX is much better in 1.3 it is still not really lazy. There happen a lot of calls until the value is marked as invalid.
So I assume that the performance has just been increased for complex binding expressions. Just binding one var to another shouldn’t be much faster now (this is just an assumption!)…

Adding dependencies manually

Now we try to add a dependency manually. It is possible by simply calling “DependentsManager.addDependent()“.
Of course it does not have any visible effects (besides that the update/invalidate methods are called). Because the values are fetched from the original objects… But the debugger shows us, that it is possible to use that bind mechanism from Java.

Simple class

At first I tried to create a simple class with just one var of type String:

[cc lang="c"]public class Test{
var value:String = “asdf”;
}[/cc]

And then I tried to take a look at the internals. Of course I did not decompile that stuff. Instead I used javap and Reflection to analyze it myself. The result could look like that:

[cc lang="java"]
import com.sun.javafx.runtime.FXBase;
import com.sun.javafx.runtime.FXObject;
import com.sun.javafx.runtime.annotation.Public;
import com.sun.javafx.runtime.annotation.ScriptPrivate;
import com.sun.javafx.runtime.annotation.SourceName;

@Public
public class Test extends FXBase implements FXObject {
@ScriptPrivate
@SourceName( “value” )
private String $value;

public Test() {
this( false );
initialize$( true );
}

public Test( boolean paramBoolean ) {
super( paramBoolean );
this.$value = “asdf”;
}
}[/cc]

So, what is interesting about this?
At first the name of the field is not so nice. Very hard to access using Reflection… But probably that is intended.
Every JavaFX class extends FXBase (or implement FXObject if extending another Java class).

Well, those information can be found within the sources of FXBase (look at src.zip)…

Changing var to def

What is the difference? There is just an annotation (@Def) added to the field…

Simple binding

Of course binding is the most interesting part for me. So let’s create add simple binding. Therefore we create a second var (“boundValue”) and bind it to value using bind value.

And now here comes the wow. Look at that monster javafxc has created:
[cc lang="java"]import com.sun.javafx.runtime.Checks;
import com.sun.javafx.runtime.FXBase;
import com.sun.javafx.runtime.FXObject;
import com.sun.javafx.runtime.annotation.Public;
import com.sun.javafx.runtime.annotation.ScriptPrivate;
import com.sun.javafx.runtime.annotation.SourceName;

@Public
public class Test extends FXBase implements FXObject {
private static int VCNT$ = 2;
public static final int VOFF$value = 0;
public static final int VOFF$boundValue = 1;
private short VFLG$value;
private short VFLG$boundValue;

@ScriptPrivate
@SourceName( “value” )
private String $value;

@ScriptPrivate
@SourceName( “boundValue” )
private String $boundValue;

public static int VCNT$() {
return 2;
}

public int count$() {
return 2;
}

private String get$value() {
return this.$value;
}

private void invalidate$value( int paramInt ) {
int i = this.VFLG$value & 0×7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
this.VFLG$value = ( short ) ( this.VFLG$value & 0xFFFFFFF8 | paramInt >> 4 );
paramInt &= -35;
notifyDependents$( 0, paramInt );
invalidate$boundValue( paramInt );
}

private String get$boundValue() {
if ( ( this.VFLG$boundValue & 0×18 ) == 0 ) {
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0×400 );
} else if ( ( this.VFLG$boundValue & 0×104 ) == 260 ) {
int i = this.VFLG$boundValue;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFE7 | 0×0 );
String str = get$value();
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0×200 );
if ( ( this.VFLG$boundValue & 0×5 ) == 4 ) {
this.VFLG$boundValue = ( short ) i;
return str;
}
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFF8 | 0×19 );
this.$boundValue = str;
}
return this.$boundValue;
}

private void invalidate$boundValue( int paramInt ) {
int i = this.VFLG$boundValue & 0×7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
if ( ( ( paramInt & 0×8 ) == 8 ) && ( ( this.VFLG$value & 0×5 ) == 4 ) ) return;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFF8 | paramInt >> 4 );
paramInt &= -35;
}

public void applyDefaults$( int paramInt ) {
if ( !varTestBits$( paramInt, 56, 8 ) ) return;
switch ( paramInt ) {
case 0:
String str = this.$value;
int i = this.VFLG$value;
this.VFLG$value = ( short ) ( this.VFLG$value | 0×18 );
if ( ( !Checks.equals( str, “asdf” ) ) || ( ( i & 0×10 ) == 0 ) ) {
invalidate$value( 97 );
this.$value = “asdf”;
invalidate$value( 94 );
}
this.VFLG$value = ( short ) ( this.VFLG$value & 0xFFFFFFF8 | 0×1 );
return;
case 1:
invalidate$boundValue( 65 );
invalidate$boundValue( 92 );
if ( ( this.VFLG$boundValue & 0×440 ) != 0 ) get$boundValue();
return;
}
super.applyDefaults$( paramInt );
}

public Object get$( int paramInt ) {
switch ( paramInt ) {
case 0:
return get$value();
case 1:
return get$boundValue();
}
return super.get$( paramInt );
}

public void set$( int paramInt, Object paramObject ) {
switch ( paramInt ) {
case 0:
this.$value = ( ( String ) paramObject );
return;
case 1:
this.$boundValue = ( ( String ) paramObject );
return;
}
super.set$( paramInt, paramObject );
}

public void invalidate$( int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5 ) {
switch ( paramInt1 ) {
case 0:
invalidate$value( paramInt5 );
return;
case 1:
invalidate$boundValue( paramInt5 );
return;
}
super.invalidate$( paramInt1, paramInt2, paramInt3, paramInt4, paramInt5 );
}

public int varChangeBits$( int paramInt1, int paramInt2, int paramInt3 ) {
switch ( paramInt1 ) {
case 0:
return this.VFLG$value = ( short ) ( this.VFLG$value & ( paramInt2 ^ 0xFFFFFFFF ) | paramInt3 );
case 1:
return this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & ( paramInt2 ^ 0xFFFFFFFF ) | paramInt3 );
}
return super.varChangeBits$( paramInt1, paramInt2, paramInt3 );
}

public Test() {
this( false );
initialize$( true );
}

public Test( boolean paramBoolean ) {
super( paramBoolean );
this.VFLG$value = 1;
this.VFLG$boundValue = 769;

this.$value = “”;
this.$boundValue = “”;
}
}[/cc]

Very interesting. Let’s take a deeper look:
First two fields are created as expected.

Dirty flags

Additionally for both fields a short “VFLG$” has been generated. Those hold the dirty state of the var. There is also a static field (int) prefixed with “VOFF” for every var. Seems to hold some sort of index?

Getters

And now there have been created (private!) getters. The getter for the unbound var is simple. Just returns the field. The getter for boundValue is more interesting:
It contains some checks about its state using VFLG$boundValue. Depending on that state the field is updated (see line 61) using the getter for value. Here we can see that bindings are in fact lazy.

Invalidate methods

For every var there has been created an invalidate method. Those change the dirty flag and call notifyDependents$. That method delegates to DependentsManager.
Very interesting: The invalidate method for boudnValue does not call notifyDepenents. This is probably an optimization because the scope of the vars is script.

Generic methods

There are generic get/set/invalidate methods that delegate to the corresponding methods based on the index.

applyDefaults

This method is also interesting. It is called from FXBase#applyDefaults which itself is called within the constructor. I don’t know if it is called sometimes else. But probably it is…

Constructor

The constructor is different. It does not initialize the the fields. Instead they are set to their default values.

One var with on replace

To verify that thought we go one step back: Just one var, but this time we add a on replace method.

[cc lang="java"]import com.sun.javafx.runtime.Checks;
import com.sun.javafx.runtime.FXBase;
import com.sun.javafx.runtime.FXObject;
import com.sun.javafx.runtime.annotation.Public;
import com.sun.javafx.runtime.annotation.ScriptPrivate;
import com.sun.javafx.runtime.annotation.SourceName;
import javafx.lang.Builtins;

@Public
public class Test extends FXBase implements FXObject {
private static int VCNT$ = 1;
public static final int VOFF$value = 0;
private short VFLG$value;

@ScriptPrivate
@SourceName( “value” )
private String $value;

public static int VCNT$() {
return 1;
}

public int count$() {
return 1;
}

private String get$value() {
return this.$value;
}

private void onReplace$value( String paramString1, String paramString2 ) {
Builtins.println( String.format( “value changed to %s”, new Object[]{get$value()} ) );
}

public void applyDefaults$( int paramInt ) {
if ( !varTestBits$( paramInt, 56, 8 ) ) return;
switch ( paramInt ) {
case 0:
String str = this.$value;
int i = this.VFLG$value;
this.VFLG$value = ( short ) ( this.VFLG$value | 0×18 );
if ( ( !Checks.equals( str, “asdf” ) ) || ( ( i & 0×10 ) == 0 ) ) {
this.$value = “asdf”;
onReplace$value( str, “asdf” );
}
return;
}
super.applyDefaults$( paramInt );
}

public Object get$( int paramInt ) {
switch ( paramInt ) {
case 0:
return get$value();
}
return super.get$( paramInt );
}

public void set$( int paramInt, Object paramObject ) {
switch ( paramInt ) {
case 0:
this.$value = ( ( String ) paramObject );
return;
}
super.set$( paramInt, paramObject );
}

public int varChangeBits$( int paramInt1, int paramInt2, int paramInt3 ) {
switch ( paramInt1 ) {
case 0:
return this.VFLG$value = ( short ) ( this.VFLG$value & ( paramInt2 ^ 0xFFFFFFFF ) | paramInt3 );
}
return super.varChangeBits$( paramInt1, paramInt2, paramInt3 );
}

public Test() {
this( false );
initialize$( true );
}

public Test( boolean paramBoolean ) {
super( paramBoolean );
this.VFLG$value = 65;
this.$value = “”;
}
}[/cc]

What is the difference?
The same stuff is created as in the last example. Of course this is necessary because the on replace method is part of the binding stuff. The difference is, that there has been created a onReplace$value method with two parameters (don’t know what those parameters represent).
This method is only called in applyDefaults. Probably another optimization.

Two public-read vars with a on replace method

This results in something like that:

[cc lang="java"]package com.cedarsoft.collustra;

import com.sun.javafx.runtime.Checks;
import com.sun.javafx.runtime.FXBase;
import com.sun.javafx.runtime.FXObject;
import com.sun.javafx.runtime.annotation.Public;
import com.sun.javafx.runtime.annotation.PublicReadable;
import com.sun.javafx.runtime.annotation.ScriptPrivate;
import com.sun.javafx.runtime.annotation.SourceName;
import javafx.lang.Builtins;

@Public
public class Test extends FXBase implements FXObject {
private static int VCNT$ = 2;
public static int VOFF$value = 0;
public static int VOFF$boundValue = 1;
public short VFLG$value;
public short VFLG$boundValue;

@PublicReadable
@ScriptPrivate
@SourceName( “value” )
public String $value;

@PublicReadable
@ScriptPrivate
@SourceName( “boundValue” )
public String $boundValue;

public static int VCNT$() {
return 2;
}

public int count$() {
return 2;
}

public String get$value() {
return this.$value;
}

public String set$value( String paramString ) {
if ( ( this.VFLG$value & 0×200 ) != 0 ) restrictSet$( this.VFLG$value );
String str = this.$value;
int i = this.VFLG$value;
this.VFLG$value = ( short ) ( this.VFLG$value | 0×18 );
if ( ( !Checks.equals( str, paramString ) ) || ( ( i & 0×10 ) == 0 ) ) {
invalidate$value( 97 );
this.$value = paramString;
invalidate$value( 94 );
onReplace$value( str, paramString );
}
this.VFLG$value = ( short ) ( this.VFLG$value & 0xFFFFFFF8 | 0×1 );
return this.$value;
}

public void invalidate$value( int paramInt ) {
int i = this.VFLG$value & 0×7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
this.VFLG$value = ( short ) ( this.VFLG$value & 0xFFFFFFF8 | paramInt >> 4 );
paramInt &= -35;
notifyDependents$( VOFF$value, paramInt );
invalidate$boundValue( paramInt );
if ( ( ( paramInt & 0×8 ) != 8 ) || ( ( this.VFLG$value & 0×40 ) != 64 ) ) return;
get$value();
}

public void onReplace$value( String paramString1, String paramString2 ) {
Builtins.println( String.format( “value changed to %s”, new Object[]{get$value()} ) );
}

public String get$boundValue() {
if ( ( this.VFLG$boundValue & 0×18 ) == 0 ) {
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0×400 );
} else if ( ( this.VFLG$boundValue & 0×104 ) == 260 ) {
int i = this.VFLG$boundValue;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFE7 | 0×0 );
String str1 = get$value();
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0×200 );
if ( ( this.VFLG$boundValue & 0×5 ) == 4 ) {
this.VFLG$boundValue = ( short ) i;
return str1;
}
String str2 = this.$boundValue;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFF8 | 0×19 );
if ( ( !Checks.equals( str2, str1 ) ) || ( ( i & 0×10 ) == 0 ) ) {
this.$boundValue = str1;
onReplace$boundValue( str2, str1 );
}
}
return this.$boundValue;
}

public String set$boundValue( String paramString ) {
if ( ( this.VFLG$boundValue & 0×200 ) != 0 ) restrictSet$( this.VFLG$boundValue );
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0×200 );
String str = this.$boundValue;
int i = this.VFLG$boundValue;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0×18 );
if ( ( !Checks.equals( str, paramString ) ) || ( ( i & 0×10 ) == 0 ) ) {
invalidate$boundValue( 97 );
this.$boundValue = paramString;
invalidate$boundValue( 94 );
onReplace$boundValue( str, paramString );
}
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFF8 | 0×1 );
return this.$boundValue;
}

public void invalidate$boundValue( int paramInt ) {
int i = this.VFLG$boundValue & 0×7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
if ( ( ( paramInt & 0×8 ) == 8 ) && ( ( this.VFLG$value & 0×5 ) == 4 ) ) return;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFF8 | paramInt >> 4 );
paramInt &= -35;
notifyDependents$( VOFF$boundValue, paramInt );
}

public void onReplace$boundValue( String paramString1, String paramString2 ) {
}

public void applyDefaults$( int paramInt ) {
if ( !varTestBits$( paramInt, 56, 8 ) ) return;
switch ( paramInt ) {
case 0:
set$value( “asdf” );
return;
case 1:
invalidate$boundValue( 65 );
invalidate$boundValue( 92 );
if ( ( this.VFLG$boundValue & 0×440 ) != 0 ) get$boundValue();
return;
}
super.applyDefaults$( paramInt );
}

public Object get$( int paramInt ) {
switch ( paramInt ) {
case 0:
return get$value();
case 1:
return get$boundValue();
}
return super.get$( paramInt );
}

public void set$( int paramInt, Object paramObject ) {
switch ( paramInt ) {
case 0:
set$value( ( String ) paramObject );
return;
case 1:
set$boundValue( ( String ) paramObject );
return;
}
super.set$( paramInt, paramObject );
}

public void invalidate$( int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5 ) {
switch ( paramInt1 ) {
case 0:
invalidate$value( paramInt5 );
return;
case 1:
invalidate$boundValue( paramInt5 );
return;
}
super.invalidate$( paramInt1, paramInt2, paramInt3, paramInt4, paramInt5 );
}

public int varChangeBits$( int paramInt1, int paramInt2, int paramInt3 ) {
switch ( paramInt1 ) {
case 0:
return this.VFLG$value = ( short ) ( this.VFLG$value & ( paramInt2 ^ 0xFFFFFFFF ) | paramInt3 );
case 1:
return this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & ( paramInt2 ^ 0xFFFFFFFF ) | paramInt3 );
}
return super.varChangeBits$( paramInt1, paramInt2, paramInt3 );
}

public Test() {
this( false );
initialize$( true );
}

public Test( boolean paramBoolean ) {
super( paramBoolean );
this.VFLG$value = 65;
this.VFLG$boundValue = 769;

this.$value = “”;
this.$boundValue = “”;
}
}[/cc]

And now (see line 51) the call to onReplace has been added to the setter for value. Now we also understand the meaning of the parameters. The first one is the old value while the second one is the new one.

Interestingly there also has been genereated an empty onReplace method for boundValue. Propably because of overriding stuff?

The getter and setter are both public now. But I just set the scope to public-read. So don’t understand exactly why it is necessary to make the setter public, too.

Binding from other class

Now we create a sample where we bind from another class. Maybe we can learn something new.

[cc lang="c"]
public class Test2{
var test = Test{};
public var otherBound = bind test.value;
}
[/cc]

And here is the pseudo java code:

[cc lang="java"]
import com.sun.javafx.runtime.Checks;
import com.sun.javafx.runtime.FXBase;
import com.sun.javafx.runtime.FXObject;
import com.sun.javafx.runtime.annotation.Public;
import com.sun.javafx.runtime.annotation.ScriptPrivate;
import com.sun.javafx.runtime.annotation.SourceName;

@Public
public class Test2 extends FXBase implements FXObject {
private static int VCNT$ = 2;
public static final int VOFF$test = 0;
public static int VOFF$otherBound = 1;
private short VFLG$test;
public short VFLG$otherBound;

@ScriptPrivate
@SourceName( “test” )
private Test $test;

@Public
@SourceName( “otherBound” )
public String $otherBound;
private static int DCNT$ = 1;
public static final int DEP$test$_$value = 0;

public static int VCNT$() {
return 2;
}

public int count$() {
return 2;
}

private Test get$test() {
return this.$test;
}

private void invalidate$test( int paramInt ) {
int i = this.VFLG$test & 0×7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
this.VFLG$test = ( short ) ( this.VFLG$test & 0xFFFFFFF8 | paramInt >> 4 );
paramInt &= -35;
notifyDependents$( 0, paramInt );
invalidate$otherBound( paramInt );
}

private void onReplace$test( Test paramTest1, Test paramTest2 ) {
int i = Test.VOFF$value;
FXBase.switchDependence$( this, paramTest1, i, paramTest2, i, 0 );
}

public String get$otherBound() {
if ( ( this.VFLG$otherBound & 0×18 ) == 0 ) {
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound | 0×400 );
} else if ( ( this.VFLG$otherBound & 0×104 ) == 260 ) {
int i = this.VFLG$otherBound;
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound & 0xFFFFFFE7 | 0×0 );
String str1 = ( get$test() != null ) ? get$test().get$value() : “”;
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound | 0×200 );
if ( ( this.VFLG$otherBound & 0×5 ) == 4 ) {
this.VFLG$otherBound = ( short ) i;
return str1;
}
String str2 = this.$otherBound;
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound & 0xFFFFFFF8 | 0×19 );
if ( ( !Checks.equals( str2, str1 ) ) || ( ( i & 0×10 ) == 0 ) ) {
this.$otherBound = str1;
onReplace$otherBound( str2, str1 );
}
}
return this.$otherBound;
}

public String set$otherBound( String paramString ) {
if ( ( this.VFLG$otherBound & 0×200 ) != 0 ) restrictSet$( this.VFLG$otherBound );
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound | 0×200 );
String str = this.$otherBound;
int i = this.VFLG$otherBound;
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound | 0×18 );
if ( ( !Checks.equals( str, paramString ) ) || ( ( i & 0×10 ) == 0 ) ) {
invalidate$otherBound( 97 );
this.$otherBound = paramString;
invalidate$otherBound( 94 );
onReplace$otherBound( str, paramString );
}
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound & 0xFFFFFFF8 | 0×1 );
return this.$otherBound;
}

public void invalidate$otherBound( int paramInt ) {
int i = this.VFLG$otherBound & 0×7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
if ( ( ( paramInt & 0×8 ) == 8 ) && ( ( this.VFLG$test & 0×5 ) == 4 ) ) return;
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound & 0xFFFFFFF8 | paramInt >> 4 );
paramInt &= -35;
notifyDependents$( VOFF$otherBound, paramInt );
}

public void onReplace$otherBound( String paramString1, String paramString2 ) {
}

public void applyDefaults$( int paramInt ) {
if ( !varTestBits$( paramInt, 56, 8 ) ) return;
switch ( paramInt ) {
case 0:
Test localTest1 = new Test();
Test localTest2 = this.$test;
int i = this.VFLG$test;
this.VFLG$test = ( short ) ( this.VFLG$test | 0×18 );
if ( ( localTest2 != localTest1 ) || ( ( i & 0×10 ) == 0 ) ) {
invalidate$test( 97 );
this.$test = localTest1;
invalidate$test( 94 );
onReplace$test( localTest2, localTest1 );
}
this.VFLG$test = ( short ) ( this.VFLG$test & 0xFFFFFFF8 | 0×1 );
return;
case 1:
invalidate$otherBound( 65 );
invalidate$otherBound( 92 );
if ( ( this.VFLG$otherBound & 0×440 ) != 0 ) get$otherBound();
return;
}
super.applyDefaults$( paramInt );
}

public static int DCNT$() {
return 1;
}

public boolean update$( FXObject paramFXObject, int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5 ) {
switch ( paramInt1 ) {
case 0:
if ( paramFXObject == this.$test ) {
invalidate$otherBound( paramInt5 );
return true;
}
}
return super.update$( paramFXObject, paramInt1, paramInt2, paramInt3, paramInt4, paramInt5 );
return false;
}

public Object get$( int paramInt ) {
switch ( paramInt ) {
case 0:
return get$test();
case 1:
return get$otherBound();
}
return super.get$( paramInt );
}

public void set$( int paramInt, Object paramObject ) {
switch ( paramInt ) {
case 0:
this.$test = ( ( Test ) paramObject );
return;
case 1:
set$otherBound( ( String ) paramObject );
return;
}
super.set$( paramInt, paramObject );
}

public void invalidate$( int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5 ) {
switch ( paramInt1 ) {
case 0:
invalidate$test( paramInt5 );
return;
case 1:
invalidate$otherBound( paramInt5 );
return;
}
super.invalidate$( paramInt1, paramInt2, paramInt3, paramInt4, paramInt5 );
}

public int varChangeBits$( int paramInt1, int paramInt2, int paramInt3 ) {
switch ( paramInt1 ) {
case 0:
return this.VFLG$test = ( short ) ( this.VFLG$test & ( paramInt2 ^ 0xFFFFFFFF ) | paramInt3 );
case 1:
return this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound & ( paramInt2 ^ 0xFFFFFFFF ) | paramInt3 );
}
return super.varChangeBits$( paramInt1, paramInt2, paramInt3 );
}

public Test2() {
this( false );
initialize$( true );
}

public Test2( boolean paramBoolean ) {
super( paramBoolean );
this.VFLG$test = 1;
this.VFLG$otherBound = 769;
this.$otherBound = “”;
}

}[/cc]

The most interesting part is at line 52: There a call to FXBase.switchDependence$ is made every time the test reference is changing. This method delegates to DependentsManager#addDependent.

This is where the magic happens. I think I will take a deeper look at that stuff later.

Initialzing objects with parameters

If objects are created using the object literal, the JavaFX compiler generates the calls to set the initial value and calls complete$() on the newly created object finally.
Within complete$() the userInit$() and postInit$() methods are called.

Conclusion regarding binding

I hoped to find a way how to bind JavaFX objects to Java objects providing PropertyChangeEvents. Investigating the DependentsManager further might give further hints.
At the moment it looks a little bit difficult since the DependentsManager is working on FXObjects. So it is very probable that at least some kind of adapter objects is necessary… But who knows….

Therefore I have created a template that can be used:

[cc lang="c"]
public class MyCustomNode extends CustomNode, Resizable {
override var width on replace { requestLayout() }
override var height on replace { requestLayout() }
override var layoutBounds = bind BoundingBox {
width: this.width
height: this.height
}

init {
children =[
Rectangle {
width: bind width
height: bind height
}
]
}

override function getPrefWidth( number ) {
//return your pref width – hard coded values are ok for most cases
}

override function getPrefHeight( number ) {
//return your pref height – hard coded values are ok for most cases
}

/*
//It is not absolutly necessary to override those methods, but strongly recommended.
override function getMaxWidth() {
//Return the max width
}

override function getMaxHeight() {
//Return the max height
}

override function getMinWidth() {
//Return the min width
}

override function getMinHeight() {
//Return the min height
}*/
}
[/cc]

There is a post containing a template for CustomControls here.

So this post shows what is necessary to create a CustomNode that extends Resizable. We follow the same setting: The custom node is placed within a Stack.

Step 1: Extending Resizable

Resizable enforces us to implement the getPrefWidth/Height methods. We just return some hard coded values and try to find out what happens:
The width/height of the CustomNode are set to the values returned by getPrefWidth/Height. But the boundsInLocal and layoutBounds don’t respect that. They still just depend on the children.

Step 2: Requesting Layout

The doc of Resizable tells us that we have to call requestLayout() every time the width/height of the node is changed. Doing this doesn’t make any difference in this context (within a Stack). But when placed in other layouts this is necessary!

[cc lang="c"]
override var width on replace { requestLayout() }
override var height on replace { requestLayout() }
[/cc]

Step 3: Connecting layoutBounds to width/height

As we have learned when looking at CustomControls it is a very good idea to bind the layoutBounds to the width/height. This is necessary to avoid difficult layout bugs that will only occur in some situations and are very hard to track down.

[cc lang="c"] override var layoutBounds = bind BoundingBox {
minX: 0
minY: 0
width: this.width
height: this.height
}
[/cc]

Now the layoutBounds fit to the width/height of the Node. But of course the sizes of the rectangle(s) are still independent. And the boundInLocal don’t fit them neither.

Step 4: Children depend on width/height

Now we connect the width/height of the children to the width/height of our CustomNode.
Now the three values (width/height, layoutBounds, boundsInLocal) correspond correctly with each other.

Important: As mentioned before it is necessary that width/height always correspond with the layoutBounds. Always! But the boundsInLocal may be different from them (larger or smaller) but have to be influenced by them.