JavaFX - Ereignisbehandlung

In JavaFX können wir GUI-Anwendungen, Webanwendungen und grafische Anwendungen entwickeln. Wenn in solchen Anwendungen ein Benutzer mit der Anwendung (Knoten) interagiert, wird ein Ereignis als aufgetreten bezeichnet.

Zum Beispiel sind das Klicken auf eine Schaltfläche, das Bewegen der Maus, das Eingeben eines Zeichens über die Tastatur, das Auswählen eines Elements aus der Liste und das Scrollen der Seite die Aktivitäten, die ein Ereignis auslösen.

Arten von Ereignissen

Die Ereignisse können grob in die folgenden zwei Kategorien eingeteilt werden:

• Foreground Events- Ereignisse, die die direkte Interaktion eines Benutzers erfordern. Sie werden als Konsequenzen einer Person generiert, die mit den grafischen Komponenten in einer grafischen Benutzeroberfläche interagiert. Zum Beispiel durch Klicken auf eine Schaltfläche, Bewegen der Maus, Eingeben eines Zeichens über die Tastatur, Auswählen eines Elements aus der Liste, Scrollen der Seite usw.

• Background Events- Ereignisse, die die Interaktion des Endbenutzers erfordern, werden als Hintergrundereignisse bezeichnet. Die Betriebssystemunterbrechungen, Hardware- oder Softwarefehler, Ablauf des Timers und Abschluss des Vorgangs sind Beispiele für Hintergrundereignisse.

Ereignisse in JavaFX

JavaFX bietet Unterstützung für eine Vielzahl von Ereignissen. Die benannte KlasseEvent des Pakets javafx.event ist die Basisklasse für ein Ereignis.

Eine Instanz einer ihrer Unterklassen ist ein Ereignis. JavaFX bietet eine Vielzahl von Ereignissen. Einige von ihnen sind unten aufgeführt.

• Mouse Event- Dies ist ein Eingabeereignis, das auftritt, wenn eine Maus angeklickt wird. Es wird durch die genannte Klasse dargestelltMouseEvent. Es umfasst Aktionen wie Klicken mit der Maus, Drücken der Maus, Loslassen der Maus, Bewegen der Maus, Eingeben der Maus, Verlassen der Maus usw.

• Key Event- Dies ist ein Eingabeereignis, das den Tastenanschlag an einem Knoten angibt. Es wird durch die genannte Klasse dargestelltKeyEvent. Dieses Ereignis umfasst Aktionen wie Drücken der Taste, Loslassen der Taste und Eingeben der Taste.

• Drag Event- Dies ist ein Eingabeereignis, das auftritt, wenn die Maus gezogen wird. Es wird durch die genannte Klasse dargestelltDragEvent. Es enthält Aktionen wie eingegebenes Ziehen, fallengelassenes Ziehen, eingegebenes Ziel ziehen, verlassenes Ziel ziehen, überziehen usw.

• Window Event- Dies ist ein Ereignis im Zusammenhang mit Fenstern, mit denen Aktionen angezeigt / ausgeblendet werden. Es wird durch die genannte Klasse dargestelltWindowEvent. Es enthält Aktionen wie Fenster ausblenden, Fenster angezeigt, Fenster ausgeblendet, Fenster angezeigt usw.

Handhabung des Events

Die Ereignisbehandlung ist der Mechanismus, der das Ereignis steuert und entscheidet, was passieren soll, wenn ein Ereignis auftritt. Dieser Mechanismus verfügt über den Code, der als Ereignishandler bezeichnet wird und ausgeführt wird, wenn ein Ereignis auftritt.

JavaFX bietet Handler und Filter zur Behandlung von Ereignissen. In JavaFX hat jedes Ereignis -

• Target- Der Knoten, auf dem ein Ereignis aufgetreten ist. Ein Ziel kann ein Fenster, eine Szene und ein Knoten sein.

• Source- Die Quelle, aus der das Ereignis generiert wird, ist die Quelle des Ereignisses. Im obigen Szenario ist die Maus die Quelle des Ereignisses.

• Type- Art des aufgetretenen Ereignisses; Im Falle eines Mausereignisses - Maus gedrückt, Maus losgelassen sind die Art der Ereignisse.

Angenommen, wir haben eine Anwendung, in die Schaltflächen für Kreis, Stopp und Wiedergabe mit einem Gruppenobjekt wie folgt eingefügt wurden:

Wenn Sie auf die Wiedergabetaste klicken, ist die Quelle die Maus, der Zielknoten die Wiedergabetaste und der Typ des generierten Ereignisses ist der Mausklick.

