Wow, it’s September already! This year is flying by, and JavaOne is right on the door step. This week there is a bunch of interesting news: let’s get right into it!

• Osvaldo Doederlein has an article discussing how he attempted to solve a DropBox coding challenge using JavaFX. In his usual style this is an interesting and informative read.
• Irina Filippova has a detailed article discussing how to create a simple database client using the JavaFX Composer.
• The SmartFaces project is starting to embrace JavaFX, with a SpellChecker component being the latest addition to the component suite that is written in JavaFX.
• Nick Apperley announced the release of JFX Blocks 0.3, which includes new controls, and more focus on media playback functionality.
• siesiek has a simple tutorial explaining how to use the JavaFX bind functionality to center nodes in a container or scene.
• The JavaFX Cookbook website has a brief tutorial on using the JavaFX reflection API. Note that reflection is slow, so use it sparingly, and only where absolutely necessary.

That’s that for another week. I hope you found a useful link or two. Catch you all again next week

A very quiet week in the land of the JavaFX. I put this partly down to the JavaOne effect – everyone is off working on their talks and not blogging as much – the same thing happened last year. As always, feel free to email me with any comments or suggestions you may have.

On with the news!

• With the release of his new book, Vladimir Vivien has also posted a JavaFX Cookbook website with a number of useful tutorials.
• Mayboroda Dmitiry has two posts this week. His first post discusses improvements to my multiple selection hack for ListView. His second post discusses creating pseudo classes in JavaFX, and builds a TabPanel control to demo it (with source code). I’m not sure what it is with TabPanel / TabView controls – we all seem to be building them
• William Antônio showed off his HttpRequester application which is essentially a GUI frontend for the JavaFX HttpRequest class.

That’s it for another week. Thanks for coming along and I hope something in the links list was helpful to you. Catch you all in a weeks time

Another week has started, so it must be time for another batch of JavaFX links. As per usual there are some very good links this week, so enjoy

• Srikanth Shenoy has released FxContainer 1.0, which is an IoC container written in JavaFX, for JavaFX applications. You can learn more about FxContainer as a PDF (or an embedded PDF if you prefer).
• Exadel have released the 1.3.5 release of their free JavaFX Plugin for Eclipse. The two major features of this release are ’setting VM parameters for JavaFX application’ and ‘option to specify custom JNLP arguments’.
• Osvaldo Doederlein has continued his deep dive series of posts, this time covering ‘JDK 6u21, JavaFX 1.3.1 and Deployment‘.
• In another post, Exadel have announced that Exadel Flamingo now supports CDI and Bean Validation for JavaFX.
• William Antônio has blogged about an application he created to retrieve images from various web services, and to manipulate them locally.
• Yücel Ünlü has blogged about using code optimization software to reduce the size of JavaFX applications.
• Henrik Samuelsson has created a JavaFX application for people wanting to improve their poker skills.
• Richa Singhal has provided a JavaFX Marquee effect. Use with caution (because no one likes marquees ).

That’s it for another week. Thanks to everyone for emailing links to include. I’ll catch you all again in a weeks time

Another week, another batch of JavaFX posts for you to check out. Enjoy!

• Eric Bruno has posted an article over at Dr Dobbs about building custom controls in JavaFX, in particular a ListView control that supports multiple selection. Remember that recently FX Experience also posted an example on how to create a multiple selection ListView.
• Martijn van de Rijdt has written about building a JavaFX project with Maven using javaFX 1.3 and the JFrog JavaFX Compiler Maven Plugin.
• itssmee has blogged about recreating Radioheads ‘House of Cards’ music video in JavaFX (the original video was created in Processing). For those unsure what is being referred to, check out this YouTube video.
• Sergey Malenkov has blogged about multi-threading in JavaFX, by recreating Reversi.
• Abhilshit Soni has posted ‘Yet another JavaFX App‘, which includes a runnable demo and source code.

That’s that for another week. I hope you all found something useful in the links today, and thanks to everyone for emailing their links to me. Catch you all in a weeks time

A very quiet week this week in terms of link quantity, but with new JavaFX and NetBeans releases it is made up for with some very important links to take note of this week. As always thanks to the people who take the time to email me their links.

