JavaFX News, Demos and Insight // FX Experience » Web Services

Maps in JavaFX 2.0

Jasper Potts — Wed, 01 Jun 2011 02:11:10 +0000

Something that you see more and more with client applications at the moment is embedded map components. This blog will show you how to embed Google, Yahoo or Bing maps in your JavaFX application.

Google Maps in JavaFX 2.0

Download a copy of the application and try it out. The jar file is linked below, just download it and double click. This requires you to have the JavaFX 2.0 beta runtime installed.

Download double clickable jar

Using the Application

The toolbar at the top of the application is all JavaFX controls, it communicates with the web map by calling JavaScript functions. Clicking on the Road,Satellite, Hybrid or Terrain sends commands to the JavaScript map library to change the map style. The Google, Yahoo and Bing buttons change the HTML page to use different map providers. As you type in the location field it navigates to the location, try “London” or “New York” for example. The zoom in/out buttons call JavaScript functions to change the map zoom level.

Yahoo Maps in JavaFX 2.0

Bing Maps in JavaFX 2.0

How it’s Built

There are three parts to the application: the HTML and JavaScript code, the JavaFX application and the css styling.

The HTML Code

This is the code for using Google Maps API, there is similar code for Yahoo and Bing in the attached Netbeans project below. This is very basic use of the Google Maps API to create a full page map and provide some constant JavaScript functions that the JavaFX application can call. You could have called the Google API directly from JavaFX but it seemed simpler to provide a basic abstraction layer in JavaScript so the only difference the JavaFX app sees is the URL. The other two APIs Yahoo and Bing require that you register to get a API key to be able to use them. The code is provided you just need to insert you API keys into the HTML files.

The JavaFX Code

The most basic application without the toolbar to just show the map would be:

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.paint.Color;
import javafx.scene.web.WebEngine;
import javafx.scene.web.WebView;
import javafx.stage.Stage;

public class WebMap extends Application {

    @Override public void start(Stage stage) {
        // create web engine and view
        final WebEngine webEngine = new WebEngine(getClass().getResource("googlemap.html").toString());
        final WebView webView = new WebView(webEngine);
        // create scene
        stage.setTitle("Web Map");
        Scene scene = new Scene(webView,1000,700, Color.web("#666970"));
        stage.setScene(scene);
        // show stage
        stage.setVisible(true);
    }

    static { // use system proxy settings when standalone application
        System.setProperty("java.net.useSystemProxies", "true");
    }

    public static void main(String[] args){
        Application.launch(args);
    }
}

The next step is to create the toolbar, this is just a bunch of JavaFX controls in a Toolbar with actions that call the JavaScript functions in the HTML page.

import ....

public class WebMap extends Application {
    private Timeline locationUpdateTimeline;

