Get a reference to a Tab from outside FXML Controller - javafx

Question

I'm playing around with JavaFX for the first time on a personal project.
I want to be able to update the content in a Tab (adding a PieChart), but from outside the FXML controller, can anyone tell me if that's possible? How would I get a reference to the relevant tab, and is there a way to specify the location of the item I am adding?
UPDATE: Added some example code.
Hope this gives a clear idea of what I'm trying to do:
The interface:
interface ChartStrategy {
public void DisplayChart(Info info)
}
Two implementations:
public class BarChartStrategy extends ChartStrategy {
public void DisplayChart(Info info)
{
// Create bar charts on specific tabs in the UI
}
}
public class PieChartStrategy extends ChartStrategy {
public void DisplayChart(Info info)
{
// Create pie charts on specific tabs in the UI
}
}
The context:
public class ChartContext {
private ChartStrategy strategy;
public void setChartStrategy(ChartStrategy strategy) {
this.strategy = strategy;
}
public void drawGraphs(Info info) {
strategy.DisplayChart(info);
}
}
In my Controller, I'm reading in a file the user selects from which the data to generate the charts is parsed, .e.g.
#FXML
private void handleButtonAction(ActionEvent event) {
// Load the file and parse the data
...
ChartContext charts = new ChartContext();
charts.setChartStrategy(new PieChartStrategy());
}
So my original thought was that I could draw the charts from the DisplayChart function in the implementations, but it seems that's not a good idea - can anyone give me some advice here on the best way to get this to work?

Answer 1

I would refactor this a bit.
First, letting the strategy display the chart is a bit inflexible. You are giving the strategy two responsibilities: first to decide how to represent the data visually (choose a chart) and second to actually display it somewhere. That violates the single responsibility principle.
So I would do
interface ChartStrategy {
public Chart generateChart(Info info)
}
and similarly for the implementations, of course. Then the responsibility of the strategy is simply to provide a chart: the context can decide what to do with it.
(You can also consider whether returning a Chart here is too rigid: maybe you just want it to return a Parent, or Node. Then your "chart" could be, e.g., a TableView, for example.)
In the theoretical descriptions of the strategy pattern, at least in my interpretation, the "context" just represents "something that is using the strategy". So your context is likely a view or controller (depending on your choice of MVC variant...). As a trivial example you might have something like
public class ChartTab {
private ChartStrategy chartGenerator ;
public void setChartGenerator(ChartStrategy chartGenerator) {
this.chartGenerator = chartGenerator ;
}
public Tab createChartTab(Info info) {
Tab tab = new Tab();
tab.setContent(chartGenerator.generateChart(info));
return tab ;
}
}
and then in your controller
#FXML
private TabPane tabPane ;
#FXML
private void handleButtonAction(ActionEvent event) {
// Load the file and parse the data
...
ChartTab chartTab = new ChartTab();
chartTab.setChartGenerator(new PieChartStrategy());
tabPane.getTabs().add(chartTab.getTab(info));
}
It's also possible just to consider the controller the context (if for a fixed controller you are just creating one kind of chart, which depends on how you split up the FXML files and their corresponding controllers):
public class MyController {
private ChartStrategy chartGenerator ;
#FXML
private TabPane tabPane ;
public MyController(ChartStrategy chartGenerator) {
this.chartGenerator = chartGenerator ;
}
#FXML
private void handleButtonAction(ActionEvent event) {
// Load the file and parse the data
...
Tab tab = new Tab();
tab.setContent(chartGenerator.generateChart(info));
tabPane.getTabs().add(tab);
}
}
Note this controller doesn't have a no-arg constructor, so you cannot use the fx:controller attribute in the FXML file (i.e. remove that attribute from the FXML file). Instead, you'd do
FXMLLoader loader = new FXMLLoader("/path/to/DataDisplay.fxml");
MyController controller = new MyController(new PieChartStrategy());
loader.setController(controller);
Parent root = loader.load();
Now you have an FXML and controller with the functionality to generate charts and display them in a tab pane (or whatever), but the details of what kind of chart is generated are factored out into a pluggable strategy. You still have the proper MVC (or MVP, etc etc) encapsulation in which the details of the UI are kept private to the view-controller (here it's really a presenter, but who's counting...) pair. In other words the strategy knows nothing about the rest of the view, which is as it should be.