Just Java

Maven: Fixing table bug for site plugin 2.1

johannes — Thu, 15 Jul 2010 14:56:35 +0000

Some time ago a new big release for the site plugin has been done.
Unfortunately they have introduced a small bug:

The table tags now contain the alignment attribute set to “left”.

This results to some strange bugs. Take a look at that page:
http://fest.easytesting.org/javafx/maven/compile-mojo.html

Look at the background of the table. The following h3 gets resized and its background is drawn behind the table…

To fix it, just add those lines to the CSS:

1
2
3

table {
float: none;
}

JUnit @Theory oddities

johannes — Sat, 10 Jul 2010 11:28:00 +0000

At the moment I try to switch my tests for serialization.cedarsoft.org over to JUnit Theories (4.8.1).

And I run into some problems:

No DataPoints

1
2
3
4
5
6
7
8

@RunWith( Theories.class )
public class TheoriesTest {
@Theory
public void aTheory( String arg ) {
System.out.println( "TheoriesTest.aTheory(" + arg + ")" );
assertNotNull( arg );
}
}

Throws an exception: java.lang.AssertionError: Never found parameters that satisfied method assumptions. Violated assumptions: []

Very nice. A theory doesn’t make any sense without any DataPoints.

A DataPoint method

Okay, now I created a DataPoints method:

1
2
3
4

@DataPoint
public static String getParam() {
return "daParam";
}

And everything works as expected.

Removing the static keyword

In my test cases I try to avoid every unnecessary key press as good as I can. Therefore I would like to create an abstract method that I just have to implement (IDE creates the method stub for me then).

So I just removed the static keyword from the method to try if it is possible…

And guess what?

The test method did not run – but is reported as succeeded…

JavaFX2Java Bridge added to JFXtras (step 2)

johannes — Tue, 06 Jul 2010 07:52:12 +0000

Thanks to Stephen: He has prepared a branch for the upcoming 0.7 release of JFXtras. Now it has been possible to merge the latest changes to the JFXtras default branch.

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.

JavaFX2Java Bridge added to JFXtras (step 1)

johannes — Sat, 03 Jul 2010 19:09:54 +0000

It has taken a long time since I promised to integrate the JavaFX2Java bridge to JFXtras until I finally did it…

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”.

JFXtras: 0.7 RC1 released

johannes — Fri, 18 Jun 2010 08:21:44 +0000

Hi guys,

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/

Closing the gap between Java and JavaFX

johannes — Tue, 11 May 2010 14:39:20 +0000

There is a huge gap between Java and JavaFX: While it is very easy to bind JavaFX objects to each other there has been no way to bind JavaFX objects to Java properties (and vice versa).

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”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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);
}
}

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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

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();

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…

Binding PropertyChangeSupport to JavaFX objects transparently

johannes — Sat, 08 May 2010 20:03:48 +0000

Binding is one of the best features in JavaFX. The possibility to class Java APIs from JavaFX is another one.
But unfortunately there is no easy way to combine JavaFX binding and Java PropertyChangeEvents. Therefore I have taken a look at the JavaFX code and I think I have found a possible solution:

The manual way

Of course you can add on replace triggers on every var and fire your events manually:

1
2
3
4
5
6
7
8
9
10
11
12

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 );
}

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:

1
2
3

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

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<Entry> entries = new ArrayList<Entry>();
@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.
*/

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

JavaFX Internals Part 2

johannes — Sat, 08 May 2010 13:15:34 +0000

Yesterday I wrote about some JavaFX Internals…. Today comes the second part.

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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 );
}
}

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.

Analyzing JavaFX

johannes — Wed, 05 May 2010 20:23:40 +0000

Today I wanted to analyze the internals of JavaFX. This post is the documentation – primarily made for myself. But maybe useful for somebody else, too…

Simple class

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

1
2
3

public class Test{
var value:String = "asdf";
}

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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";
}
}

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:

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 & 0x7;
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 & 0x18 ) == 0 ) {
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0x400 );
} else if ( ( this.VFLG$boundValue & 0x104 ) == 260 ) {
int i = this.VFLG$boundValue;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFE7 | 0x0 );
String str = get$value();
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0x200 );
if ( ( this.VFLG$boundValue & 0x5 ) == 4 ) {
this.VFLG$boundValue = ( short ) i;
return str;
}
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFF8 | 0x19 );
this.$boundValue = str;
}
return this.$boundValue;
}