    @Override public void start(Stage stage) {
        // create web engine and view
        final WebEngine webEngine = new WebEngine(
                getClass().getResource("googlemap.html").toString());
        final WebView webView = new WebView(webEngine);
        // create map type buttons
        final ToggleGroup mapTypeGroup = new ToggleGroup();
        final ToggleButton road = new ToggleButton("Road");
        road.setSelected(true);
        road.setToggleGroup(mapTypeGroup);
        final ToggleButton satellite = new ToggleButton("Satellite");
        satellite.setToggleGroup(mapTypeGroup);
        final ToggleButton hybrid = new ToggleButton("Hybrid");
        hybrid.setToggleGroup(mapTypeGroup);
        final ToggleButton terrain = new ToggleButton("Terrain");
        terrain.setToggleGroup(mapTypeGroup);
        mapTypeGroup.selectedToggleProperty().addListener(
                            new ChangeListener() {
            public void changed(
                    ObservableValue observableValue,
                    Toggle toggle, Toggle toggle1) {
                if (road.isSelected()) {
                    webEngine.executeScript("document.setMapTypeRoad()");
                } else if (satellite.isSelected()) {
                    webEngine.executeScript("document.setMapTypeSatellite()");
                } else if (hybrid.isSelected()) {
                    webEngine.executeScript("document.setMapTypeHybrid()");
                } else if (terrain.isSelected()) {
                    webEngine.executeScript("document.setMapTypeTerrain()");
                }
            }
        });
        // add map source toggles
        ToggleGroup mapSourceGroup = new ToggleGroup();
        final ToggleButton google = new ToggleButton("Google");
        google.setSelected(true);
        google.setToggleGroup(mapSourceGroup);
        final ToggleButton yahoo = new ToggleButton("Yahoo");
        yahoo.setToggleGroup(mapSourceGroup);
        final ToggleButton bing = new ToggleButton("Bing");
        bing.setToggleGroup(mapSourceGroup);
        // listen to selected source
        mapSourceGroup.selectedToggleProperty().addListener(
                            new ChangeListener() {
            public void changed(
                    ObservableValue observableValue,
                    Toggle toggle, Toggle toggle1) {
                terrain.setDisable(true);
                if (google.isSelected()) {
                    terrain.setDisable(false);
                    webEngine.load(
                          getClass().getResource("googlemap.html").toString());
                } else if (yahoo.isSelected()) {
                    webEngine.load(
                          getClass().getResource("bingmap.html").toString());
                } else if (bing.isSelected()) {
                    webEngine.load(
                          getClass().getResource("yahoomap.html").toString());
                }
                mapTypeGroup.selectToggle(road);
            }
        });
        // add search
        final TextBox searchBox = new TextBox("95054");
        searchBox.setColumns(12);
        searchBox.setPromptText("Search");
        searchBox.rawTextProperty().addListener(new ChangeListener() {
            public void changed(
                    ObservableValue observableValue,
                    String s, String s1) {
                // delay location updates to we don't go too fast file typing
                if (locationUpdateTimeline!=null) locationUpdateTimeline.stop();
                locationUpdateTimeline = new Timeline();
                locationUpdateTimeline.getKeyFrames().add(
                    new KeyFrame(new Duration(400),
                            new EventHandler() {
                        public void handle(ActionEvent actionEvent) {
                            webEngine.executeScript("document.goToLocation(\""+
                                    searchBox.getRawText()+"\")");
                        }
                    })
                );
                locationUpdateTimeline.play();
            }
        });
        Button zoomIn = new Button("Zoom In");
        zoomIn.setOnAction(new EventHandler() {
            public void handle(ActionEvent actionEvent) {
                webEngine.executeScript("document.zoomIn()");
            }
        });
        Button zoomOut = new Button("Zoom Out");
        zoomOut.setOnAction(new EventHandler() {
            public void handle(ActionEvent actionEvent) {
                webEngine.executeScript("document.zoomOut()");
            }
        });
        // create toolbar
        ToolBar toolBar = new ToolBar();
        toolBar.getStyleClass().add("map-toolbar");
        toolBar.getItems().addAll(
                road, satellite, hybrid, terrain,
                createSpacer(),
                google, yahoo, bing,
                createSpacer(),
                new Label("Location:"), searchBox, zoomIn, zoomOut);
        // create root
        BorderPane root = new BorderPane();
        root.getStyleClass().add("map");
        root.setCenter(webView);
        root.setTop(toolBar);
        // create scene
        stage.setTitle("Web Map");
        Scene scene = new Scene(root,1000,700, Color.web("#666970"));
        stage.setScene(scene);
        scene.getStylesheets().add("/webmap/WebMap.css");
        // show stage
        stage.setVisible(true);
    }

    private Node createSpacer() {
        Region spacer = new Region();
        HBox.setHgrow(spacer, Priority.ALWAYS);
        return spacer;
    }

    static { // use system proxy settings when standalone application
        System.setProperty("java.net.useSystemProxies", "true");
    }

    public static void main(String[] args){
        Application.launch(args);
    }
}

The CSS Code

The last part of the application is a little css to style the toolbar and make it look dark to stand out from the maps.

