Comment émettre et gérer des événements personnalisés?
Il existe plusieurs classes d'événements prédéfinies dans javafx. Event.ANY, KeyEvent.KEY_TYPED, MouseEvent.ANY et ainsi de suite. Il existe également un système avancé de filtrage et de gestion des événements. Et je voudrais le réutiliser pour envoyer des signaux personnalisés.
Comment puis-je créer mon type d'événement personnalisé CustomEvent.Any, émettre cet événement par programme et le gérer dans un nœud?
En général:
- Créez le type d'événement souhaité .
- Créez l'événement correspondant .
- Appelez Node.fireEvent () .
- Ajoutez des gestionnaires et/ou des filtres pour les types d'événement qui vous intéressent.
Quelques explications:
Si vous souhaitez créer une cascade d'événements, commencez par un type "All" ou "Any", qui sera la racine de tous les EventTypes:
EventType<MyEvent> OPTIONS_ALL = new EventType<>("OPTIONS_ALL");
Cela permet de créer des descendants de ce type:
EventType<MyEvent> BEFORE_STORE = new EventType<>(OPTIONS_ALL, "BEFORE_STORE");
Ensuite, écrivez la classe MyEvent (qui étend Event). Les EventTypes doivent être saisis dans cette classe d'événements (comme c'est mon exemple).
Utilisez maintenant (ou en d'autres termes: tirez) l'événement:
Event myEvent = new MyEvent();
Node node = ....;
node.fireEvent(myEvent);
Si vous voulez assister à cet événement:
Node node = ....;
node.addEventHandler(OPTIONS_ALL, event -> handle(...));
node.addEventHandler(BEFORE_STORE, event -> handle(...));
Voici un exemple d'application (légèrement trop compliqué) illustrant certains des concepts que eckig décrit dans sa (excellente) réponse.
L'échantillon crée un champ visuel qui est un volet carrelé de nœuds de réacteur. Un événement de foudre personnalisé est périodiquement envoyé à un nœud aléatoire, qui clignote en jaune lorsqu'il reçoit l'événement. Des filtres et des gestionnaires sont ajoutés au champ parent et leur appel signalé à system.out afin que vous puissiez voir les phases de propagation et de capture d'événements en action.
Le code de LightningEvent lui-même a été principalement copié directement à partir du code ActionEvent standard dans la source JavaFX, votre code d'événement pourrait probablement être un peu plus simple.
import javafx.animation.*;
import javafx.application.Application;
import javafx.event.*;
import javafx.scene.Scene;
import javafx.scene.layout.TilePane;
import javafx.scene.Paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;
import javafx.util.Duration;
import Java.util.Random;
public class LightningSimulator extends Application {
private static final int FIELD_SIZE = 10;
private static final Random random = new Random(42);
@Override
public void start(Stage stage) throws Exception {
TilePane field = generateField();
Scene scene = new Scene(field);
stage.setScene(scene);
stage.setResizable(false);
stage.show();
field.addEventFilter(
LightningEvent.PLASMA_STRIKE,
event -> System.out.println(
"Field filtered strike: " + event.getI() + ", " + event.getJ()
)
);
field.addEventHandler(
LightningEvent.PLASMA_STRIKE,
event -> System.out.println(
"Field handled strike: " + event.getI() + ", " + event.getJ()
)
);
periodicallyStrikeRandomNodes(field);
}
private void periodicallyStrikeRandomNodes(TilePane field) {
Timeline timeline = new Timeline(
new KeyFrame(
Duration.seconds(0),
event -> strikeRandomNode(field)
),
new KeyFrame(
Duration.seconds(2)
)
);
timeline.setCycleCount(Timeline.INDEFINITE);
timeline.play();
}
private void strikeRandomNode(TilePane field) {
LightningReactor struckNode = (LightningReactor)
field.getChildren()
.get(
random.nextInt(
FIELD_SIZE * FIELD_SIZE
)
);
LightningEvent lightningStrike = new LightningEvent(
this,
struckNode
);
struckNode.fireEvent(lightningStrike);
}
private TilePane generateField() {
TilePane field = new TilePane();
field.setPrefColumns(10);
field.setMinWidth(TilePane.USE_PREF_SIZE);
field.setMaxWidth(TilePane.USE_PREF_SIZE);
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
field.getChildren().add(
new LightningReactor(
i, j,
new StrikeEventHandler()
)
);
}
}
return field;
}
private class LightningReactor extends Rectangle {
private static final int SIZE = 20;
private final int i;
private final int j;
private FillTransition fillTransition = new FillTransition(Duration.seconds(4));
public LightningReactor(int i, int j, EventHandler<? super LightningEvent> lightningEventHandler) {
super(SIZE, SIZE);
this.i = i;
this.j = j;
Color baseColor =
(i + j) % 2 == 0
? Color.RED
: Color.WHITE;
setFill(baseColor);
fillTransition.setFromValue(Color.YELLOW);
fillTransition.setToValue(baseColor);
fillTransition.setShape(this);
addEventHandler(
LightningEvent.PLASMA_STRIKE,
lightningEventHandler
);
}
public void strike() {
fillTransition.playFromStart();
}
public int getI() {
return i;
}
public int getJ() {
return j;
}
}
private class StrikeEventHandler implements EventHandler<LightningEvent> {
@Override
public void handle(LightningEvent event) {
LightningReactor reactor = (LightningReactor) event.getTarget();
reactor.strike();
System.out.println("Reactor received strike: " + reactor.getI() + ", " + reactor.getJ());
// event.consume(); if event is consumed the handler for the parent node will not be invoked.
}
}
static class LightningEvent extends Event {
private static final long serialVersionUID = 20121107L;
private int i, j;
public int getI() {
return i;
}
public int getJ() {
return j;
}
/**
* The only valid EventType for the CustomEvent.
*/
public static final EventType<LightningEvent> PLASMA_STRIKE =
new EventType<>(Event.ANY, "PLASMA_STRIKE");
/**
* Creates a new {@code LightningEvent} with an event type of {@code PLASMA_STRIKE}.
* The source and target of the event is set to {@code NULL_SOURCE_TARGET}.
*/
public LightningEvent() {
super(PLASMA_STRIKE);
}
/**
* Construct a new {@code LightningEvent} with the specified event source and target.
* If the source or target is set to {@code null}, it is replaced by the
* {@code NULL_SOURCE_TARGET} value. All LightningEvents have their type set to
* {@code PLASMA_STRIKE}.
*
* @param source the event source which sent the event
* @param target the event target to associate with the event
*/
public LightningEvent(Object source, EventTarget target) {
super(source, target, PLASMA_STRIKE);
this.i = ((LightningReactor) target).getI();
this.j = ((LightningReactor) target).getJ();
}
@Override
public LightningEvent copyFor(Object newSource, EventTarget newTarget) {
return (LightningEvent) super.copyFor(newSource, newTarget);
}
@Override
public EventType<? extends LightningEvent> getEventType() {
return (EventType<? extends LightningEvent>) super.getEventType();
}
}
}