private void invalidate$boundValue( int paramInt ) {
int i = this.VFLG$boundValue & 0x7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
if ( ( ( paramInt & 0x8 ) == 8 ) && ( ( this.VFLG$value & 0x5 ) == 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 | 0x18 );
if ( ( !Checks.equals( str, "asdf" ) ) || ( ( i & 0x10 ) == 0 ) ) {
invalidate$value( 97 );
this.$value = "asdf";
invalidate$value( 94 );
}
this.VFLG$value = ( short ) ( this.VFLG$value & 0xFFFFFFF8 | 0x1 );
return;
case 1:
invalidate$boundValue( 65 );
invalidate$boundValue( 92 );
if ( ( this.VFLG$boundValue & 0x440 ) != 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 = "";
}
}

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.

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:

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 & 0x200 ) != 0 ) restrictSet$( this.VFLG$value );
String str = this.$value;
int i = this.VFLG$value;
this.VFLG$value = ( short ) ( this.VFLG$value | 0x18 );
if ( ( !Checks.equals( str, paramString ) ) || ( ( i & 0x10 ) == 0 ) ) {
invalidate$value( 97 );
this.$value = paramString;
invalidate$value( 94 );
onReplace$value( str, paramString );
}
this.VFLG$value = ( short ) ( this.VFLG$value & 0xFFFFFFF8 | 0x1 );
return this.$value;
}

public void invalidate$value( int paramInt ) {
int i = this.VFLG$value & 0x7;
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 & 0x8 ) != 8 ) || ( ( this.VFLG$value & 0x40 ) != 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 & 0x18 ) == 0 ) {
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0x400 );
} else if ( ( this.VFLG$boundValue & 0x104 ) == 260 ) {
int i = this.VFLG$boundValue;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFE7 | 0x0 );
String str1 = get$value();
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0x200 );
if ( ( this.VFLG$boundValue & 0x5 ) == 4 ) {
this.VFLG$boundValue = ( short ) i;
return str1;
}
String str2 = this.$boundValue;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFF8 | 0x19 );
if ( ( !Checks.equals( str2, str1 ) ) || ( ( i & 0x10 ) == 0 ) ) {
this.$boundValue = str1;
onReplace$boundValue( str2, str1 );
}
}
return this.$boundValue;
}

public String set$boundValue( String paramString ) {
if ( ( this.VFLG$boundValue & 0x200 ) != 0 ) restrictSet$( this.VFLG$boundValue );
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0x200 );
String str = this.$boundValue;
int i = this.VFLG$boundValue;
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue | 0x18 );
if ( ( !Checks.equals( str, paramString ) ) || ( ( i & 0x10 ) == 0 ) ) {
invalidate$boundValue( 97 );
this.$boundValue = paramString;
invalidate$boundValue( 94 );
onReplace$boundValue( str, paramString );
}
this.VFLG$boundValue = ( short ) ( this.VFLG$boundValue & 0xFFFFFFF8 | 0x1 );
return this.$boundValue;
}

public void invalidate$boundValue( int paramInt ) {
int i = this.VFLG$boundValue & 0x7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
if ( ( ( paramInt & 0x8 ) == 8 ) && ( ( this.VFLG$value & 0x5 ) == 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 & 0x440 ) != 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 = "";
}
}

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.

1
2
3
4

public class Test2{
var test = Test{};
public var otherBound = bind test.value;
}

And here is the pseudo java code:

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 & 0x7;
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 & 0x18 ) == 0 ) {
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound | 0x400 );
} else if ( ( this.VFLG$otherBound & 0x104 ) == 260 ) {
int i = this.VFLG$otherBound;
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound & 0xFFFFFFE7 | 0x0 );
String str1 = ( get$test() != null ) ? get$test().get$value() : "";
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound | 0x200 );
if ( ( this.VFLG$otherBound & 0x5 ) == 4 ) {
this.VFLG$otherBound = ( short ) i;
return str1;
}
String str2 = this.$otherBound;
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound & 0xFFFFFFF8 | 0x19 );
if ( ( !Checks.equals( str2, str1 ) ) || ( ( i & 0x10 ) == 0 ) ) {
this.$otherBound = str1;
onReplace$otherBound( str2, str1 );
}
}
return this.$otherBound;
}

public String set$otherBound( String paramString ) {
if ( ( this.VFLG$otherBound & 0x200 ) != 0 ) restrictSet$( this.VFLG$otherBound );
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound | 0x200 );
String str = this.$otherBound;
int i = this.VFLG$otherBound;
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound | 0x18 );
if ( ( !Checks.equals( str, paramString ) ) || ( ( i & 0x10 ) == 0 ) ) {
invalidate$otherBound( 97 );
this.$otherBound = paramString;
invalidate$otherBound( 94 );
onReplace$otherBound( str, paramString );
}
this.VFLG$otherBound = ( short ) ( this.VFLG$otherBound & 0xFFFFFFF8 | 0x1 );
return this.$otherBound;
}