Phasen der Ereignisbehandlung in JavaFX

Jedes Mal, wenn ein Ereignis generiert wird, durchläuft JavaFX die folgenden Phasen.

Streckenbau

Immer wenn ein Ereignis generiert wird, wird die Standard- / Anfangsroute des Ereignisses durch die Erstellung eines Ereignisses bestimmt Event Dispatch chain. Es ist der Weg von der Bühne zum Quellknoten.

Es folgt die Ereignisversandkette für das Ereignis, das generiert wird, wenn wir im obigen Szenario auf die Wiedergabetaste klicken.

Ereigniserfassungsphase

Nach dem Aufbau der Ereignisversandkette löst der Stammknoten der Anwendung das Ereignis aus. Dieses Ereignis wird zu allen Knoten in der Versandkette übertragen (von oben nach unten). Wenn einer dieser Knoten eine hatfilterregistriert für das generierte Ereignis, wird es ausgeführt. Wenn keiner der Knoten in der Versandkette einen Filter für das generierte Ereignis hat, wird dieser an den Zielknoten übergeben und schließlich verarbeitet der Zielknoten das Ereignis.

Ereignisblasenphase

In der Ereignisblasenphase wird das Ereignis vom Zielknoten zum Bühnenknoten (von unten nach oben) übertragen. Wenn einer der Knoten in der Ereignisversandkette eine hathandlerregistriert für das generierte Ereignis, wird es ausgeführt. Wenn keiner dieser Knoten über Handler verfügt, die das Ereignis behandeln, erreicht das Ereignis den Stammknoten und der Vorgang wird abgeschlossen.

Ereignishandler und Filter

Ereignisfilter und -handler sind solche, die Anwendungslogik zum Verarbeiten eines Ereignisses enthalten. Ein Knoten kann sich bei mehr als einem Handler / Filter registrieren. Bei Eltern-Kind-Knoten können Sie den Eltern einen gemeinsamen Filter / Handler bereitstellen, der standardmäßig für alle untergeordneten Knoten verarbeitet wird.

Wie oben erwähnt, ist die Verarbeitung während des Ereignisses ein Filter, der ausgeführt wird, und während der Ereignisblasenphase wird ein Handler ausgeführt. Alle Handler und Filter implementieren die SchnittstelleEventHandler des Pakets javafx.event.

Ereignisfilter hinzufügen und entfernen

Um einem Knoten einen Ereignisfilter hinzuzufügen, müssen Sie diesen Filter mithilfe der Methode registrieren addEventFilter() des Node Klasse.

//Creating the mouse event handler 
EventHandler<MouseEvent> eventHandler = new EventHandler<MouseEvent>() { 
   @Override 
   public void handle(MouseEvent e) { 
      System.out.println("Hello World"); 
      circle.setFill(Color.DARKSLATEBLUE);  
   } 
};   
//Adding event Filter 
Circle.addEventFilter(MouseEvent.MOUSE_CLICKED, eventHandler);

Auf die gleiche Weise können Sie einen Filter mit der Methode removeEventFilter () entfernen, wie unten gezeigt -

circle.removeEventFilter(MouseEvent.MOUSE_CLICKED, eventHandler);

Beispiel für die Ereignisbehandlung

Das folgende Beispiel zeigt die Ereignisbehandlung in JavaFX mithilfe der Ereignisfilter. Speichern Sie diesen Code in einer Datei mit NamenEventFiltersExample.java.

import javafx.application.Application; 
import static javafx.application.Application.launch; 
import javafx.event.EventHandler;
 
import javafx.scene.Group; 
import javafx.scene.Scene; 
import javafx.scene.input.MouseEvent; 
import javafx.scene.paint.Color; 
import javafx.scene.shape.Circle; 

import javafx.scene.text.Font; 
import javafx.scene.text.FontWeight;
import javafx.scene.text.Text; 
import javafx.stage.Stage; 
         