.map{
    -fx-background-color: #666970;
}
.map-toolbar .button, .map-toolbar .toggle-button, .map-toolbar .label {
    -fx-text-fill: white;
    -fx-background-radius: 0;
}
.map-toolbar{
    -fx-base: #505359;
    -fx-background: #505359;
    -fx-shadow-highlight-color: transparent;
    -fx-spacing: 5;
    -fx-padding: 4 4 4 4;
    -fx-background-color: linear (0%,0%) to (0%,100%) stops
                (0%,#919398)
                (4%,#919398)
                (4.1%,#666970)
                (66%,#494d53)
                (94%,#3c3f46)
                (94.1%,#515151);
}

Download Source

Download Netbeans Project

Writing a Java-based Task

Richard Bair — Tue, 24 Nov 2009 15:12:04 +0000

In a post from earlier this year I explored the concept of background tasks in JavaFX. If you haven’t yet, you might want to review that article before reading on. For the impatient: JavaFX is currently a single threaded programming language. All code you write in JavaFX occurs on the same thread. Since you don’t want to write an unresponsive application, you need to write long-lived operations on a background thread. The Task API provides a single consistent abstraction which all background operations in JavaFX are based on. This means whether you are computing fibonacci sequences, breaking down protein chains, writing to a database or reading data from disk there is a single consistent programming model and API that your GUI communicates with. And we think this is a pretty good idea.

RunnableFuture Bug in FX 1.2

JavaFX Script has to compile on desktop, mobile, and tv platforms. This puts some constraints on what Java API we can use for the core JavaFX platform.

The real RunnableFuture class in the java concurrent utils is one of these classes that we couldn’t use because it wasn’t available on all platforms, yet. So we wanted to use essentially the same interface, but needed to put it into the javafx namespace.

That is why we added a RunnableFuture interface to the javafx.async package. However, somehow along the way it got whacked and ended up looking just like Runnable. Doh! This will be fixed in the next release.

Because each background task is encapsulated in a Task subclass of some kind, it also provides a convenient programming model for third party developers to build libraries of background tasks. For example, I expect third party libraries like jfxtras will probably provide several reusable tasks such as for reading lines of text from files, saving data to disk, executing SQL queries, or other such operations. You will likely want to create your own set of such background tasks as you commonly encounter to keep handy in your own toolbox.

Because we require all background work to be done in a background Java thread, we have provided a helper class called JavaTaskBase from which you should extend to create custom background tasks. Unfortunately we made one small (and rather embarrassing) error in the 1.2 release which, while it will not impact your code much when you upgrade to 1.3, you should be aware of (see sidebar for details). We would also like to make the JavaTaskBase more convenient for you to use, although what we have currently I found rather quite friendly and helped me write threaded code rather cleanly.

JavaTaskBase

The Task class contains many different lifecycle variables, events, and functions. When you create a JavaTaskBase subclass, you get all of this for free. Your main responsibility is simply to define the parameters to the background thread, the results of the background computation, and the Java implementation that will carry out the work on the background thread.

Step 1: Define the input parameters

Let’s take as our example a simple Task implementation which reads the contents of a File from the file system and returns the entire contents as a single String. What would we need to define as the input parameters? For the simple case, it is probably sufficient to simply provide a path to the file as the input parameter. For the sake of this example, we’ll assume that this Task accesses the local filesystem only.

public class LocalFileReader extends JavaTaskBase {
    public-init var path:String;
}

In the above code, we defined the path to the file as a public-init var. This means that it is a variable that can only be set by external code during init time — essentially rendering this variable immutable. This is an important key point about Tasks — they are designed to be used once and then thrown away, not reused. Create a new instance whenever you need to perform a new task.

Step 2: Define the results

Now that we have defined our input parameter, we should add to our class whatever output values, event handlers, or other API that the user would use during the course of this operation, or at its completion. In the case of our file reader, we are going to provide a single String variable which will contain the entire contents of the file as a single String. This is obviously a contrived example as it would only be useful with very small files, but should demonstrate many of the issues in building a basic Task implementation.

public class LocalFileReader extends JavaTaskBase {
    public-init var path:String;

    /**
     * The contents of the file as a String. This is populated upon successful
     * completion of the background task.
     */
    public-read var contents:String;
}

The contents variable is defined as public-read var, meaning that it is publicly readable but not publicly settable. The LocalFileReader class itself can write to the variable (which is a good thing or it could never be set!), but no other code can.

Step 3: Define the Java implementation

We are now ready to write the Java implementation of the background task. To do this we simply need to create a Java class which implements RunnableFuture (see sidebar for conversation). The Java implementation will generally also be an immutable object, and in our case, that is exactly what we are going to do.

public class LocalFileReaderImpl implements RunnableFuture {
    /** The path to the file to read */
    private String path;
    /** The buffer to contain the contents of the file */
    private StringBuffer contents;

    public LocalFileReaderImpl(String path) {
        this.path = path;
        this.contents = new StringBuffer();
    }

    /**
     * All code executed in the run() method is done so on a background thread
     * and can happily take as long as it likes. Exceptions that occur will be
     * passed along to users of your Task for you
     */
    public void run() throws Exception {
        FileInputStream in = new FileInputStream(path);
        try {
            BufferedInputStream bin = new BufferedInputStream(in);
            String line = null;
            while ((line = bin.readLine()) != null) {
                contents.append(line);
                contents.append("\n");
            }
        } finally {
            try { in.close(); } catch (Exception e) { }
        }
    }
}

The run method executes on the background thread. JavaFX will make sure this happens, reusing threads in a thread pool and so forth. For advanced users, if you absolutely must manage your own thread pools or concurrency on a very fine-grained level, you will probably want to create your own JavaTaskBase equivalent which extends directly from Task.

At the conclusion of the run method, the contents buffer has been completely populated with the file contents and the input stream has been closed. Now we must add a single method to our LocalFileReader which will create and return the LocalFileReaderImpl so that JavaFX knows what Java code to call when it comes time to call it on a background thread.

public class LocalFileReader extends JavaTaskBase {
    //.… other code goes here as defined in the previous examples ….

    /** save a reference to this, we'll need it later */
    var impl:LocalFileReaderImpl;

    /**
     * Create and return an instance of the imp class. This is called
     * when the task is started.
     */
    override function create() { impl = new LocalFileReaderImpl(path) }
}

We now have created our Task and its Java implementation. However there is one big problem remaining, which is that when the task completes, our LocalFileReader has no way of knowing that this has occurred. We will add some convenience API to JavaTaskBase to make this a bit easier, but for the moment we can solve the problem by simply introducing a callback interface. Our LocalFileReader will implement this interface and the LocalFileReaderImpl will invoke the “finished” function of this interface when the background task completes. The LocalFileReader can then read the finished contents buffer from the impl class and set its own contents variable with the final result. The complete source code for this example is found below.

public interface FinishedHandler {
    public void finished();
}

Now have LocalFileReader implement this interface and pass a reference of “this” down to the imp:

public class LocalFileReader extends JavaTaskBase, FinishedHandler {
    /** A path to a file on the local file system */
    public-init var path:String;

    /**
     * The contents of the file as a String. This is populated upon successful
     * completion of the background task.
     */
    public-read var contents:String;

    /** save a reference to this, we'll need it later */
    var impl:LocalFileReaderImpl;

    /**
     * Create and return an instance of the imp class. This is called
     * when the task is started.
     */
    override function create() { impl = new LocalFileReaderImpl(this, path) }

    /**
     * This is called by the imp while still on the background thread so our
     * very first responsibility is to call FX.deferAction, which will execute the
     * supplied anonymous function on the FX event thread
     */
    override function finished() {
        FX.deferAction(function() {
            contents = impl.contents.toString();
        });
    }
}

public class LocalFileReaderImpl implements RunnableFuture {
    /** The handler to call when we have finished reading from the file */
    private FinishedHandler handler;
    /** The path to the file to read */
    private String path;
    /** The buffer to contain the contents of the file */
    private StringBuffer contents;

    public LocalFileReaderImpl(FinishedHandler handler, String path) {
        this.handler = handler;
        this.path = path;
        this.contents = new StringBuffer();
    }

    /**
     * All code executed in the run() method is done so on a background thread
     * and can happily take as long as it likes. Exceptions that occur will be
     * passed along to users of your Task for you
     */
    public void run() throws Exception {
        FileInputStream in = new FileInputStream(path);
        try {
            BufferedInputStream bin = new BufferedInputStream(in);
            String line = null;
            while ((line = bin.readLine()) != null) {
                contents.append(line);
                contents.append("\n");
            }
            handler.finished();
        } finally {
            try { in.close(); } catch (Exception e) { }
        }
    }
}

There are loads of variations that you can make as suits your task. For example, you could establish a long running background task with job queues, callbacks, and more complicated state management (extra bonus props for the first person to implement a Python or Ruby like file read operation conveniently in FX). You can execute database calls or web service calls or other such long running tasks.

In the future we will add more convenience variables to JavaTaskBase, and maybe provide an implementation base class as well to help ease things. For example it would be nice to do away with the custom FinishedHandler and instead to have JavaTaskBase automatically realize when a task has finished and invoke an overridden function in the sub class that does the synchronization. In the future we hope to add threading support tightly into the language itself which will make a lot of this easier. While there are a number of steps involved, there is not much code involved and it is fairly straightforward — as far as threading code goes that is!

Enterprising JavaFX @ #devoxx

Richard Bair — Wed, 18 Nov 2009 12:16:50 +0000

In a couple hours Jasper and I will be presenting a talk titled “Enterprising JavaFX” at Devoxx. The main purpose of the talk is to describe how to use JavaFX for writing enterprise application content. Here’s a quick teaser screenshot of one of the apps we’re going to describe:

Jira Dashboard Application

We’ll be writing some additional blog posts over the next few weeks describing various tips n’ tricks as to how we used web services in this app, how we wrote the custom list cells, and so forth.

Background Tasks in JavaFX

Richard Bair — Mon, 22 Jun 2009 15:01:32 +0000

While on vacation I’ve been watching twitter to see what kinds of things people are doing with JavaFX. One thing I’ve seen a fair amount of tweets on that is pretty gratifying is tying JavaFX to backend data services. One project is a port of Cairngorm from Flex to Java/JavaFX. Another was an earlier demo based on Hessian (which needs to be ported to JavaFX 1.2). Another was about integrating Flamingo to JavaFX.

It’s great to see a lot of people starting to play with this part of the JavaFX space because we haven’t really given much guidance to it yet. We do have some great web service APIs as a starting point (basic HTTP with HttpRequest, RSS and ATOM feed support), but haven’t so far given any guidance as to writing an end to end app. I wanted to take just a moment and outline how we designed the Task API and how it ought to be used by third parties when creating background tasks or services, including communicating with a server.

I also wanted to give a shout out to an excellent blog by my colleague Baechul who has been writing some very detailed and well written articles on JavaFX. Of particular interest to this post is one he wrote on JavaFX 1.2 Async.

The Task class in the javafx.async represents the basic programming model for all asynchronous tasks in JavaFX and should form the base class for all such background Tasks. Its design was heavily influenced by the excellent work of Hans Muller on the Swing Application Framework. All JavaFX Tasks have the notion of “state” and “progress”. The state of the Task is expressed though a series of public API members:

started:Boolean
stopped:Boolean
failed:Boolean
succeeded:Boolean
done:Boolean

We chose to break these states out into Boolean properties rather than have a single property with an enum for two reasons. First, it makes it a little cleaner in the onDone event handler to find out what state the Task ended up in, especially when checking for several states. Second, this allows you to bind to the state of the Task from an external class using some rather clean code. For example, suppose you had a progress indicator and error icon and wanted to make it so that if the task failed, the error icon would be made visible, otherwise the progress indicator would be visible and display progress appropriately.

Group {
    content: [
        ProgressIndicator {
            visible: bind task.started and not task.failed and not task.stopped
            progress: bind task.percentDone
        }
        ErrorIndicator { // this class doesn't exist, but you could write a CustomNode
            visible: bind task.started and task.failed
            causeOfFailure: bind task.causeOfFailure
        }
    ]
}

You’ll notice in this code block I’m also taking advantage of another really nice feature of Task and ProgressIndicator. A ProgressIndicator has a progress property which, if -1, means it is indeterminate but if between 0 and 1 then it indicates the percent done. Task also has a similar property called percentDone where, if -1, it means that the progress of the Task is also indeterminate. This makes binding a ProgressIndicator to a Task very clean. Simply bind like this: ProgressIndicator { progress: bind task.percentDone } and the rest works exactly like it should (switching between determinate and indeterminate mode automatically).

There are several API members for tasks for tracking progress:

progress
maxProgress
percentDone

To help explain these properties lets imagine that our Task was to read a file from disk. In this case, progress could be used to indicate the number of bytes read from disk. maxProgress would indicate the size of the file in bytes, and percentDone would be automatically calculated based on progress and maxProgress. In this way, you can create a UI which will track not only the percent done, but also the discrete amount of work to be done, and how much has been done.

Another simple example would be computing prime numbers. Suppose your app wanted to compute the first 5 prime numbers. In this case, maxProgress would be 5, and progress would be incremented each time a prime number is computed.

Finally, there are two event handlers that all Tasks share: onStart and onDone. onStart is called whenever the Task’s start() method is called, not when the background task is actually started. For example, your Task implementation might push work onto a worker queue. In this case, onStart should be called immediately after start() is invoked, not when the actual background worker that was pushed on the queue starts working.

The onDone function is called whenever the task stops, for any reason. If the task was cancelled manually, or if there was a failure, or if the task completed successfully. In all these cases onDone will be called. I’d like to add “onSuccess” and “onFailure” and “onStopped” events in the future. It is the developer’s responsibility in onDone to check the state of the Task to determine whether the task succeeded or failed or was stopped by checking the state booleans of the Task.

All background operations in JavaFX should extend from Task. This design gives application developers a single common programming model to use with all background operations developed by the JavaFX team or by third party developers. HttpRequest was refactored to be a Task in 1.2 (hence the reason for some of the API changes between 1.1 and 1.2).

There is one major caveat that I need to make clear. As of JavaFX 1.2, JavaFX Script is single threaded. All background work must be done in Java code. The JavaTaskBase abstract class is the base class intended to be used by all background threading implementations in JavaFX 1.2. Unfortunately, the hookup between JavaTaskBase and RunnableFuture didn’t come out right in 1.2 and you’re left with very little guidance as to how to do this appropriately.

The key thing is to understand that nothing should touch JavaFX variables from a background thread. So the idiom to use is to have the JavaTaskBase subclass to have a Java language peer which does the background work. The JavaTaskBase subclass would register a listener on the peer, and the peer would communicate back to the JavaTaskBase through that listener interface. The JavaTaskBase subclass would then pump events from the peer back onto the JavaFX thread (i.e. event thread) using FX.deferAction.

That’s a whole other blog entry though. For starters, I suggest reading Baechul’s take on it.

There is one last thing I wanted to mention, which is a futures item which Brian Goetz and I have been bouncing around a bit. It’s completely pie-in-the-sky at this point, take it with a grain of salt, etc etc. Having to write background tasks in Java is a pain at the moment primarily because you cannot create JavaFX objects in a background thread. Also, it involves writing a messaging interface, a Java class, and a JavaTaskBase subclass. What I’d like to see is something like this:

var task = BackgroundTask {
    run: function() {
        // code in this function runs in a background thread
        defer(function() {
            // code in this function runs on the JavaFX thread
        });
    }
}

The kicker is, the compiler would check and enforce that you don’t illegally modify application state from the background thread, but that you can when using “defer” or “deferAction”. The thing that gets me all excited about the idea is that we don’t have to expose a full threading model (with synchronicity, concurrent collections, memory barriers, semaphores, or anything else), but can instead simplify the problem by having a much more limited coarse grained approach of “this body of work happens in some background thread”. If you want or need to have a full threading model, then we still make that available by writing a JavaTaskBase subclass, but for the vast majority of uses, you could just use the simplified BackgroundTask model.

Vaibhav: Charts and RSS

Richard Bair — Wed, 10 Jun 2009 16:05:57 +0000

Another link I found the other day to a blog posting by Vaibhav Choudhary on using the JavaFX 1.2 Charting APIs.

He then followed up with a blog populating a chart from a web service call. The important pieces are the following code blocks. The first here is what generates the Pie Chart data slices after the web service call succeeded:

function generateChartData(tg:TagInformation, done:Boolean):PieChart.Data[] {
    for (i in [0..
This function generateChartData simply returns a sequence of PieChart.Data instances. “for loop” expressions in JavaFX yield a sequence, one item for each iteration of the loop. So the generated sequence will be one PieChart.Data for each result in the tg.tag sequence.
This next block of code uses the HttpRequest class to fetch and parse the RSS feed from Del.icio.us. The only thing here that I might have done differently, is to have used the RSS APIs introduced in JavaFX 1.2 rather than hand rolling my own parsing code and using HttpRequest. First the code from the blog doing it the “long” way:
public class TagInformation {
    public var tag: String[]=[];
    public var tagCount: Integer[]=[];
    public var username: String = "javafx";  // for this sample it's javafx
    public-read var done = false;
    var url = bind "http://feeds.delicious.com/v2/rss/tags/{username}?count=4";
    var p: PullParser;
    var h: HttpRequest;
    init {
            h = HttpRequest {
                location: url
                onException: function(exception: Exception) {
                    exception.printStackTrace();
                }
                onInput: function(input) {
                    p = PullParser {
                        input: input
                        onEvent: function(event) {
                            if ((event.type == PullParser.END_ELEMENT)) {
                                if (event.qname.name == "title" and
                                    event.level == 3) {
                                   insert event.text into tag;
                                }
                                if(event.qname.name == "description" and
                                    event.level == 3){
                                   insert Integer.parseInt(event.text)
                                   into tagCount;
                                }
                            }
                        }
                    };
                    p.parse();
                    p.input.close();
                }
                onDone: function() {
                    Main.showtag = false;
                    done = true;
                }
            };
            h.start();
        }
    }
And now here is how I would have done it using the JavaFX 1.2 APIs. In JavaFX 1.2 we released some ATOM and RSS support. These classes are in the javafx.data.feed package.
public class TagInformation {
    public var tag: String[]=[];
    public var tagCount: Integer[]=[];
    public var username: String = "javafx";  // for this sample it's javafx
    public-read var done = false;
    var url = bind "http://feeds.delicious.com/v2/rss/tags/{username}?count=4";
    init {
		RssTask {
	        location: "http://feeds.delicious.com/v2/rss/tags/javafx?count=4"
	        interval: 1h
	        onItem: function(item) {
	            insert item.title into tag;
	            insert Integer.parseInt(item.description) into tagCount;
	        }
	        onDone: function() { done = true }
	    }.start();
    }
}
The only thing here that I found somewhat irritating and will get put on the bug list for the next release is that you must specify an interval for the RssTask, even if you won’t be polling. Expect this to change to some reasonable polling value as the default. Maybe 1 hour (as in this example) isn’t a bad default. 1 minute is a bit more extreme, but for the feed-junkies out there maybe that’s a better default.
As you can see, the code is much simpler using the feed APIs. I guess that’s a good thing  . The RSS/ATOM feed APIs use the same basic programming model as HttpRequest — both extend from Task. Task’s have API for monitoring progress, canceling, starting, handling error condition, etc in a unified model. All asynchronous operations in JavaFX should extend from Task either directly or indirectly.