public void invalidate$otherBound( int paramInt ) {
int i = this.VFLG$otherBound & 0x7;
int j = ( ( i & paramInt ) == i ) ? 1 : 0;
if ( j == 0 ) return;
if ( ( ( paramInt & 0x8 ) == 8 ) && ( ( this.VFLG$test & 0x5 ) == 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 | 0x18 );
if ( ( localTest2 != localTest1 ) || ( ( i & 0x10 ) == 0 ) ) {
invalidate$test( 97 );
this.$test = localTest1;
invalidate$test( 94 );
onReplace$test( localTest2, localTest1 );
}
this.VFLG$test = ( short ) ( this.VFLG$test & 0xFFFFFFF8 | 0x1 );
return;
case 1:
invalidate$otherBound( 65 );
invalidate$otherBound( 92 );
if ( ( this.VFLG$otherBound & 0x440 ) != 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 = "";
}

}

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….

JavaFX Bug or Feature? Panel doesn’t layout if placed in class

johannes — Sat, 01 May 2010 14:50:26 +0000

I run into a strange problem. I think I have missed something. So every hint is welcome!

Try this demo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.layout.Panel;
import javafx.scene.shape.Rectangle;
import javafx.scene.paint.Color;
import javafx.scene.layout.Container;

public function run( ) {

//Remove the next two lines for a miracle!
Asdf {}}
public class Asdf {

def stage: Stage = Stage {
scene: Scene {
width: 800
height: 600
content: [
{
def p: Panel = Panel {
width: bind stage.scene.width
height: bind stage.scene.height
onLayout: function (): Void {
p.resizeContent();
for ( node in Container.getManaged( p.content ) ) {
Container.positionNode( node, indexof node * 20 + 50, indexof node * 30 + 40, true );
}
}
content: [
Rectangle {
width: 140, height: 90
fill: Color.ORANGE
opacity: 0.5
},
Rectangle {
width: 100, height: 120
fill: Color.BLUE
opacity: 0.5
}, ]
}
},
]
}
};
}

The layout of the panel doesn’t work properly…

Now lets move the stage directly into the run function (just remove two lines):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.layout.Panel;
import javafx.scene.shape.Rectangle;
import javafx.scene.paint.Color;
import javafx.scene.layout.Container;

public function run( ) {

//Remove the next two lines for a miracle!
//Asdf {}}
//public class Asdf {

def stage: Stage = Stage {
scene: Scene {
width: 800
height: 600
content: [
{
def p: Panel = Panel {
width: bind stage.scene.width
height: bind stage.scene.height
onLayout: function (): Void {
p.resizeContent();
for ( node in Container.getManaged( p.content ) ) {
Container.positionNode( node, indexof node * 20 + 50, indexof node * 30 + 40, true );
}
}
content: [
Rectangle {
width: 140, height: 90
fill: Color.ORANGE
opacity: 0.5
},
Rectangle {
width: 100, height: 120
fill: Color.BLUE
opacity: 0.5
}, ]
}
},
]
}
};
}

Now everything works as expected! Any hints?

Just Java

Maven: Fixing table bug for site plugin 2.1

Related Posts:

JUnit @Theory oddities

No DataPoints

A DataPoint method

Removing the static keyword

Related Posts:

JavaFX2Java Bridge added to JFXtras (step 2)

Related Posts:

JavaFX2Java Bridge added to JFXtras (step 1)

Related Posts:

JFXtras: 0.7 RC1 released

Related Posts:

Closing the gap between Java and JavaFX

Java to JavaFX

JavaFX to Java

With inverse…

Related Posts:

Binding PropertyChangeSupport to JavaFX objects transparently

The manual way

Using an automated bridge

Related Posts:

JavaFX Internals Part 2

Extending FXBase

Approaching that binding stuff

Process of dependency notification

Adding dependencies manually

Related Posts:

Analyzing JavaFX

Simple class

Changing var to def

Simple binding

Dirty flags

Getters

Invalidate methods

Generic methods

applyDefaults

Constructor

One var with on replace

Two public-read vars with a on replace method

Binding from other class

Initialzing objects with parameters

Conclusion regarding binding

Related Posts:

JavaFX Bug or Feature? Panel doesn’t layout if placed in class

Related Posts: