Vamos a continuar con el diseño del panel para gestionar alumnos en Java Swing, enfocándonos en crear un panel de detalle que permita editar y visualizar la información de cada alumno. Para ello, hemos preparado una interfaz con botones para agregar, editar, borrar, guardar y cancelar, y una tabla que muestra la lista de alumnos.
Primero, hemos incorporado imágenes a los botones para mejorar la experiencia visual, usando recursos del proyecto Elementar. Los botones Agregar, Editar y Borrar están configurados para activarse según la interacción con la tabla: Agregar siempre está disponible para crear un nuevo alumno, mientras que Editar y Borrar se habilitan al seleccionar un alumno existente. Los botones Guardar y Cancelar aparecen cuando se muestra el panel de detalle, permitiendo confirmar o descartar cambios.
El panel de detalle contiene campos para los apellidos, nombre y fecha de nacimiento del alumno. Para los dos primeros usamos JTextField, y para la fecha un JFormattedTextField con un formato personalizado día/mes/año, adaptado a la convención española. Aunque el manejo de JFormattedTextField puede ser complicado, en este caso simplifica la entrada y validación de fechas.
Creamos variables para almacenar el alumno actual y un indicador booleano editable que controla si los campos pueden modificarse. Al cambiar el estado editable, propagamos esta propiedad a los campos de texto para activar o desactivar la edición. También definimos métodos para cargar datos en el formulario (loadData) y para guardar los datos introducidos (saveData). En saveData, si no hay un alumno asignado, creamos uno nuevo con un constructor vacío, asignando los valores de los campos. Para la fecha usamos la conversión automática que ofrece el JFormattedTextField.
Para organizar la interfaz, ocultamos el panel de scroll original y usamos un JSplitPane con un panel central para la tabla y otro a la derecha para el detalle del alumno. Esto asegura que ambos paneles tengan el tamaño adecuado y se adapten bien al espacio disponible.
En cuanto a la interacción, añadimos un ListSelectionListener a la tabla para detectar cuándo se selecciona una fila. Si la selección es válida, activamos los botones Editar y Borrar. Al pulsar Editar, obtenemos el alumno seleccionado desde el DAO y cargamos sus datos en el panel de detalle, activando la edición y habilitando los botones Guardar y Cancelar.
El botón Cancelar limpia el formulario, desactiva la edición y deselecciona cualquier fila en la tabla, restaurando el estado inicial sin cambios. Para el botón Nuevo, creamos un alumno vacío, cargamos el formulario con campos vacíos, activamos la edición y habilitamos los botones correspondientes. Además, pedimos que el foco se coloque automáticamente en el campo de apellidos para facilitar la entrada de datos.
Por último, queda pendiente implementar la funcionalidad del botón Guardar, que debe distinguir entre insertar un nuevo alumno o actualizar uno existente, y la operación de Borrar. Estas tareas requieren un manejo cuidadoso de la base de datos y se abordarán en próximas etapas.
Con este enfoque, hemos construido un flujo interactivo en la interfaz que permite gestionar alumnos de forma intuitiva, combinando componentes Swing, manejo de eventos y lógica para controlar el estado de edición y selección. El uso de JFormattedTextField para la fecha y la organización con JSplitPane contribuyen a una experiencia de usuario más clara y funcional.
A continuación, mostramos un fragmento representativo del código para el panel de detalle y la gestión de eventos:
// Variables para campos y estado
private JTextField apellidosField = new JTextField(20);
private JTextField nombreField = new JTextField(20);
private JFormattedTextField fechaNacimientoField;
private Alumno alumno;
private boolean editable;
// Constructor o método de inicialización
DateFormat format = new SimpleDateFormat("dd/MM/yyyy");
fechaNacimientoField = new JFormattedTextField(format);
fechaNacimientoField.setColumns(10);
public void setEditable(boolean editable) {
this.editable = editable;
apellidosField.setEditable(editable);
nombreField.setEditable(editable);
fechaNacimientoField.setEditable(editable);
}
public void setAlumno(Alumno alumno) {
this.alumno = alumno;
}
public void loadData() {
if (alumno != null) {
apellidosField.setText(alumno.getApellidos());
nombreField.setText(alumno.getNombre());
fechaNacimientoField.setValue(alumno.getFechaNacimiento());
} else {
apellidosField.setText("");
nombreField.setText("");
fechaNacimientoField.setValue(null);
}
}
public void saveData() {
if (alumno == null) {
alumno = new Alumno();
alumno.setFechaNacimiento(new Date());
}
alumno.setApellidos(apellidosField.getText());
alumno.setNombre(nombreField.getText());
alumno.setFechaNacimiento((Date) fechaNacimientoField.getValue());
}
// Listener para selección en la tabla
tabla.getSelectionModel().addListSelectionListener(e -> {
int selectedRow = tabla.getSelectedRow();
boolean rowSelected = selectedRow != -1;
editarButton.setEnabled(rowSelected);
borrarButton.setEnabled(rowSelected);
});
// Acción para botón Editar
editarButton.addActionListener(e -> {
int selectedRow = tabla.getSelectedRow();
if (selectedRow != -1) {
int idAlumno = (int) tabla.getValueAt(selectedRow, 0);
try {
alumno = alumnoDao.obtenerPorId(idAlumno);
detallePanel.setAlumno(alumno);
detallePanel.setEditable(true);
detallePanel.loadData();
guardarButton.setEnabled(true);
cancelarButton.setEnabled(true);
} catch (Exception ex) {
// Manejo de excepción
}
}
});
// Acción para botón Cancelar
cancelarButton.addActionListener(e -> {
detallePanel.setAlumno(null);
detallePanel.setEditable(false);
detallePanel.loadData();
guardarButton.setEnabled(false);
cancelarButton.setEnabled(false);
tabla.clearSelection();
});
// Acción para botón Nuevo
nuevoButton.addActionListener(e -> {
detallePanel.setAlumno(null);
detallePanel.loadData();
detallePanel.setEditable(true);
guardarButton.setEnabled(true);
cancelarButton.setEnabled(true);
apellidosField.requestFocus();
});
Este código refleja la estructura básica para manejar la edición y creación de alumnos, integrando la interfaz gráfica con la lógica de negocio y eventos. Así, podemos avanzar en la construcción de una aplicación CRUD funcional y amigable.