7.3.2 – Mise à jour du parent

Dans certaines situations, une fenêtre secondaire ou modale doit pouvoir mettre à jour la fenêtre parente après avoir effectué une action. Par exemple, après avoir modifié ou supprimé un élément dans une fenêtre de détail, vous voulez que la liste dans la fenêtre principale soit automatiquement mise à jour. Il existe plusieurs méthodes pour réaliser cela.

🎯 Pourquoi mettre à jour le parent ?

La mise à jour du parent est nécessaire dans plusieurs cas :

• Modification d'un élément : Après modification, la liste principale doit refléter les changements
• Suppression d'un élément : L'élément doit disparaître de la liste principale
• Ajout d'un élément : Le nouvel élément doit apparaître dans la liste
• Changement d'état : Mettre à jour l'affichage selon les actions effectuées

📝 Méthode 1 : Passer une référence au contrôleur parent

La méthode la plus simple est de passer une référence au contrôleur parent à la fenêtre secondaire. Ainsi, la fenêtre secondaire peut appeler des méthodes du parent pour mettre à jour l'affichage.

Exemple : Modification avec mise à jour automatique

MainController.java

package application;

import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.scene.control.ListView;
import javafx.stage.Modality;
import javafx.stage.Stage;

public class MainController {
    
    @FXML
    private ListView<Personne> listViewPersonnes;
    
    private Stage stagePrincipal;
    private List<Personne> personnes;
    
