And the best matched turned out to be Robusta Pro SemiCond

Identifont suggested Anivers but I thought it was way off mark.

What do you think Amble was?

Imagine my delight when I found the JavaFX SDK ships with an interactive shell.

C:\javafx-sdk1.2\>java -Djava.ext.dirs=lib/desktop;lib/shared/ com.sun.tools.javafx.script.
ScriptShell
/*fx1*/ def circle = javafx.scene.shape.Circle {centerX: 50 centerY: 50 radius:80 fill:javafx.scene.paint.Color.PURPLE }
le
/*fx2*/ def stage = javafx.stage.Stage { title: "Interactive stage" width: 400 height: 300 }
fx.stage.Stage@c7057c
/*fx3*/ import javafx.scene.Scene;
/*fx4*/ stage.scene = Scene {content: circle};
fx.scene.Scene@19e733e

Why do this?

Firstly, if you make any syntax errors, they get caught straight away. So explore away, saving the working snippets into your final source file.

Secondly, results are immediate. There is no need to restart the javafx application. Time is money.

import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.layout.*;
import javafx.ext.swing.SwingTextField;
import javafx.ext.swing.SwingButton;

Stage {
    title : "MyApp"
    scene: Scene {
        width: 200
        height: 200
        content: [
            VBox{
                content:
                [
                SwingTextField {
                columns: 10
                text: "TextField"
                editable: true
                },
                SwingButton {
                text: "Button"
                action: function() {  }
                }]
            }

        ]
    }
}

SwingTextField barfs like this:

Exception in thread "AWT-EventQueue-1" java.lang.IllegalArgumentException: Zero length string passed to TextLayout constructor.
        at java.awt.font.TextLayout.(TextLayout.java:364)
        at sun.font.FontDesignMetrics.charsWidth(FontDesignMetrics.java:487)
        at javax.swing.text.Utilities.getTabbedTextWidth(Utilities.java:262)
        at javax.swing.text.Utilities.getTabbedTextWidth(Utilities.java:191)
        at javax.swing.text.PlainView.modelToView(PlainView.java:335)
        at javax.swing.text.FieldView.modelToView(FieldView.java:248)
        at javax.swing.plaf.basic.BasicTextUI$RootView.modelToView(BasicTextUI.java:1496)
        at javax.swing.plaf.basic.BasicTextUI.modelToView(BasicTextUI.java:1034)
        at javax.swing.text.DefaultCaret.paint(DefaultCaret.java:600)
        at javax.swing.plaf.basic.BasicTextUI.paintSafely(BasicTextUI.java:730)
        at javax.swing.plaf.basic.BasicTextUI.paint(BasicTextUI.java:868)
        at javax.swing.plaf.basic.BasicTextUI.update(BasicTextUI.java:847)
        at javax.swing.JComponent.paintComponent(JComponent.java:758)
        at javafx.ext.swing.JTextFieldImpl.paintComponent(JTextFieldImpl.java:77)
        at javax.swing.JComponent.paint(JComponent.java:1022)
        at javax.swing.JComponent.paintChildren(JComponent.java:859)
        at javax.swing.JComponent.paint(JComponent.java:1031)
        at com.sun.embeddedswing.EmbeddedPeer.paint(EmbeddedPeer.java:135)
        at com.sun.scenario.scenegraph.SGComponent.paint(SGComponent.java:121)
        at com.sun.scenario.scenegraph.SGLeaf.render(SGLeaf.java:179)
        at com.sun.scenario.scenegraph.SGWrapper.render(SGWrapper.java:122)
        at com.sun.scenario.scenegraph.SGGroup.render(SGGroup.java:222)
        at com.sun.scenario.scenegraph.SGWrapper.render(SGWrapper.java:122)
        at com.sun.scenario.scenegraph.SGGroup.render(SGGroup.java:222)
        at com.sun.scenario.scenegraph.SGGroup.render(SGGroup.java:222)
        at com.sun.scenario.scenegraph.JSGPanel.paintComponent(JSGPanel.java:582)
        at javax.swing.JComponent.paint(JComponent.java:1022)
        at javax.swing.JComponent.paintChildren(JComponent.java:859)
        at javax.swing.JComponent.paint(JComponent.java:1031)
        at javax.swing.JLayeredPane.paint(JLayeredPane.java:564)
        at javax.swing.JComponent.paintChildren(JComponent.java:859)
        at javax.swing.JComponent.paintToOffscreen(JComponent.java:5111)
        at javax.swing.RepaintManager$PaintManager.paintDoubleBuffered(RepaintManager.java:1386)
        at javax.swing.RepaintManager$PaintManager.paint(RepaintManager.java:1317)
        at javax.swing.RepaintManager.paint(RepaintManager.java:1132)
        at javax.swing.JComponent.paint(JComponent.java:1008)
        at java.awt.GraphicsCallback$PaintCallback.run(GraphicsCallback.java:21)
        at sun.awt.SunGraphicsCallback.runOneComponent(SunGraphicsCallback.java:60)
        at sun.awt.SunGraphicsCallback.runComponents(SunGraphicsCallback.java:97)
        at java.awt.Container.paint(Container.java:1797)
        at javax.swing.RepaintManager.paintDirtyRegions(RepaintManager.java:738)
        at javax.swing.RepaintManager.seqPaintDirtyRegions(RepaintManager.java:667)
        at javax.swing.SystemEventQueueUtilities$ComponentWorkRequest.run(SystemEventQueueUtilities.java:128)
        at java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:209)
        at java.awt.EventQueue.dispatchEvent(EventQueue.java:597)
        at com.sun.embeddedswing.EmbeddedEventQueue.dispatchEvent(EmbeddedEventQueue.java:369)
        at java.awt.EventDispatchThread.pumpOneEventForFilters(EventDispatchThread.java:273)
        at java.awt.EventDispatchThread.pumpEventsForFilter(EventDispatchThread.java:183)
        at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:173)
        at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:168)
        at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:160)
        at java.awt.EventDispatchThread.run(EventDispatchThread.java:121)

Running javafx with the verbose switch pointed the fault out

javafx -verbose:class test
:
:
[Loaded java.awt.Container$EventTargetFilter from c:\Progra~1\Java\jdk1.6.0\jre\lib\rt.jar]
:

I was running an old version of the JDK!
Unsetting the JAVA_HOME resolved the problem.
I hope this helps somebody.

import java.awt.Toolkit;
import javafx.scene.Cursor;
import javafx.scene.image.Image;

public class ColorChooser extends Cursor
{
    public override function impl_getAWTCursor(): java.awt.Cursor {

        def url = "{__DIR__}eyedropper.png";

        var toolkit = Toolkit.getDefaultToolkit();

        var image = Image{width:32 height:32 url:url}.bufferedImage;
        var hotspot = new java.awt.Point(0,15);
        var cursor = toolkit.createCustomCursor(image, hotspot, "colorpicker");
        return cursor;
    }
}

public def ColorChooserCursor=ColorChooser{};

public function run()
{
    javafx.scene.shape.Rectangle
    {
        x:5 y:5
        width:200 height:200
        cursor:ColorChooserCursor
    }
}

Tags: javafx

function getValueType(obj:Object,name:String):String
{
    var context:FXLocal.Context=FXLocal.getContext();
    var objectValue:FXLocal.ObjectValue = new FXLocal.ObjectValue(obj,context);
    var cls:FXClassType = objectValue.getClassType();
    var varType:FXType = cls.getVariable(name).getType();
    println("{name} {varType}");
    if (varType instanceof FXSequenceType)
    {
        return "array";
    } else if (varType instanceof FXClassType) {
        return "element";
    } else {
        return "value";
    }
}

Thanks to James Weaver for tips on JavaFX Reflection API

var circles:Circle[];
var group:Group = Group { content: [circles] };

strangely, I couldn’t get newly inserted circles to render.

It turns out that you have to bind group.content to ensure that changes in circles are reflected in group.content.

Here’s a test routine.

import javafx.scene.*;
import javafx.scene.paint.*;
import javafx.scene.shape.*;
import javafx.stage.*;

var lines = for (i in [1..10])
    Line {startX:i*30 startY:20 endX:i*20 endY:500};

var circles = for (i in [1..10])
    Circle {centerX:i*30 centerY:50 radius:20};

Stage
{
    scene: Scene
    {
        content: Group
        {
            content: // bind
            [

                Rectangle {fill:Color.YELLOW width:800 height:500}
                circles,
                lines,

            ]

            onMouseClicked: function(e)
            {
                println('clicked');
                insert Circle {fill:Color.RED centerX:e.x centerY:e.y radius:20} into circles;
            }

        }

    }
}

Uncomment the //bind and observe the difference.

On with the list.

Wins

• bind keyword – it took a while, but finally concepts from sloppy tools like Excel is making it’s way into mainstream programming languages. Programmers should never have to do the work that a computer can do just as well.
• First class support for animations The language simplifies the process of creating keyframe-styled animations, without having to launch background threads, worry about EDT and having to write callback code for timers.
• Object initializer syntax Using keyword-style arguments suits objects which has tonnes of properties
• effect property in Nodes makes it straightforward to add “bling” to a project without having to rearrange program layout
• strong support for functional-style programming List comprehensions, filter, map. Built into the language.

Losses

