szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[oktatas:programozás:java:java_fx|< Java FX]]

====== JavaFX - Eseménykezelés ======

  * **Szerző:** Sallai András
  * Copyright (c) 2025, Sallai András
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu

===== Bevezetés =====

Ebben a leírásban VSCode JavaFX készítő bővítményét használtuk. A projekt amit kapunk FXML és Java kontroller fájlokkal dolgozik. Az alkalmazás belépési pontja pedig az App.java fájl.


===== Gomb =====

Az eseménykezelés megvalósítható az FXML fájlban meghatározott fx:id alapján is.
Tegyük fel, hogy van egy **button** nevű nyomógombunk. Az initialize() metódusban
a setOnAction() metódussal adhatom meg mit tegyünk kattintásra.

<code xml>
<Button 
    fx:id="button" 
    layoutX="270.0" 
    layoutY="187.0" 
    mnemonicParsing="false" 
    text="Button" />
</code>

A következő példában a setOnAction() számára egy névtelen függvényt adunk meg, ami egyébként egy lambda kifejezés :

<code java MainController.java>
    @FXML
    private Button button;

    @FXML
    void initialize() {
        button.setOnAction(e -> startButton());
    }
    void startButton() {
        System.out.println("start button");
    }
</code>

Használhatunk metódusreferenciát is:

<code java MainController.java>
    @FXML
    private Button button;

    @FXML
    void initialize() {
        button.setOnAction(this::startButton);
    }

    void startButton(ActionEvent event) {
        System.out.println("start button");
    }
</code>

A **this::startButton** a metódusreferencia, amivel megmondjuk melyik metódust kell
végrehajtani kattintásra.

A két megvalósítás valójában ennek a rövidített változata:

<code java>
    @FXML
    private Button button;

    @FXML
    void initialize() {
        button.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                startButton();
            }
        });
    }
    void startButton() {
        System.out.println("start button");
    }

</code>

Az utóbbihoz tartozó teljeskód:
<code java MainController.java>
package com.example;

import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.scene.control.Button;

public class MainController {

    @FXML
    private Button button;

    @FXML
    void initialize() {
        button.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                startButton();
            }
        });
    }
    void startButton() {
        System.out.println("start button");
    }
}
</code>

Külön osztályt is létrehozhatunk ami implementálja a **EventHandler<ActionEvent>** interfészt.
A példánkban egy beépített osztályt használunk. Teljes kód:

<code java MainController.java>
package com.example;

import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.scene.control.Button;

public class MainController {

    @FXML
    private Button button;

    @FXML
    void initialize() {
        button.setOnAction(new ButtonHandler());
    }
    void startButton() {
        System.out.println("start button");
    }
    class ButtonHandler implements EventHandler<ActionEvent> {
        @Override
        public void handle(ActionEvent event) {
            startButton();
        }
    }
}

</code>

==== Eseménykezelő megadása ====

Az FXML fájlban megadhatjuk azt a metódust, amivel kezeljük az eseményt.

<code xml>
<Button 
    layoutX="270.0" 
    layoutY="187.0" 
    mnemonicParsing="false" 
    onAction="#onClickStartButton" 
    text="Button" />
</code>

A Java kód ebben az esetben:

<code java MainController.java>
package com.example;

import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.scene.control.Button;

public class MainController {

    @FXML
    private Button button;

    @FXML
    void onClickStartButton(ActionEvent event) {
        startButton();
    }    

    void startButton() {
        System.out.println("start button");
    }

}

</code>

===== Alkalmazás indítása =====

Az alkalmazás indításakor ha szeretnénk a betöltött kontrollerekkel dolgozni az initialize() 
metódusra van szükségünk a kontrollerben. A metódust jelöljük meg az FXML annotációval.

Egy kontrollerben:

<code java>
    @FXML
    void initialize() {
        System.out.println("start");
    }
</code>

Tötlsük fel például egy listView-t:
<code java>
    @FXML
    void initialize() {
        listView.getItems().addAll(
            "item1", 
            "item2", 
            "item3"
        );
    }
</code>

A kontroller konstruktora nem használható, mivel annak lefutása idején még nem léteznek
UI elemek.

===== Alkalmazás bezárása =====