    @FXML
    private void modifierPersonne() {
        Personne personneSelectionnee = listViewPersonnes.getSelectionModel().getSelectedItem();
        
        if (personneSelectionnee == null) {
            return;
        }
        
        try {
            FXMLLoader loader = new FXMLLoader(getClass().getResource("fenetreModification.fxml"));
            Scene scene = new Scene(loader.load());
            
            Stage stageModification = new Stage();
            stageModification.setScene(scene);
            stageModification.setTitle("Modifier la personne");
            stageModification.setWidth(400);
            stageModification.setHeight(350);
            stageModification.initOwner(stagePrincipal);
            stageModification.initModality(Modality.APPLICATION_MODAL);
            
            FenetreModificationController controller = loader.getController();
            controller.setStage(stageModification);
            controller.setPersonne(personneSelectionnee);
            controller.setParentController(this); // Passer la référence au parent
            
            stageModification.showAndWait();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * Méthode appelée par la fenêtre secondaire pour mettre à jour l'affichage
     */
    public void actualiserListe() {
        listViewPersonnes.refresh();
        System.out.println("Liste actualisée");
    }
    
    /**
     * Méthode pour supprimer une personne de la liste
     */
    public void supprimerPersonne(Personne personne) {
        personnes.remove(personne);
        listViewPersonnes.getItems().remove(personne);
        System.out.println("Personne supprimée : " + personne);
    }
}

FenetreModificationController.java

package application;

import javafx.fxml.FXML;
import javafx.scene.control.TextField;
import javafx.stage.Stage;

public class FenetreModificationController {
    
    @FXML
    private TextField txtNom;
    
    @FXML
    private TextField txtPrenom;
    
    @FXML
    private TextField txtAge;
    
    private Stage stage;
    private Personne personne;
    private MainController parentController; // Référence au contrôleur parent
    
    public void setPersonne(Personne personne) {
        this.personne = personne;
        if (personne != null) {
            txtNom.setText(personne.getNom());
            txtPrenom.setText(personne.getPrenom());
            txtAge.setText(String.valueOf(personne.getAge()));
        }
    }
    
    /**
     * Définit le contrôleur parent
     */
    public void setParentController(MainController parent) {
        this.parentController = parent;
    }
    
    @FXML
    private void enregistrer() {
        if (personne == null) {
            return;
        }
        
        // Modifier l'objet
        personne.setNom(txtNom.getText().trim());
        personne.setPrenom(txtPrenom.getText().trim());
        
        try {
            int age = Integer.parseInt(txtAge.getText().trim());
            personne.setAge(age);
        } catch (NumberFormatException e) {
            return;
        }
        
        // Mettre à jour le parent
        if (parentController != null) {
            parentController.actualiserListe(); // Appeler la méthode du parent
        }
        
        // Fermer la fenêtre
        if (stage != null) {
            stage.close();
        }
    }
    
    @FXML
    private void supprimer() {
        if (personne == null || parentController == null) {
            return;
        }
        
        // Demander confirmation (optionnel)
        // ...
        
        // Supprimer via le parent
        parentController.supprimerPersonne(personne);
        
        // Fermer la fenêtre
        if (stage != null) {
            stage.close();
        }
    }
    
    @FXML
    private void annuler() {
        if (stage != null) {
            stage.close();
        }
    }
    
    public void setStage(Stage stage) {
        this.stage = stage;
    }
}

📝 Méthode 2 : Utiliser une interface de callback

Pour une approche plus flexible et découplée, vous pouvez utiliser une interface de callback. Cela permet à la fenêtre secondaire de notifier le parent sans connaître son type exact.

Exemple : Interface de callback

UpdateListener.java (interface)

package application;

public interface UpdateListener {
    /**
     * Méthode appelée quand une personne est modifiée
     */
    void onPersonneModifiee(Personne personne);
    
    /**
     * Méthode appelée quand une personne est supprimée
     */
    void onPersonneSupprimee(Personne personne);
    
    /**
     * Méthode appelée quand une personne est ajoutée
     */
    void onPersonneAjoutee(Personne personne);
}

MainController.java (implémente l'interface)

package application;

public class MainController implements UpdateListener {
    
    @FXML
    private ListView<Personne> listViewPersonnes;
    
    private List<Personne> personnes;
    
    @Override
    public void onPersonneModifiee(Personne personne) {
        listViewPersonnes.refresh();
        System.out.println("Personne modifiée : " + personne);
    }
    
    @Override
    public void onPersonneSupprimee(Personne personne) {
        personnes.remove(personne);
        listViewPersonnes.getItems().remove(personne);
        System.out.println("Personne supprimée : " + personne);
    }
    
    @Override
    public void onPersonneAjoutee(Personne personne) {
        personnes.add(personne);
        listViewPersonnes.getItems().add(personne);
        System.out.println("Personne ajoutée : " + personne);
    }
    
    @FXML
    private void modifierPersonne() {
        Personne personneSelectionnee = listViewPersonnes.getSelectionModel().getSelectedItem();
        
        if (personneSelectionnee == null) {
            return;
        }
        
        try {
            FXMLLoader loader = new FXMLLoader(getClass().getResource("fenetreModification.fxml"));
            Scene scene = new Scene(loader.load());
            
            Stage stageModification = new Stage();
            stageModification.setScene(scene);
            stageModification.initOwner(stagePrincipal);
            stageModification.initModality(Modality.APPLICATION_MODAL);
            
            FenetreModificationController controller = loader.getController();
            controller.setStage(stageModification);
            controller.setPersonne(personneSelectionnee);
            controller.setUpdateListener(this); // Passer le listener
            
            stageModification.showAndWait();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

FenetreModificationController.java (utilise le listener)

package application;

import javafx.fxml.FXML;
import javafx.scene.control.TextField;
import javafx.stage.Stage;

public class FenetreModificationController {
    
    @FXML
    private TextField txtNom;
    
    @FXML
    private TextField txtPrenom;
    
    @FXML
    private TextField txtAge;
    
    private Stage stage;
    private Personne personne;
    private UpdateListener updateListener; // Interface de callback
    
    public void setPersonne(Personne personne) {
        this.personne = personne;
        if (personne != null) {
            txtNom.setText(personne.getNom());
            txtPrenom.setText(personne.getPrenom());
            txtAge.setText(String.valueOf(personne.getAge()));
        }
    }
    
    /**
     * Définit le listener pour les mises à jour
     */
    public void setUpdateListener(UpdateListener listener) {
        this.updateListener = listener;
    }
    
    @FXML
    private void enregistrer() {
        if (personne == null) {
            return;
        }
        
        // Modifier l'objet
        personne.setNom(txtNom.getText().trim());
        personne.setPrenom(txtPrenom.getText().trim());
        
        try {
            int age = Integer.parseInt(txtAge.getText().trim());
            personne.setAge(age);
        } catch (NumberFormatException e) {
            return;
        }
        
        // Notifier le parent via l'interface
        if (updateListener != null) {
            updateListener.onPersonneModifiee(personne);
        }
        
        // Fermer la fenêtre
        if (stage != null) {
            stage.close();
        }
    }
    
    @FXML
    private void supprimer() {
        if (personne == null || updateListener == null) {
            return;
        }
        
        // Notifier le parent
        updateListener.onPersonneSupprimee(personne);
        
        // Fermer la fenêtre
        if (stage != null) {
            stage.close();
        }
    }
    
    public void setStage(Stage stage) {
        this.stage = stage;
    }
}

📝 Méthode 3 : Utiliser des propriétés observables

JavaFX fournit des propriétés observables qui permettent de notifier automatiquement les observateurs lors des changements. C'est particulièrement utile pour synchroniser plusieurs vues.

Exemple : ObservableList

package application;

import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.scene.control.ListView;

public class MainController {
    
    @FXML
    private ListView<Personne> listViewPersonnes;
    
    // Utiliser ObservableList au lieu de List
    private ObservableList<Personne> personnes;
    
    @FXML
    private void initialize() {
        // Créer une ObservableList
        personnes = FXCollections.observableArrayList();
        personnes.add(new Personne("Dupont", "Jean", 25, "jean@exemple.com"));
        personnes.add(new Personne("Martin", "Marie", 30, "marie@exemple.com"));
        
        // Lier directement la ListView à l'ObservableList
        listViewPersonnes.setItems(personnes);
        
        // La ListView se met à jour automatiquement quand la liste change !
    }
    
    @FXML
    private void ajouterPersonne() {
        // Ajouter directement à l'ObservableList
        Personne nouvelle = new Personne("Nouveau", "Nom", 20, "nouveau@exemple.com");
        personnes.add(nouvelle); // La ListView se met à jour automatiquement
    }
    
    @FXML
    private void supprimerPersonne() {
        Personne selectionnee = listViewPersonnes.getSelectionModel().getSelectedItem();
        if (selectionnee != null) {
            personnes.remove(selectionnee); // La ListView se met à jour automatiquement
        }
    }
}

💡 Points clés à retenir

• Référence au parent : Passez une référence au contrôleur parent pour permettre la mise à jour
• Interface de callback : Utilisez une interface pour découpler la fenêtre secondaire du parent
• ObservableList : Utilisez ObservableList pour des mises à jour automatiques de la ListView
• Méthodes publiques : Exposez des méthodes publiques dans le contrôleur parent pour les mises à jour
• Notification : Notifiez toujours le parent après une action importante (modification, suppression, ajout)

7.3.3 – Bonnes pratiques

Pour créer des applications JavaFX robustes et maintenables avec plusieurs fenêtres, il est important de suivre certaines bonnes pratiques. Cette section résume les recommandations essentielles pour bien structurer la communication entre fenêtres.

🎯 1. Séparation des responsabilités

Chaque contrôleur doit avoir une responsabilité claire et limitée :

• Contrôleur principal : Gère la liste principale et la navigation vers les autres fenêtres
• Contrôleur de fenêtre secondaire : Gère uniquement sa propre fenêtre et ses interactions
• Classe modèle : Représente les données (ex: Personne) sans logique d'interface

🎯 2. Gestion des références null

Toujours vérifier que les références ne sont pas null avant de les utiliser :

// ❌ MAUVAIS : Pas de vérification
parentController.actualiserListe();

// ✅ BON : Vérification avant utilisation
if (parentController != null) {
    parentController.actualiserListe();
}

// ✅ ENCORE MIEUX : Vérification avec message d'erreur
if (parentController == null) {
    System.err.println("Erreur : Référence au parent manquante");
    return;
}
parentController.actualiserListe();

🎯 3. Validation des données

Validez toujours les données avant de les utiliser ou de les passer à d'autres fenêtres :

@FXML
private void valider() {
    String nom = txtNom.getText().trim();
    String prenom = txtPrenom.getText().trim();
    String ageStr = txtAge.getText().trim();
    
    // Validation
    if (nom.isEmpty() || prenom.isEmpty() || ageStr.isEmpty()) {
        // Afficher un message d'erreur
        lblMessage.setText("Veuillez remplir tous les champs");
        lblMessage.getStyleClass().setAll("message-error");
        return; // Ne pas fermer la fenêtre
    }
    
    try {
        int age = Integer.parseInt(ageStr);
        if (age < 0 || age > 150) {
            lblMessage.setText("Âge invalide (0-150)");
            return;
        }
        
        // Créer l'objet seulement si la validation réussit
        Personne personne = new Personne(nom, prenom, age, email);
        // ...
        
    } catch (NumberFormatException e) {
        lblMessage.setText("Âge doit être un nombre");
        return;
    }
}

🎯 4. Gestion des erreurs

Utilisez des blocs try-catch pour gérer les erreurs lors du chargement des FXML et des opérations sur les fichiers :

@FXML
private void ouvrirFenetre() {
    try {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("fenetre.fxml"));
        Scene scene = new Scene(loader.load());
        
        Stage stage = new Stage();
        stage.setScene(scene);
        stage.show();
        
    } catch (IOException e) {
        // Afficher un message d'erreur à l'utilisateur
        Alert alert = new Alert(AlertType.ERROR);
        alert.setTitle("Erreur");
        alert.setHeaderText("Impossible d'ouvrir la fenêtre");
        alert.setContentText("Erreur : " + e.getMessage());
        alert.showAndWait();
        
        // Logger l'erreur pour le débogage
        System.err.println("Erreur lors du chargement : " + e.getMessage());
        e.printStackTrace();
    }
}

🎯 5. Utilisation d'ObservableList

Préférez ObservableList à List pour les listes affichées dans des ListView :

// ❌ MAUVAIS : List normale
private List<Personne> personnes = new ArrayList<>();

// ✅ BON : ObservableList
private ObservableList<Personne> personnes = FXCollections.observableArrayList();

// Lier à la ListView
listViewPersonnes.setItems(personnes);

// Les modifications sont automatiquement reflétées dans la ListView
personnes.add(nouvellePersonne); // Mise à jour automatique
personnes.remove(personne);      // Mise à jour automatique

🎯 6. Nettoyage des ressources

Fermez toujours les fenêtres et libérez les ressources quand elles ne sont plus nécessaires :

@FXML
private void fermer() {
    // Nettoyer les ressources si nécessaire
    // Par exemple : fermer des connexions, sauvegarder des données, etc.
    
    if (stage != null) {
        stage.close();
    }
    
    // Optionnel : Réinitialiser les références
    parentController = null;
    personne = null;
}

🎯 7. Documentation du code

Documentez vos méthodes publiques, surtout celles utilisées pour la communication entre fenêtres :

/**
 * Met à jour l'affichage de la liste principale.
 * Cette méthode est appelée par les fenêtres secondaires
 * après une modification, suppression ou ajout.
 */
public void actualiserListe() {
    listViewPersonnes.refresh();
}

/**
 * Définit le contrôleur parent pour permettre la mise à jour.
 * 
 * @param parent Le contrôleur parent qui sera notifié des changements
 */
public void setParentController(MainController parent) {
    this.parentController = parent;
}

🎯 8. Utilisation de constantes

Définissez des constantes pour les valeurs réutilisées (tailles de fenêtres, messages, etc.) :

public class FenetreModificationController {
    
    // Constantes pour les dimensions
    private static final double FENETRE_LARGEUR = 400.0;
    private static final double FENETRE_HAUTEUR = 350.0;
    
    // Constantes pour les messages
    private static final String MESSAGE_ERREUR_AGE = "Âge invalide";
    private static final String MESSAGE_CHAMPS_VIDES = "Veuillez remplir tous les champs";
    
    @FXML
    private void ouvrirFenetre() {
        Stage stage = new Stage();
        stage.setWidth(FENETRE_LARGEUR);
        stage.setHeight(FENETRE_HAUTEUR);
        // ...
    }
}

🎯 9. Éviter les dépendances circulaires

Évitez les dépendances circulaires entre contrôleurs. Utilisez des interfaces ou des événements pour découpler :

// ❌ MAUVAIS : Dépendance circulaire
// MainController importe FenetreController
// FenetreController importe MainController

// ✅ BON : Utiliser une interface
// MainController implémente UpdateListener
// FenetreController utilise UpdateListener (interface)
// Pas de dépendance directe entre les deux contrôleurs

🎯 10. Tests et débogage

Ajoutez des messages de débogage pour suivre le flux d'exécution :

@FXML
private void enregistrer() {
    System.out.println("Début de l'enregistrement");
    
    if (personne == null) {
        System.err.println("Erreur : personne est null");
        return;
    }
    
    // ... logique ...
    
    if (parentController != null) {
        System.out.println("Notification du parent");
        parentController.actualiserListe();
    } else {
        System.err.println("Attention : parentController est null");
    }
    
    System.out.println("Fin de l'enregistrement");
}

💡 Checklist des bonnes pratiques