public class EventFiltersExample extends Application { 
   @Override 
   public void start(Stage stage) {      
      //Drawing a Circle 
      Circle circle = new Circle(); 
      
      //Setting the position of the circle 
      circle.setCenterX(300.0f); 
      circle.setCenterY(135.0f); 
      
      //Setting the radius of the circle 
      circle.setRadius(25.0f); 
      
      //Setting the color of the circle 
      circle.setFill(Color.BROWN); 
      
      //Setting the stroke width of the circle 
      circle.setStrokeWidth(20);      
       
      //Setting the text 
      Text text = new Text("Click on the circle to change its color"); 
      
      //Setting the font of the text 
      text.setFont(Font.font(null, FontWeight.BOLD, 15));     
      
      //Setting the color of the text 
      text.setFill(Color.CRIMSON); 
  
      //setting the position of the text 
      text.setX(150); 
      text.setY(50); 
       
      //Creating the mouse event handler 
      EventHandler<MouseEvent> eventHandler = new EventHandler<MouseEvent>() { 
         @Override 
         public void handle(MouseEvent e) { 
            System.out.println("Hello World"); 
            circle.setFill(Color.DARKSLATEBLUE);
         } 
      };  
      //Registering the event filter 
      circle.addEventFilter(MouseEvent.MOUSE_CLICKED, eventHandler);   
       
      //Creating a Group object  
      Group root = new Group(circle, text); 
         
      //Creating a scene object 
      Scene scene = new Scene(root, 600, 300); 
       
      //Setting the fill color to the scene 
      scene.setFill(Color.LAVENDER);  
      
      //Setting title to the Stage 
      stage.setTitle("Event Filters Example");       
         
      //Adding scene to the stage 
      stage.setScene(scene); 
         
      //Displaying the contents of the stage 
      stage.show(); 
   } 
   public static void main(String args[]){ 
      launch(args); 
   } 
}

Kompilieren Sie die gespeicherte Java-Datei und führen Sie sie mit den folgenden Befehlen an der Eingabeaufforderung aus.

javac EventFiltersExample.java 
java EventFiltersExample

Bei der Ausführung generiert das obige Programm ein JavaFX-Fenster wie unten gezeigt.

Hinzufügen und Entfernen von Ereignishandlern

Um einem Knoten einen Ereignishandler hinzuzufügen, müssen Sie diesen Handler mithilfe der Methode registrieren addEventHandler() des Node Klasse wie unten gezeigt.

//Creating the mouse event handler 
EventHandler<javafx.scene.input.MouseEvent> eventHandler = 
   new EventHandler<javafx.scene.input.MouseEvent>() { 
   
   @Override 
   public void handle(javafx.scene.input.MouseEvent e) { 
      System.out.println("Hello World"); 
      circle.setFill(Color.DARKSLATEBLUE);             
   } 
};    
//Adding the event handler 
circle.addEventHandler(javafx.scene.input.MouseEvent.MOUSE_CLICKED, eventHandler);

Auf die gleiche Weise können Sie einen Ereignishandler mit der Methode removeEventHandler () entfernen, wie unten gezeigt -

circle.removeEventHandler(MouseEvent.MOUSE_CLICKED, eventHandler);

Beispiel

Das folgende Programm ist ein Beispiel für die Ereignisbehandlung in JavaFX mithilfe der Ereignishandler.

Speichern Sie diesen Code in einer Datei mit Namen EventHandlersExample.java.

import javafx.animation.RotateTransition; 
import javafx.application.Application; 
import javafx.event.EventHandler; 

import javafx.scene.Group; 
import javafx.scene.PerspectiveCamera; 
import javafx.scene.Scene; 
import javafx.scene.control.TextField; 
import javafx.scene.input.KeyEvent; 
import javafx.scene.paint.Color; 
import javafx.scene.paint.PhongMaterial;
 
import javafx.scene.shape.Box; 
import javafx.scene.text.Font; 
import javafx.scene.text.FontWeight; 
import javafx.scene.text.Text;  
import javafx.scene.transform.Rotate; 
import javafx.stage.Stage; 
import javafx.util.Duration; 
         
public class EventHandlersExample extends Application { 
   