Ha az alkalmazás bezárására szeretnénk reagálni, akkor az App.java fájlban
írjuk felül a stop() metódust. 

<code java>
    @Override
    public void stop() throws Exception {
        System.out.println("stop");
    }
</code>

==== Lista mentése bezáráskor ====

Tegyük fel, hogy a VSCode JavaFX generáló bővítményét használtuk, ezért kaptunk egy
App.java fájlt, és használunk valamilyen kontrollert, például MainController.
Az alkalmazás tartalmaz egy listView objektumot, aminek az elemeit szeretnénk 
fájlba menteni.

Mivel a bezárás eseménynél szükségünk lesz a kontrollerre, ezért vegyünk fel egy
statikus mainController objektumot, ami a start() metódusban előkészítünk.
Ehhez szükség van az fxmlLoadedr objektumra, ami alapértelmezetten csak
a loadFXML() metódusból érhető el. Ezért a fxmlLoader objektumot globálissá
tesszük az osztályon belül.

Teljes kód:

<code java App.java>
package com.example;

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

import java.io.IOException;
import java.util.List;

/**
 * JavaFX App
 */
public class App extends Application {

    private static Scene scene;

    //A statikus mainController
    private static MainController mainController;

    // globális fxmlLoader:
    private static FXMLLoader fxmlLoader;

    @Override
    public void start(Stage stage) throws IOException {
        scene = new Scene(loadFXML("mainScene"), 640, 480);        
        mainController = fxmlLoader.getController();
        stage.setScene(scene);
        stage.show();
    }

    @Override
    public void stop() throws Exception {
        System.out.println("stop");
        List<String> items = mainController.getListView().getItems();
        Storage.writeContent(items);
    }

    static void setRoot(String fxml) throws IOException {
        scene.setRoot(loadFXML(fxml));
    }

    private static Parent loadFXML(String fxml) throws IOException {
        //Eltávolítottuk a típust:
        fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
        return fxmlLoader.load();
    }

    public static void main(String[] args) {
        launch();
    }

}
</code>

A stop() metódusban így már elérhető a MainController osztály.

Esetünkben a MainControllerben a listView private elérésű, ezért készítünk hozzá
egy gettert:

<code java MainController.java>
//...
    public ListView<String> getListView() {
        return listView;
    }
//...
</code>

A fájlba írás a teljesség kedvéért:

<code java Storage.java>
package com.example;

import java.io.FileWriter;
import java.io.IOException;
import java.util.List;

public class Storage {
  public static void writeContent(List<String> content) {
    try {
      tryWriteContent(content);
    } catch (IOException e) {
      System.err.println(e.getMessage());
    }
  }
  public static void tryWriteContent(List<String> content) throws IOException {
    FileWriter writer = new FileWriter("data.txt");
    for (String line : content) {
      writer.write(line + "\n");
    }
    writer.close();
  }
}
</code>

A megvalósítás megfordítható. Ha a stage objektumot globálissá tesszük az App osztályban,
a kontrollerben elérhetővé válik, így reagálhatunk a Close eseményre.

==== A Close esemény ====

Reagálhatunk a **Close** eseményre is. Egészítsük ki a start() metódust:

<code java>
    @Override
    public void start(Stage stage) throws IOException {
        scene = new Scene(loadFXML("mainScene"), 640, 480);        
        stage.setScene(scene);
        stage.show();

        stage.setOnCloseRequest(e -> {
            System.out.println("close");
        });
    }
</code>

A lambda kifejezés a következőt helyettesíti:

<code java>
        stage.setOnCloseRequest(new EventHandler<WindowEvent>() {
            @Override
            public void handle(WindowEvent event) {
                System.out.println("close");
            }
        });
</code>

Az alkalmazás bezárásának megakadályozása a **consume()** metódus hívásával lehetséges:

<code java>
        stage.setOnCloseRequest(e -> {
            System.out.println("close");
            e.consume();
        });
</code>


Ebben az esetben valószínűleg szeretnék valamilyen más eseményre kilépni az alkalmazásból. Kilépéshez használhatjuk a **javafx.application.Platform** osztályt.

<code java>
import javafx.application.Platform;
//...
Platform.exit();
</code>