• JavaFX 1.3.1 was released this week. It contains a lot of improvements and bug fixes, and is accompanied by an updated NetBeans release. The main feature of JavaFX 1.3.1 is an improved (and more configurable) startup experience.
• Danny Coward presented at Jazoon in June with an interesting talk titled ‘Java SE and JavaFX: The Road Ahead‘. It’s a good and informative talk, so if you’ve got an hour to spare the video is well worth watching.
• David Kaspar has written an article over at the NetBeans knowledge base about using NetBeans JavaFX Composer fragments to make building user interfaces easier (by spanning them over multiple files).
• I posted two screencasts for two controls I built in my spare time: TitledPane and Accordion.

That’s that for another week. Catch you all in a weeks time, and keep up the hard work folks

Howdy folks – not a huge number of links this week, but still there is a bit of good reading to be had. I hope you enjoy them

• Srikanth Shenoy has released FxObjects 0.1. FxObjects is a open source Enterprise JavaFX Application Development framework. The whole intention of the framework is to make Enterprise JavaFX application development easy, elegant and fast. There is a quick summary, and also a 50-page user guide PDF.
• Stuart Marks has blogged about ‘Missing Listeners and Local Overrides‘ in the JavaFX UI controls.
• Speaking of control listeners, Pedro Duque Vieira has blogged his event handling proposal.
• Patrick Champion has blogged about a RESTful client in JavaFX.
• One of the new features in the JavaFX Plugin for Eclipse is support for ‘Organize Imports‘.
• Mark Anro Silva posted his JavaFX animation demo.
• I posted two screencasts related to my personal SplitView project. At this point it’s a very early proof of concept only.

That’s all for this week – I told you it was a quick post. Catch you in a weeks time.

Another week, another bunch of good links right across the JavaFX ecosystem. Let’s dive right into the links of the week!

• I posted an example of how to create a ListView in JavaFX that supports multiple selection.
• dooApp posted an introduction to their FXForm project. FXForm is a library providing automatic form generation for JavaFX objects.
• Carl Dea has published a JavaFX Tabbed Pane and Tab Panel prototype.
• Sébastien Stormacq has posted about creating an animated chart in JavaFX.
• Srikanth Shenoy continues with the third part of his series titled ‘Effective JavaFX Architecture’. This week his post looks at ‘Asynchronous calls, Command Pattern and Testability‘.
• As part of his series of posts, Srikanth has also been creating a JavaFX project called fxobjects. From the website, “FxObjects is a JavaFX Application Framework that enables methodical, pattern based and test friendly way of developing JavaFX applications based on ideas and best practices distilled from real life usage”.
• Due to the amount of echoing going on about JavaFX and it’s future, most of which consist of references to each other (with very little further information), I’ve picked out Max Katz’s post this week as the only one I’m including. His post discusses what he believes the future of JavaFX looks like, both the good and the bad points.

So, in general, a week of impressive links, with some new releases, and interesting discussions and demonstrations. Keep it up folks, and I’ll catch you all again in a weeks time.

One of the things that would be really nice to have in the virtualised ListView and TreeView JavaFX controls, not to mention future controls like TableView, is multiple selection. Certain kinds of apps just can not exist without multiple selection in fact.

So, unsurprisingly, today I got an email from a user of JavaFX, who claims to be a fan of FX Experience (hi Keith!), who was needing multiple selection for his work. I didn’t actually think it could be done very easily (and one of my main jobs is working on these controls, so I should know), but I spent a bit of time looking into it, and it turns out that it’s actually quite possible, with a number of warnings and rough edges, and also the use of a little bit of unpublished API. As long as you’re promising to not tell anyone, I thought I’d share this code….but just with you, so shhh

What I present to you today therefore is to be considered proof of concept only. Using this in your day job is considered risky, as some of the code may not work in future releases. Being a proof of concept, the code below is not fully implemented (which I’ll detail more shortly), and performance may degrade somewhat as the number of selected items increases. No attempt at performance optimisation has been made. Proceed at your own risk I hope that I’ve sufficiently scared you.

I wanted to briefly show the code, and then just provide you with a jar file to download and use in your own projects. Firstly though, here’s a screenshot I sent to Keith to detail what he should expect to see when he runs the new control:

Do not adjust your TV sets (for those of you, ah, accessing the net via your TV?). The ListView on the right looks odd because the label is rotated inside the cell, to make it apparent that you can get multiple selection even when using a custom cell factory. To get the multiple rows selected I just held down ctrl or shift as I left-clicked, as is usually the case in list controls in other UI toolkits. Here’s the code I wrote to create the app in the screenshot above:

Stage {
    title: "Multiple Selection Demo"
    scene: Scene {
        width: 340
        height: 260
        content: [
            HBox {
                spacing: 10
                content: [
                    MultiSelectListView {
                        items: [1..100]
                    },

                    MultiSelectListView {
                        items: [1..100]
                        cellFactory: function() {
                            def cell:ListCell = MultiSelectListCell {
                                node: Label {
                                    rotate: 180
                                    text: bind if (cell.item == null)
                                        then "" else "{cell.item}";
                                }
                            }
                        }
                    }
                ]
            }
        ]
    }
}

Pretty much the kind of code you’d expect to see when creating a ListView, except the control is called MultiSelectListView, and the ListCell used in the second list is called MultiSelectListCell.

The code for MultiSelectListView is shown below. There is nothing special in here, it simply extends ListView, and adds a bit more API for selectedIndexes and selectedItems, as well as a default cell factory if one isn’t specified by the user.

import javafx.scene.control.ListView;
import javafx.scene.control.ListCell;
import javafx.scene.Node;
import javafx.scene.control.Label;

public class MultiSelectListView extends ListView {

    public-read var selectedItems:Object[];

    public var selectedIndexes:Integer[] on replace {
        selectedItems = for (i in selectedIndexes) items[i];
    }

    override var cellFactory = function():ListCell {
        var label:Label;
        def cell:ListCell = MultiSelectListCell {
            onUpdate: function() {
                def item = cell.item;
                if (item == null) {
                    cell.node = null;
                } else if (item instanceof Node) {
                    cell.node = item as Node;
                } else {
                    if (label == null) {
                        label = Label { }
                    }
                    label.text = if (item instanceof String) then item as String else "{item}";
                    if (cell.node != label) cell.node = label;
                }
            }
        }
    }
}

Moving on, we come to MultiSelectListCell, which is where the real warning comes – this class has unpublished API being used, and we offer no guarantee that it’ll stay this way. Use it at your own risk, and seriously, don’t build your business around this API being available. You’ve been warned.

This class creates a custom MultiSelectListCellSkin, and binds to the selectedIndexes sequence to determine if it is selected or not. When this property changes, it calls some impl_ code to re-evaluate its state, to allow for the background selection colour to be turned on or off as necessary. The rest of the code is pretty straightforward (i.e. don’t question it)

import javafx.scene.control.ListCell;
import javafx.scene.control.Skin;
import com.sun.javafx.scene.control.skin.ListCellSkin;
import com.sun.javafx.scene.control.skin.SkinAdapter;
import javafx.util.Sequences;

public class MultiSelectListCell extends ListCell {

    def multiSelected = bind Sequences.indexOf((listView as MultiSelectListView).selectedIndexes, index) != -1 on invalidate {
        impl_pseudoClassStateChanged("selected");
    }

    package override function createDefaultSkin():Skin {
        SkinAdapter {
            rootRegion: MultiSelectListCellSkin { }
        }
    }

    override function impl_getPseudoClassState():String[] {
        [
            if (multiSelected) "selected" else null,
            super.impl_getPseudoClassState()
        ]
    }
}

MultiSelectListCellSkin is hidden inside MultiSelectListCell (for no particular reason), and its job is simply to just extend ListCellSkin, apply a small bug workaround, and apply a custom behavior, which is where the actual multiple selection magic happens.

class MultiSelectListCellSkin extends ListCellSkin {
    override var behavior = MultiSelectListCellBehavior { }

    postinit {
        // This fixes an issue where the mouseReleased function is called twice.
        overlay.onMouseReleased = null;
    }
}

The final class is a slight extension of the ListCellBehavior class, not surprisingly called MultiSelectListCellBehavior. This class handles the mouse click event, including determining if ctrl or shift is held down, and acting appropriately.

import com.sun.javafx.scene.control.behavior.ListCellBehavior;
import javafx.util.Sequences;

public class MultiSelectListCellBehavior extends ListCellBehavior {

    override function mouseReleased(e) {
        // Note that list.select will reset selection
        // for out of bounds indexes. So, need to check
        def listCell = skin.control as MultiSelectListCell;
        def listView = listCell.listView as MultiSelectListView;

        // If the mouse event is not contained within this ListCell, then
        // we don't want to react to it.
        if (listCell.contains(e.x, e.y)) {
            if (listCell.index >= sizeof listView.items) return;

            var row = listCell.index;

            if (e.controlDown) {
                if (Sequences.indexOf(listView.selectedIndexes, row) == -1) {
                    insert row into listView.selectedIndexes;
                } else {
                    delete row from listView.selectedIndexes;
                }
            } else if (e.shiftDown) {
                var start = listView.focusedIndex;
                var end = row;
                var range = if (start < end)
                    then [start..end] else [end..start];

                listView.selectedIndexes = range;
            } else {
                delete listView.selectedIndexes;
                insert row into listView.selectedIndexes;
                listView.focus(row);
            }
        }
    }
}

That’s all there is to it. Note that whilst I wrote this, because it is not a ‘production-quality’ control, I haven’t tested it at all, past a few user tests. I’m sure it’ll have issues. If you report them to me I’ll revise this post to ensure the best control we can have. You should also note that this in no way reflects how we’ll do multiple selection in the future, when it is supported ‘natively’.

Now, on to the warnings I warned you were coming. In general, don’t use the select() function any more – just directly manipulate the selectedIndexes sequence. Also, don’t use the selectedItem / selectedIndex properties any more – just use the selectedItems and selectedIndexes sequences instead. If you think you’re going to forget this, it should be possible to just keep overriding more functions / properties to have everything work as expected, but unless I feel sufficiently nagged, I’ll probably just leave this as a user exercise. Similarly, there is no support for keyboard navigation / multiple selection in this version.

So – that’s it really. You can download a NetBeans project containing this source code, or if you’re just wanting to use the code as-is, I’ve also put up a jar file for you to use directly in your own applications. Feel free to leave comments.

Well, what an interesting week we had in the JavaFX world. It started off with Kirill Grouchnikov posting his thoughts that JavaFX is a train wreck. This created a number of threads around the web discussing this. At the same time Stephen Chin posted his petition to open source JavaFX. So much controversy, so many (sometimes anonymous) comments – what a week! For what it’s worth, I’m just reporting the news here, not endorsing or disagreeing with any of it

• As mentioned, this week Kirill Grouchnikov outlined his thinking that JavaFX is a train wreck. Quite quickly the comments on his blog became incredibly side-tracked, so he turned off comments. Because of the nature of the topic, the discussion spilled over into a number of other blogs, and for the most part was mostly negative.
• Stephen Chin has posted a petition to open source JavaFX. Further discussion is available here and here.
• The next Silicon Valley JavaFX Users Group topic has been announced: it’ll be Stephen Chin and Keith Combs doing a live lab session where they will demonstrate the concepts behind implementing JavaFX Controls. It’s coming up August 11, so a few weeks away yet.
• Jim Weaver has posted a tutorial on the Sun Developer Network titled “Stylin’ with JavaFX“.
• Dean Iverson has posted some comments about his previous blog posts to fix up mistakes and misunderstandings on his part.
• Max Katz has done a bunch of blogs recently, titled ‘Binding to server-side context variable from JavaFX‘, ‘Using Expression Language (EL) in JavaFX to communicate with server‘ and ‘Seam conversations from JavaFX‘.
• Alex Ruiz has announced FEST JavaFX Compiler Maven Plug-in 1.0b2. This release adds new configuration options.
• Sergey Malenkov has posted about ‘localized reaction time‘. It shows how you can localise your application in JavaFX.
• William Antônio Siqueira has created LyricSearchFX, which you can run over at his new blog.
• I posted two brief screencasts to show off a TabView control I’m building in my spare time.

Whew! What a week. Catch you all again in a week.

A good week of JavaFX links this week – some exciting releases, and interesting blog posts exploring / announcing interesting work. Let’s get right into it!

• Richard Bair posted a text alignment trick that is useful when trying to lay out Label text.
• I posted a tip regarding sequence performance, and how you can cut down on needless churn.
• Stephen Chin has announced the release of JFXtras 0.7 release candidate 2.
• Max Katz is presenting at the next Silicon Valley JavaFX Users Group meetup, which is this coming week on Wednesday, July 14, 2010 at 7PM PST.
• Speaking of Max, he has posted two blog posts titled ‘Calling Seam component from JavaFX‘ and ‘Invoking Hibernate Validator from JavaFX‘.
• It looks like IntelliJ IDEA is starting to support JavaFX even more, with the 0.2 release of their JavaFX plugin for IntelliJ. Watch the Getting Started video if you’re interested.
• Nicholas has blogged about displaying a JavaFX applet in a Grails application.
• Srikanth Shenoy has posted the second part of his multi-part series on ‘Effective JavaFX Architecture’, this time covering Test Driven Development with JavaFX.

That’s us for another week. Thanks to everyone for your hard work in the community, and for sharing your knowledge with the rest of us Catch you all again in a weeks time!