FX Experience Has Gone Read-Only

I've been maintaining FX Experience for a really long time now, and I love hearing from people who enjoy my weekly links roundup. One thing I've noticed recently is that maintaining two sites (FX Experience and JonathanGiles.net) takes more time than ideal, and splits the audience up. Therefore, FX Experience will become read-only for new blog posts, but weekly posts will continue to be published on JonathanGiles.net. If you follow @FXExperience on Twitter, I suggest you also follow @JonathanGiles. This is not the end - just a consolidation of my online presence to make my life a little easier!

tl;dr: Follow me on Twitter and check for the latest news on JonathanGiles.net.

JavaFX links of the week, October 15

by | Oct 14, 2012 | Links

Hi all! Sorry for not posting last week, I was just overloaded with work and was in the US. Now that I am back home in good old New Zealand, let’s get going with the links for the last two weeks! I should quickly note that due to all the travel and distractions I may have missed some posts. Feel free to either leave the links in the comments or else email me and I can include them next week.

Cell spanning in TableView

Cell spanning in TableView

by | Oct 7, 2012 | Controls, JavaOne

Now that JavaOne is over and everyone finally has a chance to exhale, it’s time to start blogging about all the stuff we talked about. For my part, I’m hoping to blog about a bunch of stuff that I covered in my two sessions (primarily TableView cell spanning, RangeSlider, Rating, SegmentedButton and whatever else I can find on my machine). For today, lets talk about adding cell spanning support to TableView. Just a quick pro tip: for those of you who just want a jar and don’t care about how cell spanning was developed, you might want to skip to the end of this post…

So, I need to start this post as per usual – this is not a product of Oracle – there is no support contract or guarantee that this code won’t format your hard drive or do something equally nefarious. Please act responsibly for your personal circumstances. Finally, if you do find something wrong (API, documentation, bug, etc), please email me and lets improve it!

With that out of the way, what exactly is cell spanning (and how does it differ from cell merging)? My understanding (and correct me if I’m wrong) is that cell spanning is when the cell at the ‘spanned index’ takes over the full area of the span, whereas in cell merging you essentially take the content of all cells in the span area and merge them into a single cell taking up the area. In other words, the cell will be the same size regardless of whether spanning or merging is used, and it is simply a question of where does the data come from in either case. My preference is cell spanning over cell merging, so that is what I’ve implemented in this blog post.

To make things even clearer, I guess I should clarify what I mean by the ‘spanned index’. What I mean is that, essentially, we continue to layout our TableView in the same way as we always do (TableRow by TableRow (top to bottom), with each TableRow laying out each TableCell within it (left to right)). As we’re doing this layout, we are basically doing what I show in the code fragment below (although I should note this is pseudocode – things are somewhat more complex internally). The ‘spanned index’ is basically the combination of row/column index as we do the layout. In other words, the value in a spanned cell is the row/column index at the ‘top-left’ of the spanned cell area. This means that all other values that are in row/column indices that are overlapped due to a span will be lost. Here’s the pseudocode:

for (int row = 0; row < maxRows; row++) {
// start laying out a new TableRow.
// We do this by laying out each column in the row.
for (int column = 0; column < maxColumns; column++) {
// laying out each column
}
}

Now we’ve covered a bit of theory, I guess we better cover what exactly the end result is. Here’s a few screenshots below – click on them for the full-sized version.


               
Please excuse the actual data used in the screenshots – I paid precisely zero minutes preparing the demo data – I just used what I had on hand. Clearly what I am doing in the demo data makes no sense for cell spanning – please use your imagination (and ideally send me a better sample data set to use for improved screenshots). 🙂

To support cell spanning support, the first new class is the CellSpanTableView. It simply extends TableView and adds support for a SpanModel. SpanModel is defined as such:

public interface SpanModel {
// cell spanning is only run when isCellSpanEnabled() returns true.
public boolean isCellSpanEnabled();

// Returns the CellSpan for the given row/column index.
public CellSpan getCellSpanAt(int rowIndex, int columnIndex);
}

The CellSpan class is (presently) quite simple, it is a final class with two immutable fields representing the amount of spanning that should occur in the horizontal and vertical directions. I should note that a rowSpan (or columnSpan) of one simply means that there is no spanning of multiple rows / columns – it is just the default layout. Here it is in its full glory:

public final class CellSpan {
private final int rowSpan;
private final int columnSpan;

public CellSpan(int rowSpan, int columnSpan) {
this.rowSpan = rowSpan;
this.columnSpan = columnSpan;
}

public int getRowSpan() {
return rowSpan;
}

public int getColumnSpan() {
return columnSpan;
}
}

Therefore, with this API you should do something like the following when creating your own CellSpanTableView instance:

CellSpanTableView cellSpanTableView = ...;

cellSpanTableView.setSpanModel(new SpanModel() {
private final CellSpan spanTwoRows = new CellSpan(2, 1);

@Override public CellSpan getCellSpanAt(int rowIndex, int columnIndex) {
return rowIndex % 3 == 0 && columnIndex == 1 ? spanTwoRows : null;
}

@Override public boolean isCellSpanEnabled() {
return true;
}
});

Note that all the magic happens in the getCellSpanAt method – for the given row / column indices, you need to tell the SpanModel what the cell span is. If you return null, you are saying there is no spanning required. In the code above, we span two rows whenever the row index is cleanly divisible by three, and we’re looking at the ‘first’ column. This gets you the result shown in the first screenshot above. I have already heard some requests to improve this API – if you have any strong feelings please let me know!

To achieve the new layout, there is a small number of code changes that need to go into the backend of TableView. Because this post is already quite long I won’t bother to talk about that here – if people are interested I will do another post. Needless to say, the code is included in the links below, but it is definitely a proof of concept, not a final implementation!

Another important point to make is that you should definitely join the cell spanning discussion on Jira at RT-24747 – this is where I would appreciate people post feedback on the API. I already know there are a few things to improve (particularly related to what should be passed to the user in the CellSpan.getCellSpanAt(…) method).

Ok, with all that covered, you can download a zip file that contains both the source and a precompiled jar file. Note that these will only work with the JavaFX 8.0 developer preview releases – they use API that is not available in JavaFX 2.2. It is trivial enough to backport though, and if someone does I will happily host the source code and jar file here.

In summary – lets get the discussion around cell spanning started! I look forward to your comments 🙂

JavaFX links of the week, September 30

by | Sep 30, 2012 | Links

Hi all, and welcome to another JavaFX links post. This week we have a special guest editor (because I’m at JavaOne this week). I’ll leave him to introduce himself – enjoy the links folks! 🙂

Hi. I’m Josh Marinacci, former member of the JavaFX team. Jonathan Giles and the rest of the JavaFX crew are insanely busy preparing for JavaOne, so I’ll be your editor for this week’s links. If you are attending JavaOne this year be sure to see some of the stellar JavaFX talks.

Thanks to Josh for the help this week, it was much appreciated.

JavaFX Scenic View 1.2.0 now available for download!

JavaFX Scenic View 1.2.0 now available for download!

by | Sep 25, 2012 | Scenic View

It is with great pride that Ander Ruiz and I announce the release of Scenic View 1.2.0. This release includes a bunch of new features, most notable of which are support for event monitoring, javadoc browsing, contextual menus (to minimise UI clutter), support for copying details to the system clipboard, and a bunch of bug fixes (particularly around tools.jar / attach.dll requirements). As always, the download can be grabbed from here, and you can read the help documentation to learn about all the features.

Enjoy! 🙂

JavaFX links of the week, September 24

by | Sep 23, 2012 | Links

Hi folks – and welcome to yet another JavaFX links of the week. As per usual I’ve got a selection of interesting and informative posts for you to peruse this week, and I hope you all enjoy!

Whilst I’m writing this I realise that, rather obviously, we’re a week out from JavaOne in San Francisco. I will be there, and of course look I’m really looking forward to catching up with plenty of you. However, the flipside of this is that I will be traveling for the next two weeks, and unless someone wants to step up and be the guest editor for the next two weeks (email me for details), things may be a little quiet around here so now I have a guest editor filling in for me. You’ll find out who it is next week! I will try my best to get some posts out covering all the news, but don’t hold me to it! Anywho – on with the links! 🙂

That’s all for this week. Once again, I look forward to catching up with as many of you as possible at JavaOne. Please come up and say hello – it’ll make my day 🙂