• Javaesque layouts, not Webesque – containers are emphasised over styles. This is not going to win any points with the semantic crowd.
• Difficulty in adding extension points – I would have favoured seeing C# static extension methods in the language. It would have made adding behaviors easier. For instance, centering a piece of text takes more effort than it should, and once done it could not be easily refactored and added to other elements. I regard this as a wart in a DSL that aims to support animators.
• Difficulty in adding behaviors – adding behaviors like “clickable”, “hoverable”, “draggable” requries programmatic intervention, rather than being able to declaratively do this. This is due to the absence of extension points above, and the absence of namespacing from the YAML syntax. XML-style syntax would have been kinder to these kind of mashups.
• The DSL may be suited for laying out standard blocky objects, but (I was working with Vim and) it was hard to lay things out by hand. One still needs to fall back on a graphic editor to create most of the resources.
• The story on accessibility is still unclear – granted that JavaFX is a DSL for graphics and animations, however, it’s target is to be a platform for developing applications. Without a clear accessibility story, JavaFX will never see the doors of a government application, or a public-facing application of large corporations.
• event handlers – there is only one for each event. I couldn’t figure out why. onclick=”…” is so 1997.

Recommendations

• Tools support is essential The language compiler project should make the abstract syntax trees available so that third parties can easily develop tools to parse the language. Currently, it is a one-way conversion from Adobe/SVG to FXD. Syntax sugar in the Timeline, duration may be cutesy, but we need parsers please.
• Extend language to make it easy for developers to add custom attributes and behaviors to graphical nodes. The OpenJFX developers should wrap Centering layout code for each graphical shape to see how weak JavaFX is in this area.
• More support to attract web developers – the people who are writing the specs come from a Java development background, and it shows. The JavaFX language team needs a few web developers on the advisory board to make it easy to attract this particular constituent.
• more interfaces and less inheritance – when writing layout code, I’m frequently stymied by containers like scene and stage which do not have the same base classes, making it hard to measure width and height.

You’d be surprised to note that both pieces of text below are aligned using TextAlignment.CENTER.

import javafx.scene.text.*;
import javafx.scene.layout.*;

VBox
{
    translateY:10
    content:
    [
    Text {
        textAlignment:TextAlignment.CENTER
        content: "A New World"
    }
    ,
    Text {
        textAlignment:TextAlignment.CENTER
        content: "A Mighty Pub\nwith\nAbsolutely No Bitter Beer"
    }
    ]
}

Apparently, the state of the art work-around is to calculate the mid-point using myTextNode.boundsInLocal.width, and then position using translateX.

Not good enough, Sun. Not good enough.

Here’s the worked around code

import javafx.scene.*;
import javafx.scene.text.*;
import javafx.scene.layout.*;

var scene:Scene;
scene=Scene
{
    content:
    {
        VBox
        {
            translateY:10
            content:
            [
            Text {
                id: "label1"
                translateX: bind (scene.width-scene.lookup("label1").boundsInLocal.width)/2
                textAlignment:TextAlignment.CENTER
                content: "A New World"
            },
            Text {
                id: "label2"
                translateX: bind (scene.width-scene.lookup("label2").boundsInLocal.width)/2
                textAlignment:TextAlignment.CENTER
                content: "A Mighty Pub\nwith\nAbsolutely No Bitter Beer"
            },
            ]
        }
    }
}

import javafx.scene.CustomNode;
import javafx.scene.Group;
import javafx.scene.Node;
import javafx.scene.shape.Rectangle;
import javafx.scene.paint.Color;
import java.lang.Math.sqrt;

class C extends CustomNode
{
    // Test #1: Commented out
    //var node: Group = Group {};

    protected override function create():Node
    {
        return node;
    }

    public var data:Number[] on replace olddata
    {
        for (item in data)
        {
            var side:Number = sqrt(item);
            insert Rectangle{
                width:side height:side
                stroke:Color.RED strokeWidth:2 fill:Color.TEAL
            }
            into node.content;
        }
    }

    // Test 2: Comment out
    var node: Group = Group {};
}

C { data: [21000, 10000]; }

One of these declares node at the end of the class, and the other declares it at the beginning of the class. Take a look at it for a while and see if you can guess the difference in behaviour?

Answer

The “on replace” trigger for data attribute does not throw an exception in Test #2 despite the fact that node is null.

Moral of the story

Order of initialization matters. Make sure you initialize variables before triggers are defined.

How are – say – Rectangles defined?

Is the startX based on center lines? or is it from the origin?

What about borders? Are borders painted to the bottom right of the origin?

How is the boundsInLocal defined?

Here is a piece of test code.

Rectangle
{
    strokeWidth:50 fill:null stroke:Color.BLACK
    x:0 y:0 width:200 height:200
}

and I didn’t like what I saw:

Overlaying a grid, we could see that the X and Y origins are indeed based on center lines.

The big disappointment comes from the boundsInLocal measurements:

Rectangle2D [
minX = -35.85533905029297,
minY=-35.85533905029297,
maxX=235.85535430908203,
maxY=235.85535430908203,
width=271.710693359375,
height=271.710693359375]

This doesn’t make any sense at all, and is going to make laying out components properly that much harder.