afterburner.fx | The Opinionated Un-Framework For Java FX Applications

Since you're using Java 11 and module system, your resource output directory have to be in the same output directory as the module they belong to.

Judging by the images in your post, you're using gradle and you build your project directly from IDEA.

You need to tell IDE to copy your resources to the same output directory:

As you know, using the Afterburner framework injection works in presenter classes:

You can create a new fxml nodes only once per type:

Afterburner.fx is a dependency-injection framework for JavaFX. The main functionality it provides is the ability to inject objects into the controllers/presenters that are created when you load an FXML file (by instantiating a subclass of FXMLView). The basic process that happens when you instantiate a FXMLView is:

1. A new instance of the corresponding presenter is created
2. The presenter is inspected to find any @Inject-annotated fields
3. For each @Inject-annotated field, if an instance of that type exists in the injector's cache, it is set as the value of that field. Otherwise, a new instance of that type is created and placed in the cache, and set as the value of the field.

The main point to note here is that the presenters themselves are treated differently to their dependencies. If you try (as in your code) to inject one presenter in another, an instance of the presenter class will be created specifically for injection purposes: this will not be the same instance that is created when the FXML file is loaded, and consequently it won't have any @FXML-fields injected. This is why you get a null pointer exception: mainAnchorPane is null in the ``MainScenePresenterthat is injected into theNavigationPresenter`.

One presenter having a reference to another is generally a bad idea anyway: it creates unnecessary coupling between the two presenters. Instead, you should inject a model into both presenters that represents the state you want to share between them. In your case you might have something like

The basic idea here is to use a single data model, which is shared among the components that need to access shared data. Using @Inject in afterburner.fx will provide a convenient way to manage this for you.

For design patterns, the first thing to note is that afterburner.fx (and to a lesser extent, perhaps, the FXML-"controller" mechanism in general) is really based on a MVP pattern (not a MVVM pattern). The FXML file represents the (passive) view; the presenter is of course the presenter, and the model is implemented according to the application requirements.

Typically, the framework you are using is a big part of the decision about which pattern(s) to use, so I think my main recommendation would be to use a MVP pattern here. Using MVP, this looks like the following:

You can create an ObservableList in your model:

I suggest you use the Gluon templates Project MultiView with FXML and Afterburner, or the Glisten-Afterburner one. Either of them will allow you using injection and getting a valid instance of the presenters.

Solution 1. Glisten-Afterburner

Using the Glisten-Afterburner default template, I've added two TextField controls, one to each of the views.

The only thing you need is exposing a method to set the value on the second presenter: