A minor update of GMapsFX has been released this week which provides a bugfix for an issue that was preventing the GMapsFX GoogleMapView component from being loaded into Scene Builder under certain circumstances.
The release number is 2.0.4 and is currently available from BinTray, and hopefully should be available via Maven Central in the next couple of days.
twitter: @RobTerpilowski
LinkedIn: RobTerpilowski
I have just released version 2.0.3 which includes support for the following major new features:
Directions API
Elevation API
Geocoding API
http://rterp.github.io/GMapsFX/
Below is an example of a JavaFX application displaying a Google map with directions, utilizing the Directions API.
This release has been uploaded to bintray, and should hopefully be available on maven central by next week.
Blog posts to follow this one with tutorials on how to use each one of these new APIs.
https://bintray.com/artifact/download/rterp/maven/com/lynden/GMapsFX/2.0.3/GMapsFX-2.0.3.jar
twitter: @RobTerpilowski
LinkedIn: RobTerpilowski
In November 2015 Dirk Lemmermann (Freelancer) and Alexander Casall of Saxonia Systems had a JavaOne session about JavaFX Real World Applications. The article 20 JavaFX real-world applications summarizes the presentation by showing the applications that they’ve talked about. In addition to providing example applications for the article, I was interviewed by Alexander to get my thoughts on JavaFX and desktop development in general. The interview appears below.
The animated transitions and effects such as blurring or drop shadows make a huge difference in the user experience of the application when implemented properly. These are small details that sometimes get glossed over, but when introduced to an application can create a very polished UI. The effects and transitions were something that were possible to do with Swing, but it was so painful. I don’t remember how many times I had to override the paintComponent() method to customize the look of a particular component, but all of this is baked into the JavaFX framework, allowing you to do these things in literally a few lines of code.
Overall I am pleased with JavaFX as a successor to Swing. The addition of property bindings, which eliminate the need for event listeners in many circumstances helps cut down on some of the code complexity. I also like the fact that there is a very clear seperation between the model, view, and controller, where the view is FXML, the model can be a collection of JavaFX properties, and the controller utilizes dependency injection to have the UI components passed in. There are some nice tools for doing JavaFX development, including NetBeans for coding, SceneBuilder as a WYSIWYG design tool and ScenicView to help visual provide information about the application while it is running.
For a new application I would not consider Swing or SWT, which leaves either JavaFX or HTML5 as the remaining options. In this case there is not a clear winner, but a set of tradeoffs one needs to consider when making a decision. With HTML5 you have the advantage of being able to deploy your application across many different platforms (phones, tablets, and Desktops), as well as multiple OSs (Windows, Mac, Linux). There is also the benefit of a huge development community and large selection of open source tools and frameworks. The ease of deployment across platforms comes at a cost however, in that you must operate within the constraints that are placed on you by the browser. The amount of time debugging issues across different browsers or OSs is often overlooked or underestimated by teams when deciding whether or not to go the desktop or web app route. We recently worked on a project where a very large chunk of time had been consumed in order to get a piece of functionality working correctly in IE 9 on Windows.With JavaFX the drawback is that the user has to download and install something to their desktop, which is becoming very old fashioned. But if this is not an issue, then you are free to develop outside the constraints of the browser and use the full power of the Java language and the eco system that backs it.For applications that are used internally within the company I feel that it makes a lot of sense to deploy these at desktop applications for this reason. Deployments are not an issue in this case as we can automatically push out new installations or updates to PCs in our network automatically. We also bundle a private JRE with the application so we don’t need to worry about which version(s) of Java the user has installed on their PC.
Jonathan Giles and his team have been doing great work at Oracle adding improving and enhancing the JavaFX libraries. That being said, it would be nice if Oracle officially stated what their long term plans are with JavaFX. When Oracle let go of some of their evangelists (who were big proponents of JavaFX), just before JavaOne it started a rumor mill of what may have been behind the move. The uncertainty this has created, and lack of official communication from Oracle will likely deter some development teams who may be on the fence about whether they should port legacy Swing application to JavaFX or HTML5. Over time this will potentially affect how large the JavaFX community eventually becomes.
The amount of 3rd party component libraries (both open source and commercial) that are available for JavaFX is still somewhat limited at this point, but that should change as the JavaFX community continues to grow.
twitter: @RobTerpilowski
LinkedIn: Rob Terpilowski
This a minor release of the JavaFxPropertyHelper NetBeans plugin, and will now follow JavaFX best practices by marking any get/set methods as final.
This plugin would create the following methods:
public final String getName() {
return name.get();
}
public final void setName( String value ) {
name.set(value);
}
public final StringProperty nameProperty() {
return name;
}
This NetBeans plugin will help to generate get/set methods for JavaFx properties that are contained within a POJO.
The standard get/set code generator creates the following get/set methods for a JavaFx property which is not ideal:
private StringProperty name;
public StringProperty getName() {
return name;
}
public void setName( StringProperty name ) {
this.name = name;
}
This plugin would create the following methods:
public String getName() {
return name.get();
}
public void setName( String value ) {
name.set(value);
}
public StringProperty nameProperty() {
return name;
}
It’s also possible to use variables with the suffix Property in their names which will create the following methods:
private StringProperty nameProperty;
public String getName() {
return nameProperty.get();
}
public void setName( String value ) {
nameProperty.set(value);
}
public StringProperty nameProperty() {
return nameProperty;
}
Press Alt-Insert to get the “Generate” popup menu, and select “Java FX Getter and Setter…”
Methods for supported property types will automatically be generated.
The plugin is current available on GitHub at:
https://github.com/rterp/JavaFxPropertyHelperNBPlugin/releases/tag/1.1.1
and will hopefully be available via the general NetBeans Plugin portal by next week.
I am super proud of my team who this week, rolled out Version 2.0 of Lynden Navigator to more than 1,000 desktops company-wide. Navigator allows our freight terminal managers to optimize resource planning by giving them complete visibility to freight that is scheduled to arrive and depart to/from their facility. In addition, customer service personnel have access to a new Shipment Tracing plugin included in this version which can be used to quickly access current information about customer freight and freight history.
The initial version of the application was built on the NetBeans Rich Client Platform (RCP), utilizing Swing UI components, but version 2.0 includes new functionality implemented with JavaFX. A screenshot of the new version of Navigator appears below. The top portion of the application is original portion that is utilizing Swing, and specifically components developed by JideSoft. The lower portion of the screen is new functionality that has been built utilizing JavaFX.
Enter a caption
If you are building an application with JavaFx there are a few tools that will make your life a whole lot easier and save you a lot of time.
The WYSIWYG drag-n-drop design tool for JavaFx will build an FXML representation of the UI which can then be loaded by a JavaFx application. Scene Builder helps to enforce the MVC pattern, keeping business logic out of the code that describes the UI. (More on this below).
Scene builder also has a nice “CSS Analyzer” feature which will show you the full CSS path to a component that is selected in the tool. This has come in handy when attempting to figure out what the CSS path for a component is when attempting to determine where to apply a CSS style . I wish I had known about this when I first began using JavaFx, as it was previously a trial-and-error process for me to get a component styled correctly.
Gluon, Inc. has taken over the build and release of the Scene Builder installer packages which can be obtained at the following link: http://gluonhq.com/open-source/scene-builder/
Of course you will need a good IDE for developing the remaining, and NetBeans provides a number of features which helps out with developing with JavaFX.
The first is the autocomplete feature when working with the FXML files that are generated by Scene Builder. The IDE will generate a list of possible values when inserting or modifying nodes.
There is also support when working with the JavaFX CSS files that will be loaded by the application. In the example below, NetBeans generates a list of possible colors for the -fx-background-color property.
Finally, there is a code generator plugin which will generate getter and setter methods for JavaFX properties in a POJO class. The normal Getter/Setter functionality would return a StringProperty object for the name variable (below), when ideally I would want the class me to return the actual String that the property represents. A screen shot below shows the “Generate” popup menu item with the “JavaFx Props Getters & Setters”. Once selected, the following screenshot illustrates the code that is generated.
The plugin is available at the link below.
Scenic View is another helpful tool when developing and debugging JavaFX applications. It is a stand alone GUI application which will attach to a JavaFX application, and display all the nodes in the scene graph in a collapsable tree. On the right side of the UI it will display various properties about the selected node. ie min height, max height, location, css styles, etc. In the screenshot below Scenic View is in front on the right side of the screen, and the application being debugged is behind Scenic View on the left side of the screen. The selected button on the app is highlighted yellow, and Scenic View has selected this button in its tree view and is displaying its properties in the table on the right.
Scenic View can be downloaded at the FxExperience website.
Finally, MvvmFX is a framework for implementing the Model-View-ViewModel (MVVM) pattern in JavaFX. This pattern allows you to separate any business logic related to the UI from the UI data and state, meaning that the business logic behind the UI can be unit tested without creating any UI components. Since the view model doesn’t know about the view, it makes it possible to replace the view without requiring modifications to the view model.
An instance of the view model is injected into the view, which is just a JavaFx controller for a component. An example view/controller class is shown below.
twitter: @RobTerpilowski
LinkedIn: Profile
Adding and modifying a List of Strings in a JavaFx ListView is a relatively easy task, although may not be completely intuitive at first glance. In order to have changes to a List automatically reflected in a ListView you will need to make use of the ListProperty class, however setting items in the property is not as easy as calling the add() or addAll() methods. This is because the underlying ObservableList class that the Property is using does not support the add() or addAll() methods. Instead, you will need to first wrap your List in an ObservableList, and then pass that ObservableList to the ListProperty instance.
Below is an small sample application which illustrates this point. There are two ArrayLists which contain Strings of data. One contains the currency codes of some Asian currencies, and the other contains the currency codes of European currencies. The list should initially be loaded with the Asian currencies, and when the user clicks on the Button, the handleButtonAction() method is invoked, which will cause the European currency list to be rendered in the ListView.
First, the FXML layout for the UI.
| <?xml version="1.0" encoding="UTF-8"?> | |
| <?import java.lang.*?> | |
| <?import java.util.*?> | |
| <?import javafx.scene.*?> | |
| <?import javafx.scene.control.*?> | |
| <?import javafx.scene.layout.*?> | |
| <AnchorPane id="AnchorPane" prefHeight="201.0" prefWidth="131.0" xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/8.0.40" fx:controller="com.lynden.testjavafxlistview.AppController"> | |
| <children> | |
| <Button fx:id="button" layoutX="14.0" layoutY="160.0" onAction="#handleButtonAction" prefHeight="26.0" prefWidth="100.0" text="Click Me!" /> | |
| <ListView fx:id="myListView" layoutX="14.0" layoutY="21.0" prefHeight="109.0" prefWidth="100.0" /> | |
| </children> | |
| </AnchorPane> |
Next, the controller class for the application
| package com.lynden.testjavafxlistview; | |
| import java.net.URL; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| import java.util.ResourceBundle; | |
| import javafx.beans.property.ListProperty; | |
| import javafx.beans.property.SimpleListProperty; | |
| import javafx.collections.FXCollections; | |
| import javafx.event.ActionEvent; | |
| import javafx.fxml.FXML; | |
| import javafx.fxml.Initializable; | |
| import javafx.scene.control.Button; | |
| import javafx.scene.control.Label; | |
| import javafx.scene.control.ListView; | |
| public class AppController implements Initializable { | |
| @FXML | |
| private Button button; | |
| @FXML | |
| private Label label; | |
| @FXML | |
| private ListView myListView; | |
| protected List<String> asianCurrencyList = new ArrayList<>(); | |
| protected List<String> europeanCurrencyList = new ArrayList<>(); | |
| protected ListProperty<String> listProperty = new SimpleListProperty<>(); | |
| @FXML | |
| private void handleButtonAction(ActionEvent event) { | |
| listProperty.set(FXCollections.observableArrayList(europeanCurrencyList)); | |
| } | |
| @Override | |
| public void initialize(URL url, ResourceBundle rb) { | |
| asianCurrencyList.add("CNH"); | |
| asianCurrencyList.add("JPY"); | |
| asianCurrencyList.add("HKD"); | |
| asianCurrencyList.add("KRW"); | |
| asianCurrencyList.add("SGD"); | |
| europeanCurrencyList.add("EUR"); | |
| europeanCurrencyList.add("GBP"); | |
| europeanCurrencyList.add("NOK"); | |
| europeanCurrencyList.add("SEK"); | |
| europeanCurrencyList.add("CHF"); | |
| europeanCurrencyList.add("HUF"); | |
| myListView.itemsProperty().bind(listProperty); | |
| //This does not work, you can not directly add to a ListProperty | |
| //listProperty.addAll( asianCurrencyList ); | |
| listProperty.set(FXCollections.observableArrayList(asianCurrencyList)); | |
| } | |
| } |
The two lists are populated within the initialize() method of the controller. As you can see it is not possible simply to call the addAll() method on the ListProperty, as it will result in an “OperationNotSupportedException”. Instead, at line 57, the FXCollections class is used to wrap the ArrayList in an ObservableArrayList instance, which is then passed into the ListProperty.
Finally, in the handleButtonAction() method, the europeanCurrencyList is wrapped in ObservableList, and passed to the ListProperty. Since the ListProperty and the ListView are bound together (at line 53), the ListView is automatically updated with the European currency values.
Below are screenshots of the sample app both before and after the button has been clicked.
Asian currency list before clicking button.
European currency list after clicking button.
twitter: @RobTerpilowski
LinkedIn Profile: Rob Terpilowski
JavaFX comes with a number of animated transitions out of the box which are very easy to integrate into an application without too much effort. There are times though when the existing animations don’t cover a desired transition between UI states. Fortunately, implementing a custom animation is as easy as subclassing the javafx.animation.Transition class and providing an implementation of the interpolate() method. As an example, I had a JavaFX Parent component which I wanted to “grow” to a larger height if a large component was placed inside it. Rather than having the Parent component just jump to its new larger height, I wanted the transition to the new height to be animated over a specified amount of time. I was able to accomplish this effect by creating the ResizeHeightTranslation below.
| import javafx.animation.Transition; | |
| import javafx.scene.layout.Region; | |
| import javafx.util.Duration; | |
| public class ResizeHeightTranslation extends Transition { | |
| protected Region region; | |
| protected double startHeight; | |
| protected double newHeight; | |
| protected double heightDiff; | |
| public ResizeHeightTranslation( Duration duration, Region region, double newHeight ) { | |
| setCycleDuration(duration); | |
| this.region = region; | |
| this.newHeight = newHeight; | |
| this.startHeight = region.getHeight(); | |
| this.heightDiff = newHeight – startHeight; | |
| } | |
| @Override | |
| protected void interpolate(double fraction) { | |
| region.setMinHeight( startHeight + ( heightDiff * fraction ) ); | |
| } | |
| } |
In the constructor the duration of the animation is passed to the parent class, and the amount of space the component will need to grow is calculated.
| public ResizeHeightTranslation( Duration duration, Region region, double newHeight ) { | |
| setCycleDuration(duration); | |
| this.region = region; | |
| this.newHeight = newHeight; | |
| this.startHeight = region.getHeight(); | |
| this.heightDiff = newHeight – startHeight; | |
| } |
All that remains to do in the interpolate() method is to calculate the new height based on how far along the animation is. The interpolate() method will be called by the JavaFX runtime with values starting from 0.0 and going to 1.0 as the animation progresses.
| @Override | |
| protected void interpolate(double fraction) { | |
| region.setMinHeight( startHeight + ( heightDiff * fraction ) ); | |
| } |
In the example below I have a JavaFX Pane (salmon color), and a Button. When the Button is clicked I would like to add a TableView to the Pane. The TableView however is taller than the Pane is so I would like the Pane to increase in height so the table fits completely within the Pane. To give this state transition a polished effect, I would like the resizing of the Pane to be animated and then I would like the TableView to fade into view once the resizing is complete. Below is a screenshot of the UI, containing the Pane and the Button components.
The FXML for the UI is below
| <?xml version="1.0" encoding="UTF-8"?> | |
| <?import java.lang.*?> | |
| <?import java.util.*?> | |
| <?import javafx.scene.*?> | |
| <?import javafx.scene.control.*?> | |
| <?import javafx.scene.layout.*?> | |
| <AnchorPane id="AnchorPane" prefHeight="346.0" prefWidth="498.0" xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/8.0.40" fx:controller="com.lynden.resizetest.FXMLController"> | |
| <children> | |
| <Button fx:id="clickMeButton" layoutX="394.0" layoutY="294.0" onAction="#handleButtonAction" text="Click Me!" /> | |
| <Pane fx:id="contentPane" layoutX="25.0" layoutY="22.0" prefHeight="158.0" prefWidth="243.0" style="-fx-background-color: salmon;" /> | |
| </children> | |
| </AnchorPane> |
In the controller class for the UI I have implemented and ActionListener method for the Button. When the Button is clicked a new TableView is created, along with a new ResizeHeightTranslation animation and a FadeTransition. Both of these animations are set to execute one right after the other by putting them in a SequentialTransition.
| import com.lynden.glitter.animation.ResizeHeightTranslation; | |
| import java.net.URL; | |
| import java.util.ResourceBundle; | |
| import javafx.animation.FadeTransition; | |
| import javafx.animation.SequentialTransition; | |
| import javafx.event.ActionEvent; | |
| import javafx.fxml.FXML; | |
| import javafx.fxml.Initializable; | |
| import javafx.scene.control.Button; | |
| import javafx.scene.control.TableView; | |
| import javafx.scene.layout.Pane; | |
| import javafx.util.Duration; | |
| public class FXMLController implements Initializable { | |
| @FXML | |
| private Button clickMeButton; | |
| @FXML | |
| private Pane contentPane; | |
| @FXML | |
| private void handleButtonAction(ActionEvent event) { | |
| TableView tableView = new TableView(); | |
| tableView.setMaxHeight(250); | |
| tableView.setMinHeight(250); | |
| ResizeHeightTranslation rht = new ResizeHeightTranslation(Duration.millis(1000), contentPane, tableView.getMinHeight() ); | |
| FadeTransition ft = new FadeTransition(Duration.millis(1000), tableView); | |
| ft.setFromValue(0); | |
| ft.setToValue(1); | |
| SequentialTransition pt = new SequentialTransition(rht, ft); | |
| pt.play(); | |
| contentPane.getChildren().add(tableView); | |
| } | |
| @Override | |
| public void initialize(URL url, ResourceBundle rb) { | |
| } | |
| } |
Finally, a short clip illustrating the animated transition in action.
twitter: @RobTerpilowski
This tutorial illustrates the creation of a small application based on the NetBeans Rich Client Platform (RCP), and JavaFx, which will monitor the prices of a few stocks and update the UI in real time as prices are updated. The application will make use of SceneBuilder to create an main UI, and JavaFX property bindings in order to keep the UI up to date as the prices are updated.
First, lets start with the model, a Stock class which will simply consist of a ticker symbol and a name.
public class Stock {
protected String symbol;
protected String name;
public Stock(String symbol, String name) {
this.symbol = symbol;
this.name = name;
}
public String getSymbol() {
return symbol;
}
public String getName() {
return name;
}
}
Next, the listener interface that we will need to implement in order to get updates on the prices. The priceUpdated() method will be invoked whenever a new price arrives for a stock.
public interface StockPriceUpdatedListener {
public void priceUpdated( Stock stock, double price );
}The model will consist of a collection of stocks, each of which will be mapped to a StringProperty. When a new stock is added to the model, a new StringProperty will be created and mapped to the specified stock. The model implements the StockPriceUpdatedListener interface. When a new price is received, the StringProperty for that Stock will be looked up and updated.
Note that in the model below that you need to be on the main JavaFx thread when you update a property! For the purposes of this application the stock prices are arriving from a non-ui thread, so updating the property needs to be wrapped in a Platform.runLater() call which will put the update on to the ui-thread.
import com.mvc.stock.price.Stock;
import com.mvc.stock.price.StockPriceUpdatedListener;
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Map;
import javafx.application.Platform;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
public class StockModel implements StockPriceUpdatedListener {
protected Map<Stock, StringProperty> stocks = new HashMap<>();
DecimalFormat df = new DecimalFormat("$##0.00");
public StringProperty addStock( Stock stock ) {
StringProperty property = stocks.get(stock);
if( property == null ) {
property = new SimpleStringProperty("");
stocks.put(stock, property);
}
return property;
}
@Override
public void priceUpdated(Stock stock, double price) {
//Don't update the properties from a non-JavaFx-UI thread!
Platform.runLater( () -> stocks.get(stock).setValue(df.format(price)));
}
}
Next, the view for this application was designed with SceneBuilder. The layout consists of a GridPane containing information about a few stocks, as well as a subscribe button which will trigger the monitoring of price information.
SceneBuilder generated the following FXML code below, with the UI controller set to:
com.mvc.stock.ui.StockPriceController
Also note that the button has its onAction event defined to call the subscribeButtonClicked() method which will need to be implemented in the StockPriceController class.
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.text.*?>
<?import javafx.geometry.*?>
<?import java.lang.*?>
<?import java.util.*?>
<?import javafx.scene.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>
<AnchorPane id="AnchorPane" prefHeight="197.0" prefWidth="233.0" xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/8" fx:controller="com.mvc.stock.ui.StockPricePanelController">
<children>
<GridPane alignment="CENTER" gridLinesVisible="true" layoutX="14.0" layoutY="14.0">
<columnConstraints>
<ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
<ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
</columnConstraints>
<rowConstraints>
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
<RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
</rowConstraints>
<children>
<Label text="MSFT" GridPane.halignment="RIGHT" GridPane.rowIndex="1">
<padding>
<Insets right="10.0" />
</padding>
</Label>
<Label alignment="CENTER" text="Stock" textAlignment="CENTER" GridPane.halignment="CENTER">
<padding>
<Insets right="10.0" />
</padding>
<font>
<Font name="System Bold" size="13.0" />
</font>
</Label>
<Label text="Last Price" GridPane.columnIndex="1" GridPane.halignment="CENTER">
<font>
<Font name="System Bold" size="13.0" />
</font>
</Label>
<Label text="EBAY" GridPane.halignment="RIGHT" GridPane.rowIndex="3">
<padding>
<Insets right="10.0" />
</padding>
</Label>
<Label text="AMZN" GridPane.halignment="RIGHT" GridPane.rowIndex="2">
<padding>
<Insets right="10.0" />
</padding>
</Label>
<Label fx:id="msftPriceLabel" GridPane.columnIndex="1" GridPane.rowIndex="1">
<padding>
<Insets left="10.0" />
</padding>
</Label>
<Label fx:id="amznPriceLabel" GridPane.columnIndex="1" GridPane.rowIndex="2">
<padding>
<Insets left="10.0" />
</padding>
</Label>
<Label fx:id="ebayPriceLabel" GridPane.columnIndex="1" GridPane.rowIndex="3">
<padding>
<Insets left="10.0" />
</padding>
</Label>
</children>
</GridPane>
<Button fx:id="subscribeButton" layoutX="136.0" layoutY="153.0" mnemonicParsing="false" onAction="#subscribeButtonClicked" text="Subscribe" />
</children>
</AnchorPane>
As mentioned above, the FXML file references StockPricePanelController as the UI’s controller. The controller has 3 labels and a button defined which will be injected into the controller by annotating those fields with the @FXML annotation. When the controller is first initialized it creates a new stock object for each stock and then binds the StringProperty of the StockModel to the StringProperty of its corresponding label.
Also, as previously stated, the controller will need to implement a method called subscribeButtonClicked() which was defined in the FXML above. This method needs to be annotated with the @FXML annotation in order to be invoked when the subscribeButton is clicked. When this action is invoked, the controller will subscribe to price data for the specified stocks.
import com.mvc.stock.price.Stock;
import com.mvc.stock.price.provider.IStockPriceProvider;
import java.net.URL;
import java.util.ResourceBundle;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
/**
* FXML Controller class
*
*/
public class StockPricePanelController implements Initializable {
@FXML
protected Label msftPriceLabel;
@FXML
protected Label amznPriceLabel;
@FXML
protected Label ebayPriceLabel;
@FXML
protected Button subscribeButton;
protected StockModel stockModel;
protected IStockPriceProvider provider;
protected Stock msft = new Stock("MSFT", "Microsoft");
protected Stock amzn = new Stock("AMZN", "Amazon");
protected Stock ebay = new Stock("EBAY", "eBay");
/**
* Initializes the controller class.
*/
@Override
public void initialize(URL url, ResourceBundle rb) {
stockModel = new StockModel();
//bind the string property from the model to the labels.
msftPriceLabel.textProperty().bindBidirectional( stockModel.addStock(msft) );
amznPriceLabel.textProperty().bindBidirectional( stockModel.addStock(amzn) );
ebayPriceLabel.textProperty().bindBidirectional( stockModel.addStock(ebay) );
}
public IStockPriceProvider getProvider() {
return provider;
}
public void setProvider(IStockPriceProvider provider) {
this.provider = provider;
}
@FXML
public void subscribeButtonClicked( ActionEvent event ) {
if( provider != null ) {
provider.subscribeToPriceData(msft, stockModel);
provider.subscribeToPriceData(amzn, stockModel);
provider.subscribeToPriceData(ebay, stockModel);
}
}
}
The final piece is to tie JavaFX UI into the NetBeans module which this component is a part of. In order to do this you will need to have a TopComponent defined for your module like in the example below. Basically a TopComponent is a top level panel that is usually within a TabbedPane in the main UI. The TopComponent class below uses the Lookup API to find an implementation of an IStockPriceProvider interface. Next a JFXPanel is created, which is a Swing JPanel that can hold a JavaFX Scene.
Within the Platform.runLater() method, a new FXMLLoader is created which points to the location of the FXML file from above. Once the loader has loaded the file, we can obtain a reference to the StockPricePanelController, and pass in the instance of the stockPriceProvider that was previously just looked up.
Finally, a new Scene is created, added to the JFXPanel, and the JFXPanel is added to the Center position of the TopComponent.
public final class StockPriceTopComponent extends TopComponent {
public StockPriceTopComponent() {
initComponents();
setName(Bundle.CTL_StockPriceTopComponent());
setToolTipText(Bundle.HINT_StockPriceTopComponent());
putClientProperty(TopComponent.PROP_CLOSING_DISABLED, Boolean.TRUE);
putClientProperty(TopComponent.PROP_DRAGGING_DISABLED, Boolean.TRUE);
putClientProperty(TopComponent.PROP_UNDOCKING_DISABLED, Boolean.TRUE);
IStockPriceProvider stockPriceProvider = Lookup.getDefault().lookup(IStockPriceProvider.class);
if( stockPriceProvider == null ) {
throw new IllegalStateException( "Provider is null");
}
JFXPanel jfxPanel = new JFXPanel();
//This needs to be set to make sure the JavaFx thread doesn't exit if the tab is closed.
Platform.setImplicitExit(false);
// create JavaFX scene
Platform.runLater(() -> {
Parent root;
try {
FXMLLoader loader = new FXMLLoader(getClass().getResource("/com/mvc/stock/ui/StockPricePanel.fxml"));
root = loader.load();
StockPricePanelController controller = loader.getController();
controller.setProvider(stockPriceProvider);
Scene scene = new Scene(root);
jfxPanel.setScene(scene);
} catch (IOException ex) {
Exceptions.printStackTrace(ex);
}
});
add( jfxPanel, BorderLayout.CENTER );
}
The resulting NetBeans application is shown below.
twitter: @RobTerpilowski
twitter: @LimitUpTrading