Manejo de eventos en JavaFX

Programación > Java > JavaFX > Manejo de eventos en JavaFX

Una interfaz gráfica de usuario (GUI) no sería muy útil si no pudiera responder a las acciones del usuario. Cuando un usuario hace clic en un botón, mueve el ratón, o presiona una tecla, se generan eventos. JavaFX proporciona un sistema robusto para manejar estos eventos y ejecutar código en respuesta.

Entender el manejo de eventos es crucial para hacer que nuestras aplicaciones JavaFX cobren vida.

¿Qué es un Evento en JavaFX?

Un evento es un objeto que representa una acción o suceso que ha ocurrido, generalmente iniciado por el usuario o por el sistema. Cada evento contiene información sobre lo que sucedió, como:

El tipo de evento: ¿Fue un clic de ratón, una pulsación de tecla, un cambio de valor?
La fuente del evento: ¿Qué nodo originó el evento (ej. qué botón se pulsó)?
Información adicional específica del evento: Coordenadas del ratón, la tecla presionada, etc.

Algunas clases de eventos comunes en JavaFX son:

ActionEvent: Generalmente disparado por controles como Button, MenuItem, TextField (al presionar Enter).
MouseEvent: Disparado por acciones del ratón (clics, movimientos, entrada/salida del cursor sobre un nodo).
KeyEvent: Disparado por pulsaciones de teclas del teclado.
WindowEvent: Disparado por acciones relacionadas con la ventana (Stage), como cerrarla, minimizarla, etc.

El Modelo de Delegación de Eventos

JavaFX utiliza el modelo de delegación de eventos, que consta de tres componentes principales:

Fuente del Evento (Event Source): El objeto (normalmente un Node de la UI) donde ocurrió el evento. Por ejemplo, un Button.
Objeto Evento (Event Object): Un objeto que encapsula la información sobre el evento ocurrido. Por ejemplo, un ActionEvent.
Manejador de Eventos (Event Handler / Event Listener): Un objeto (o un método) que está «escuchando» eventos de un tipo particular en una fuente particular. Cuando el evento ocurre, el manejador es notificado y ejecuta su código.

Formas de Registrar Manejadores de Eventos

Hay varias maneras de registrar un manejador para que responda a un evento en JavaFX:

1. Usando Atributos onXXX en FXML

Esta es la forma más común y recomendada cuando se usa FXML. Se especifica el nombre de un método en el controlador que se ejecutará cuando ocurra el evento.

Ejemplo (Button ActionEvent):
En MiVista.fxml:

<Button text="Haz Clic" onAction="#handleButtonClick"/>

En MiVistaController.java:

public class MiVistaController {
    @FXML
    private void handleButtonClick(ActionEvent event) {
        System.out.println("¡Botón pulsado!");
        // Object source = event.getSource(); // Para obtener el botón que originó el evento
    }
}

- El método en el controlador debe ser public o protected, o private si está anotado con @FXML.
- El método puede (opcionalmente) tomar un parámetro del tipo de evento apropiado (ej. ActionEvent).

2. Usando Métodos setOnXXX() Programáticamente

Puedes añadir manejadores de eventos directamente en tu código Java. Esto es útil si necesitas añadir manejadores dinámicamente o si no estás usando FXML para una parte particular de tu UI.

Ejemplo (Button ActionEvent con Expresión Lambda):

Button miBoton = new Button("Púlsame");
miBoton.setOnAction(event -> {
    System.out.println("Botón pulsado (programáticamente)!");
});

Ejemplo (Node MouseEvent):

Label miEtiqueta = new Label("Pasa el ratón por encima");
miEtiqueta.setOnMouseEntered(event -> {
    miEtiqueta.setText("¡Ratón encima!");
});
miEtiqueta.setOnMouseExited(event -> {
    miEtiqueta.setText("Pasa el ratón por encima");
});

Las expresiones lambda (->) son muy concisas para manejadores simples.
También puedes usar clases anónimas o clases que implementen la interfaz EventHandler<T extends Event>.

3. Usando addEventHandler() Programáticamente

Este método es más genérico y permite añadir múltiples manejadores para el mismo tipo de evento en un nodo. También es crucial para entender las fases de captura y burbujeo de eventos (un concepto más avanzado).

Ejemplo (Node KeyEvent):

TextField miCampoTexto = new TextField();
miCampoTexto.addEventHandler(KeyEvent.KEY_PRESSED, event -> {
    System.out.println("Tecla presionada: " + event.getCode());
    if (event.getCode() == KeyCode.ENTER) {
        System.out.println("Enter presionado en el TextField!");
    }
});

Tipos Comunes de Eventos y Cómo Manejarlos

ActionEvent

Disparado por: Button, MenuItem, CheckBox, RadioButton, TextField (al presionar Enter), ComboBox.
Indica: Una acción de alto nivel del componente.
Manejo Típico:

@FXML
private void miAccion(ActionEvent event) {
    // Realizar la acción principal del componente
}

MouseEvent

Disparado por: Cualquier Node cuando el ratón interactúa con él.
Tipos comunes:

MOUSE_CLICKED: Clic del ratón (presionar y soltar).
MOUSE_PRESSED: Botón del ratón presionado.
MOUSE_RELEASED: Botón del ratón soltado.
MOUSE_MOVED: Ratón movido sobre el nodo (sin botones presionados).
MOUSE_DRAGGED: Ratón movido sobre el nodo (con un botón presionado).
MOUSE_ENTERED: Cursor del ratón entra en los límites del nodo.
MOUSE_EXITED: Cursor del ratón sale de los límites del nodo.

Propiedades del MouseEvent: getX(), getY() (coordenadas relativas al nodo), getSceneX(), getSceneY() (relativas a la escena), getButton() (qué botón se usó), getClickCount().
Manejo Típico:

@FXML
private void handleMouseClickEnImagen(MouseEvent event) {
    if (event.getButton() == MouseButton.PRIMARY && event.getClickCount() == 2) {
        System.out.println("Doble clic izquierdo en la imagen!");
    }
    System.out.println("Clic en: X=" + event.getX() + ", Y=" + event.getY());
}

KeyEvent

Disparado por: Un Node que tiene el foco cuando se presiona una tecla.
Tipos comunes:

KEY_PRESSED: Tecla presionada.
KEY_RELEASED: Tecla soltada.
KEY_TYPED: Carácter generado por una combinación de teclas (considera modificadores).

Propiedades del KeyEvent: getCode() (la KeyCode de la tecla, ej. KeyCode.A, KeyCode.ENTER), getText() (el carácter si aplica), isShiftDown(), isControlDown(), isAltDown().
Manejo Típico:

Eventos de Cambio (ChangeEvent en ObservableValue)

Muchos controles tienen Properties (como textProperty en TextField, selectedItemProperty en ListView). Puedes añadir un «listener» a estas propiedades para reaccionar cuando su valor cambia.

Ejemplo (TextField):

TextField miCampo = new TextField();
miCampo.textProperty().addListener((observable, oldValue, newValue) -> {
    System.out.println("El texto del TextField cambió de '" + oldValue + "' a '" + newValue + "'");
});

Ejemplo (Slider):

Slider miSlider = new Slider(0, 100, 50);
miSlider.valueProperty().addListener((observable, oldValue, newValue) -> {
    System.out.println("El valor del Slider cambió a: " + newValue.doubleValue());
});

Consumir Eventos

A veces, después de manejar un evento, no quieres que otros manejadores (posiblemente en nodos padre) también lo procesen. Puedes llamar al método event.consume() dentro de tu manejador para detener la propagación del evento.

@FXML
private void onMiNodoHijoClick(MouseEvent event) {
    System.out.println("Clic en nodo hijo manejado.");
    event.consume(); // El nodo padre no recibirá este evento de clic.
}

Buenas Prácticas para el Manejo de Eventos

Mantén los Manejadores Cortos y Enfocados:
- Los manejadores de eventos deben ser concisos. Si la lógica es compleja, llama a otros métodos privados en tu controlador o en clases de servicio/modelo.
- Esto mejora la legibilidad y el mantenimiento.
No Bloquees el Hilo de Aplicación JavaFX (JAT):
- Todo el código de manejo de eventos se ejecuta en el JAT. Si realizas operaciones largas (acceso a red, E/S de archivos pesada, cálculos intensivos) directamente en un manejador, la UI se congelará.
- Para tareas largas, usa hilos en segundo plano (Task, Service) y actualiza la UI usando Platform.runLater().
Usa Nombres Descriptivos para los Métodos Manejadores:
- handleGuardarButtonAction es mejor que accion1.
- Si usas FXML, el prefijo handle es una convención común, seguido del fx:id del nodo y el tipo de acción (ej. handleNombreUsuarioFieldEnterPressed).
Aprovecha el Objeto Evento:
- El objeto evento (ej. ActionEvent event) a menudo contiene información útil. event.getSource() te da el nodo que originó el evento, lo cual es útil si un mismo manejador es usado por múltiples nodos.
Considera la Usabilidad:
- Proporciona feedback al usuario (ej. cambiar el texto de un label, mostrar un indicador de progreso).
- Deshabilita controles que no son aplicables en el estado actual.
Separa la Lógica de la Interfaz (MVC):
- El controlador debe actuar como intermediario. La lógica de negocio «pura» debería residir en otras clases (el «Modelo»). El controlador actualiza la «Vista» (UI) basándose en el Modelo y viceversa.

El manejo de eventos es el corazón de la interactividad en JavaFX. Al comprender cómo registrar manejadores y responder a diferentes tipos de eventos, podrás crear aplicaciones dinámicas y responsivas.

Modo Debug

Ejecuta, falla, aprende…