io.datafx.tutorial

Class SimpleController

java.lang.Object

io.datafx.tutorial.SimpleController

public class SimpleController
extends java.lang.Object

This is the controller class for the view used in this first tutorial. By using the DataFX @FXMLController annotation the class defines its FXML file that contains the layout of the view and defines its UI components. By using the JavaFX @FXML annotation that is part of the basic JavaFX API, components that are defined in the FXML file can be easily injected in the controller. Once the controller is created the init() methods will be called by the Flow Framework. This method is annotated by the @PostConstruct annotation. By doing so the DataFX flow container will call this method once all injectable values of the controller instance are injected. There three different types of values / fields that can be injected:

• UI components that are annotated by @FXML
• DataFX objects. Here DataFX provides several annotations
• Custom implementations. These will be injected by using the @Inject annotation

The method that is annotated by @PostContruct will be called when all injections are finished.

In this first example we will only use @FXML to inject FXML UI components to the controller.

In addition DataFX action handling is introduced in this example. The view contains a button named actionButton. Once this button is clicked, the onAction() method will be executed. To do so DataFX contains two annotation: - The @ActionTrigger annotation annotates a UI component that will trigger an action. Each action in DataFX is defined by a unique id, which is passed as the value of the @ActionTrigger annotation In this example the "myAction" id is used. The id must be unique in view controller. - To handle the action a method of the controller should be annotated with the @ActionMethod annotation. The value of this annotation must be the unique id of the defined action. Therefore @ActionMethod("myAction") is used here. The method will be called in the JavaFX Application Thread

As you will see later there are other types of actions than simply calling a method. These will be shown later in other tutorial. For now the most important point is that a component that is annotated with @ActionTrigger can trigger a method that is annotated with {link @io.datafx.controller.flow.action.ActionMethod} if both annotations define the same unique action id. So once the actionButton in this example is clicked the onAction() method will be called and the text of the label will change.

Note: This example is quite easy and normally you could define the action binding by only one line of Java code in the init() method: actionButton.setOnAction((e) -> onAction()); So why are these annotations used here? As you will see in further tutorials that are more complex than this one it will make sense to use the annotations to provide more readable code.

Constructor Summary

Constructors

Constructor and Description
SimpleController()

Method Summary

Modifier and Type	Method and Description
void	init()
void	onAction()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SimpleController

public SimpleController()

Method Detail

init

@PostConstruct
public void init()

onAction

public void onAction()