   @Override 
   public void start(Stage stage) {
      //Drawing a Box 
      Box box = new Box(); 
      
      //Setting the properties of the Box 
      box.setWidth(150.0); 
      box.setHeight(150.0);   
      box.setDepth(100.0); 
       
      //Setting the position of the box 
      box.setTranslateX(350);  
      box.setTranslateY(150); 
      box.setTranslateZ(50); 
       
      //Setting the text 
      Text text = new Text("Type any letter to rotate the box, 
         and click on the box to stop the rotation"); 
      
      //Setting the font of the text 
      text.setFont(Font.font(null, FontWeight.BOLD, 15));     
      
      //Setting the color of the text 
      text.setFill(Color.CRIMSON); 
      
      //setting the position of the text 
      text.setX(20); 
      text.setY(50); 
       
      //Setting the material of the box 
      PhongMaterial material = new PhongMaterial();  
      material.setDiffuseColor(Color.DARKSLATEBLUE);  
      
      //Setting the diffuse color material to box 
      box.setMaterial(material);       
       
      //Setting the rotation animation to the box    
      RotateTransition rotateTransition = new RotateTransition(); 
      
      //Setting the duration for the transition 
      rotateTransition.setDuration(Duration.millis(1000)); 
      
      //Setting the node for the transition 
      rotateTransition.setNode(box);       
      
      //Setting the axis of the rotation 
      rotateTransition.setAxis(Rotate.Y_AXIS); 
      
      //Setting the angle of the rotation
      rotateTransition.setByAngle(360); 
      
      //Setting the cycle count for the transition 
      rotateTransition.setCycleCount(50); 
      
      //Setting auto reverse value to false 
      rotateTransition.setAutoReverse(false);  
      
      //Creating a text filed 
      TextField textField = new TextField();   
      
      //Setting the position of the text field 
      textField.setLayoutX(50); 
      textField.setLayoutY(100); 
       
      //Handling the key typed event 
      EventHandler<KeyEvent> eventHandlerTextField = new EventHandler<KeyEvent>() { 
         @Override 
         public void handle(KeyEvent event) { 
            //Playing the animation 
            rotateTransition.play(); 
         }           
      };              
      //Adding an event handler to the text feld 
      textField.addEventHandler(KeyEvent.KEY_TYPED, eventHandlerTextField); 
       
      //Handling the mouse clicked event(on box) 
      EventHandler<javafx.scene.input.MouseEvent> eventHandlerBox = 
         new EventHandler<javafx.scene.input.MouseEvent>() { 
         
         @Override 
         public void handle(javafx.scene.input.MouseEvent e) { 
            rotateTransition.stop();  
         } 
      }; 
      //Adding the event handler to the box  
      box.addEventHandler(javafx.scene.input.MouseEvent.MOUSE_CLICKED, eventHandlerBox);
       
      //Creating a Group object
      Group root = new Group(box, textField, text); 
         
      //Creating a scene object 
      Scene scene = new Scene(root, 600, 300);      
      
      //Setting camera 
      PerspectiveCamera camera = new PerspectiveCamera(false); 
      camera.setTranslateX(0); 
      camera.setTranslateY(0); 
      camera.setTranslateZ(0); 
      scene.setCamera(camera);  
      
      //Setting title to the Stage 
      stage.setTitle("Event Handlers Example"); 
         
      //Adding scene to the stage 
      stage.setScene(scene); 
         
      //Displaying the contents of the stage 
      stage.show(); 
   } 
   public static void main(String args[]){ 
      launch(args); 
   } 
}

Kompilieren Sie die gespeicherte Java-Datei und führen Sie sie mit den folgenden Befehlen an der Eingabeaufforderung aus.

javac EventHandlersExample.java 
java EventHandlersExample

Bei der Ausführung generiert das obige Programm ein JavaFX-Fenster, in dem ein Textfeld und ein 3D-Feld angezeigt werden (siehe unten).

Wenn Sie hier einen Buchstaben in das Textfeld eingeben, beginnt sich das 3D-Feld entlang der x-Achse zu drehen. Wenn Sie erneut auf das Feld klicken, stoppt die Drehung.

Verwenden von praktischen Methoden zur Ereignisbehandlung

Einige der Klassen in JavaFX definieren Eigenschaften der Ereignisbehandlungsroutine. Durch Festlegen der Werte für diese Eigenschaften mithilfe der jeweiligen Setter-Methoden können Sie sich bei einem Ereignishandler registrieren. Diese Methoden werden als Convenience-Methoden bezeichnet.

Die meisten dieser Methoden sind in Klassen wie Knoten, Szene, Fenster usw. vorhanden und stehen allen Unterklassen zur Verfügung.

Um beispielsweise einer Schaltfläche einen Mausereignis-Listener hinzuzufügen, können Sie die Convenience-Methode verwenden setOnMouseClicked() Wie nachfolgend dargestellt.

playButton.setOnMouseClicked((new EventHandler<MouseEvent>() { 
   public void handle(MouseEvent event) { 
      System.out.println("Hello World"); 
      pathTransition.play(); 
   } 
}));

Beispiel

Das folgende Programm ist ein Beispiel, das die Ereignisbehandlung in JavaFX mithilfe der praktischen Methoden demonstriert.

Speichern Sie diesen Code in einer Datei mit dem Namen ConvinienceMethodsExample.java.

import javafx.animation.PathTransition; 
import javafx.application.Application; 
import static javafx.application.Application.launch; 
import javafx.event.EventHandler; 

import javafx.scene.Group; 
import javafx.scene.Scene; 
import javafx.scene.control.Button; 
import javafx.scene.input.MouseEvent; 
import javafx.scene.paint.Color; 

import javafx.scene.shape.Circle; 
import javafx.scene.shape.LineTo; 
import javafx.scene.shape.MoveTo; 
import javafx.scene.shape.Path; 
import javafx.stage.Stage; 
import javafx.util.Duration; 
         
public class ConvinienceMethodsExample extends Application { 
   @Override 
   public void start(Stage stage) {      
      //Drawing a Circle 
      Circle circle = new Circle(); 
      
      //Setting the position of the circle 
      circle.setCenterX(300.0f); 
      circle.setCenterY(135.0f); 
      
      //Setting the radius of the circle 
      circle.setRadius(25.0f);  
      
      //Setting the color of the circle 
      circle.setFill(Color.BROWN); 
      
      //Setting the stroke width of the circle 
      circle.setStrokeWidth(20);      
       
      //Creating a Path 
      Path path = new Path(); 
      
      //Moving to the staring point 
      MoveTo moveTo = new MoveTo(208, 71);               
      
      //Creating 1st line 
      LineTo line1 = new LineTo(421, 161);        
      
      //Creating 2nd line 
      LineTo line2 = new LineTo(226,232); 
      
      //Creating 3rd line 
      LineTo line3 = new LineTo(332,52);        
      
      //Creating 4th line 
      LineTo line4 = new LineTo(369, 250);        
      
      //Creating 5th line 
      LineTo line5 = new LineTo(208, 71);       
      
      //Adding all the elements to the path 
      path.getElements().add(moveTo); 
      path.getElements().addAll(line1, line2, line3, line4, line5);     
      
      //Creating the path transition 
      PathTransition pathTransition = new PathTransition(); 
      
      //Setting the duration of the transition 
      pathTransition.setDuration(Duration.millis(1000));       
      
      //Setting the node for the transition 
      pathTransition.setNode(circle); 
      
      //Setting the path for the transition 
      pathTransition.setPath(path); 
      
      //Setting the orientation of the path 
      pathTransition.setOrientation(
         PathTransition.OrientationType.ORTHOGONAL_TO_TAN GENT);
      
      //Setting the cycle count for the transition 
      pathTransition.setCycleCount(50); 
      
      //Setting auto reverse value to true 
      pathTransition.setAutoReverse(false);
      
      //Creating play button 
      Button playButton = new Button("Play"); 
      playButton.setLayoutX(300); 
      playButton.setLayoutY(250); 
       
      circle.setOnMouseClicked (new EventHandler<javafx.scene.input.MouseEvent>() { 
         @Override 
         public void handle(javafx.scene.input.MouseEvent e) { 
            System.out.println("Hello World"); 
            circle.setFill(Color.DARKSLATEBLUE);             
         } 
      });   
      playButton.setOnMouseClicked((new EventHandler<MouseEvent>() { 
         public void handle(MouseEvent event) { 
            System.out.println("Hello World");  
            pathTransition.play(); 
         } 
      })); 
       
      //Creating stop button 
      Button stopButton = new Button("stop"); 
      stopButton.setLayoutX(250); 
      stopButton.setLayoutY(250); 
      
      stopButton.setOnMouseClicked((new EventHandler<MouseEvent>() { 
         public void handle(MouseEvent event) { 
            System.out.println("Hello World"); 
            pathTransition.stop(); 
         } 
      }));
      //Creating a Group object  
      Group root = new Group(circle, playButton, stopButton); 
         
      //Creating a scene object 
      Scene scene = new Scene(root, 600, 300); 
      scene.setFill(Color.LAVENDER);  
      
      //Setting title to the Stage 
      stage.setTitle("Convenience Methods Example");  
         
      //Adding scene to the stage 
      stage.setScene(scene); 
         
      //Displaying the contents of the stage 
      stage.show(); 
   } 
   public static void main(String args[]){ 
      launch(args); 
   } 
}

Kompilieren Sie die gespeicherte Java-Datei und führen Sie sie mit den folgenden Befehlen an der Eingabeaufforderung aus.

javac ConvinienceMethodsExample.java 
java ConvinienceMethodsExample

Bei der Ausführung generiert das obige Programm ein JavaFX-Fenster wie unten gezeigt. Klicken Sie hier auf die Wiedergabetaste, um die Animation zu starten, und klicken Sie auf die Stopptaste, um die Animation zu stoppen.