codeFinal+docs+clean

src/AutomatiqueActionListener.java

@@ -2,35 +2,61 @@ import javax.swing.*;
 import java.awt.event.*;
 import java.io.File;
 
+/**
+ * La classe <code>AutomatiqueActionListener</code> est un écouteur d'événements utilisé pour gérer l'action
+ * lorsqu'on clique sur le bouton "Automatique" dans la fenêtre de choix.
+ * Elle permet de choisir un fichier contenant une grille de Sudoku, de la résoudre automatiquement
+ * et d'afficher le résultat dans une nouvelle fenêtre.
+ * 
+ * Elle implémente l'interface ActionListener pour écouter les événements liés au bouton.
+ * 
+ * @author Dick Adrien
+ * @version 3.0
+ */
 public class AutomatiqueActionListener implements ActionListener {
     private JFrame choixFrame;
 
+    /**
+     * Constructeur de la classe AutomatiqueActionListener.
+     * 
+     * @param choixFrame La fenêtre de choix du Sudoku.
+     */
     public AutomatiqueActionListener(JFrame choixFrame) {
         this.choixFrame = choixFrame;
     }
 
+    /**
+     * Méthode appelée lorsque l'action associée à ce listener est déclenchée, c'est-à-dire lorsque le bouton
+     * "Automatique" est cliqué.
+     * 
+     * @param e L'événement associé à l'action.
+     */
     @Override
     public void actionPerformed(ActionEvent e) {
+        // Ferme la fenêtre de choix du Sudoku.
         choixFrame.dispose();
 
-        int[][] grille = new int[9][9]; // Création d'une grille vide
+        // Crée une grille vide de Sudoku.
+        int[][] grille = new int[9][9];
 
-        // Ouverture du sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille
+        // Ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille.
         JFileChooser fileChooser = new JFileChooser();
         int returnValue = fileChooser.showOpenDialog(null);
 
+        // Vérifie si l'utilisateur a sélectionné un fichier.
         if (returnValue == JFileChooser.APPROVE_OPTION) {
             File selectedFile = fileChooser.getSelectedFile();
 
-            // Lecture de la grille à partir du fichier sélectionné
+            // Lit la grille à partir du fichier sélectionné.
             Lecteur.lecture(selectedFile, grille);
 
-            // Résolution du Sudoku
+            // Résout le Sudoku.
             long startTime = System.nanoTime();
             if (Resolveur.resoudreSudoku(grille)) {
                 long endTime = System.nanoTime();
                 long duration = (endTime - startTime) / 1000000;
 
+                // Affiche la grille résolue dans une nouvelle fenêtre.
                 FenetrePrincipale fenetrePrincipale = new FenetrePrincipale();
                 fenetrePrincipale.afficher(true, grille);
                 JOptionPane.showMessageDialog(null, "Grille résolue avec succès en " + duration + " millisecondes !");

src/CaseMouseListener.java

@@ -1,22 +1,51 @@
 import javax.swing.*;
 import java.awt.event.*;
 
+/**
+ * La classe <code>CaseMouseListener</code> est un écouteur d'événements de souris utilisé pour gérer les actions
+ * lorsque l'utilisateur clique sur une case de la grille de Sudoku.
+ * Elle permet à l'utilisateur de sélectionner une case, d'y entrer un chiffre ou des valeurs incertaines.
+ * 
+ * Elle étend MouseAdapter pour gérer les événements de souris de manière simplifiée.
+ * 
+ * Elle utilise des boîtes de dialogue JOptionPane pour permettre à l'utilisateur d'entrer des chiffres ou des valeurs incertaines.
+ * 
+ * @author Dick Adrien
+ * @version 8.0
+ */
 public class CaseMouseListener extends MouseAdapter {
     private SaisieGrille panel;
 
+    /**
+     * Constructeur de la classe CaseMouseListener.
+     * 
+     * @param panel Le panneau de saisie de la grille de Sudoku associé à cet écouteur.
+     */
     public CaseMouseListener(SaisieGrille panel) {
         this.panel = panel;
     }
 
+    /**
+     * Méthode appelée lorsque l'utilisateur clique sur une case de la grille de Sudoku.
+     * 
+     * @param e L'événement de souris associé au clic.
+     */
     @Override
     public void mouseClicked(MouseEvent e) {
+        // Convertit les coordonnées du clic en indices de ligne et de colonne dans la grille.
         int x = e.getX() / panel.getTailleCellule();
         int y = e.getY() / panel.getTailleCellule();
+        
+        // Vérifie si les coordonnées se trouvent dans la grille.
         if (x >= 0 && x < panel.getTailleGrille() * panel.getTailleRegion() && y >= 0 && y < panel.getTailleGrille() * panel.getTailleRegion()) {
+            // Enregistre la ligne et la colonne sélectionnées.
             panel.setLigneSelectionnee(y);
             panel.setColonneSelectionnee(x);
             System.out.println("Case sélectionnée : (" + panel.getLigneSelectionnee() + ", " + panel.getColonneSelectionnee() + ")");
+            
+            // Vérifie si la case sélectionnée peut être modifiée.
             if (panel.getGrilleInitiale()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] == 0) {
+                // Affiche une boîte de dialogue pour permettre à l'utilisateur d'entrer un chiffre ou des valeurs incertaines.
                 String[] options = {"Incertain", "Valider"};
                 JTextField textField = new JTextField();
                 Object[] message = {
@@ -25,12 +54,16 @@ public class CaseMouseListener extends MouseAdapter {
                 };
                 int option = JOptionPane.showOptionDialog(null, message, "Entrez un nombre", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
                 if (option == 1) {
+                    // L'utilisateur a choisi de valider un chiffre.
                     String valeurStr = textField.getText();
                     try {
                         int valeur = Integer.parseInt(valeurStr);
+                        // Vérifie si le chiffre est valide pour cette case.
                         if (panel.validerChiffre(panel.getLigneSelectionnee(), panel.getColonneSelectionnee(), valeur)) {
+                            // Met à jour la grille et la redessine si le chiffre est valide.
                             panel.getGrille()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] = valeur;
                             panel.repaint();
+                            // Vérifie si la grille est complète après la mise à jour.
                             if (panel.grilleComplete()) {
                                 panel.afficherBravo();
                             }
@@ -41,7 +74,7 @@ public class CaseMouseListener extends MouseAdapter {
                         JOptionPane.showMessageDialog(null, "Saisie invalide. Veuillez entrer un nombre.");
                     }
                 } else if (option == 0) {
-                    // Le joueur a choisi "Incertain"
+                    // L'utilisateur a choisi "Incertain".
                     JTextField[] incertainFields = new JTextField[4];
                     for (int i = 0; i < 4; i++) {
                         incertainFields[i] = new JTextField();
@@ -55,9 +88,9 @@ public class CaseMouseListener extends MouseAdapter {
                     };
                     int incertainOption = JOptionPane.showOptionDialog(null, incertainMessage, "Entrez les valeurs incertaines", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE, null, null, null);
                     if (incertainOption == JOptionPane.OK_OPTION) {
-                        // Vérifier que les valeurs obligatoires sont remplies
+                        // Vérifie que les valeurs obligatoires sont remplies.
                         if (!incertainFields[0].getText().isEmpty() && !incertainFields[1].getText().isEmpty()) {
-                            // Vérifier que les valeurs incertaines sont valides
+                            // Vérifie que les valeurs incertaines sont valides.
                             boolean valeursValides = true;
                             for (int i = 0; i < 4; i++) {
                                 if (!incertainFields[i].getText().isEmpty()) {
@@ -69,7 +102,7 @@ public class CaseMouseListener extends MouseAdapter {
                                 }
                             }
                             if (valeursValides) {
-                                // Récupérer les valeurs incertaines saisies par le joueur
+                                // Récupère les valeurs incertaines saisies par l'utilisateur.
                                 int valeursIncertaines = 0;
                                 for (int i = 0; i < 4; i++) {
                                     if (!incertainFields[i].getText().isEmpty()) {
@@ -77,7 +110,7 @@ public class CaseMouseListener extends MouseAdapter {
                                         valeursIncertaines |= (valeur << (i * 4));
                                     }
                                 }
-                                // Mettre à jour la grille avec les valeurs incertaines
+                                // Met à jour la grille avec les valeurs incertaines et la redessine.
                                 panel.getGrille()[panel.getLigneSelectionnee()][panel.getColonneSelectionnee()] = valeursIncertaines;
                                 panel.repaint();
                             } else {

src/FenetreChoix.java

@@ -1,30 +1,58 @@
 import javax.swing.*;
 import java.awt.*;
 
-
+/**
+ * La classe <code>FenetreChoix</code> est utilisée pour afficher la fenêtre de choix de mode de résolution du Sudoku.
+ * Elle crée une fenêtre avec deux boutons, l'un pour le mode automatique et l'autre pour le mode manuel.
+ * Lorsque l'utilisateur choisit l'un des modes, la fenêtre se ferme.
+ * 
+ * @author Dick Adrien
+ * @version 2.0
+ */
 public class FenetreChoix {
+    /**
+     * Affiche la fenêtre de choix.
+     */
     public void afficher() {
+        // Crée une nouvelle fenêtre avec un titre.
         JFrame choixFrame = new JFrame("Choix de résolution du Sudoku");
+        
+        // Définit l'opération de fermeture par défaut de la fenêtre.
         choixFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        
+        // Définit la taille de la fenêtre.
         choixFrame.setSize(400, 200);
+        
+        // Définit le gestionnaire de disposition de la fenêtre.
         choixFrame.setLayout(new BorderLayout());
+        
+        // Centre la fenêtre sur l'écran.
         choixFrame.setLocationRelativeTo(null);
 
+        // Crée un label pour afficher un message d'instruction.
         JLabel label = new JLabel("Choisissez le mode de résolution du Sudoku :");
         label.setHorizontalAlignment(JLabel.CENTER);
 
+        // Crée deux boutons pour les modes automatique et manuel.
         JButton automatiqueButton = new JButton("Automatique");
         JButton manuelButton = new JButton("Manuel");
 
+        // Crée un panel pour contenir les boutons et définit son gestionnaire de disposition.
         JPanel boutonsPanel = new JPanel();
         boutonsPanel.setLayout(new FlowLayout());
+        
+        // Ajoute les boutons au panel.
         boutonsPanel.add(automatiqueButton);
         boutonsPanel.add(manuelButton);
 
+        // Ajoute le label et le panel de boutons à la fenêtre.
         choixFrame.add(label, BorderLayout.NORTH);
         choixFrame.add(boutonsPanel, BorderLayout.CENTER);
+        
+        // Rend la fenêtre visible.
         choixFrame.setVisible(true);
 
+        // Associe un écouteur d'événements aux boutons pour gérer les actions.
         automatiqueButton.addActionListener(new AutomatiqueActionListener(choixFrame));
         manuelButton.addActionListener(new ManuelActionListener(choixFrame));
     }

src/FenetreModif.java

@@ -2,45 +2,53 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
 import java.io.*;
-import java.io.File;
-import java.io.PrintWriter;
-import java.io.FileWriter;
-import java.io.IOException;
-import javax.swing.JFileChooser;
 import javax.swing.filechooser.FileNameExtensionFilter;
 
+/**
+ * La classe <code>FenetreModif</code> est utilisée pour afficher une fenêtre permettant de modifier une grille Sudoku et de l'enregistrer dans un fichier.
+ * Elle comporte une méthode statique <code>fenetreModification</code> qui prend en paramètre une grille Sudoku, puis affiche une fenêtre avec la grille et un bouton d'enregistrement.
+ * 
+ * @author Raban Hugo
+ * @version 3.0
+ */
 public class FenetreModif{
+    /**
+     * Méthode statique pour afficher une fenêtre permettant de modifier une grille Sudoku et de l'enregistrer dans un fichier.
+     * 
+     * @param grille La grille Sudoku à modifier.
+     */
     public static void fenetreModification(int[][] grille) {
-        JFrame frame = new JFrame("Sudoku");
+        JFrame frame = new JFrame("Sudoku"); // Crée une nouvelle fenêtre avec le titre "Sudoku"
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Définit l'action par défaut lorsque la fenêtre est fermée
-        SaisieGrille saisieGrille = new SaisieGrille(grille); // Utilisation de la classe SaisieGrille pour permettre la saisie des valeurs
+        SaisieGrille saisieGrille = new SaisieGrille(grille); // Crée une nouvelle instance de SaisieGrille avec la grille Sudoku fournie
-        JButton register = new JButton("Enregistrer");
+        JButton register = new JButton("Enregistrer"); // Crée un nouveau bouton "Enregistrer"
+
+        // Ajoute un écouteur d'événements au bouton "Enregistrer"
         register.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e){
-                JFileChooser fileChooser = new JFileChooser();
+                JFileChooser fileChooser = new JFileChooser(); // Crée un sélecteur de fichiers
 
-                FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri");
+                FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri"); // Définit un filtre pour les fichiers avec l'extension .gri
-                fileChooser.setFileFilter(filter);
+                fileChooser.setFileFilter(filter); // Applique le filtre au sélecteur de fichiers
 
-                File workingDirectory = new File(System.getProperty("user.dir"));
+                File workingDirectory = new File(System.getProperty("user.dir")); // Récupère le répertoire de travail de l'application
-                fileChooser.setCurrentDirectory(workingDirectory);
+                fileChooser.setCurrentDirectory(workingDirectory); // Définit le répertoire de départ du sélecteur de fichiers
                 JPanel panneau = new JPanel();
-                int valeur_de_retour = fileChooser.showOpenDialog(panneau);
+                int valeur_de_retour = fileChooser.showOpenDialog(panneau); // Affiche le sélecteur de fichiers et attend la sélection d'un fichier
-                if(valeur_de_retour == JFileChooser.APPROVE_OPTION) {
+                if(valeur_de_retour == JFileChooser.APPROVE_OPTION) { // Si un fichier est sélectionné
-                    Register.sauvegarde(fileChooser.getSelectedFile(), grille);
+                    Register.sauvegarde(fileChooser.getSelectedFile(), grille); // Enregistre la grille dans le fichier sélectionné en utilisant la méthode sauvegarde de la classe Register
                 }
             }
         });
 
-        frame.add(register, BorderLayout.SOUTH); // Ajouter le bouton "Enregistrer"
+        frame.add(register, BorderLayout.SOUTH); // Ajoute le bouton "Enregistrer" en bas de la fenêtre
+        frame.add(saisieGrille, BorderLayout.CENTER); // Ajoute la grille à la fenêtre
 
-        frame.add(saisieGrille, BorderLayout.CENTER); // Ajouter la grille à la fenêtre
+        frame.pack(); // Ajuste la taille de la fenêtre pour qu'elle s'adapte à son contenu
+        frame.setLocationRelativeTo(null); // Centre la fenêtre sur l'écran
+        frame.setVisible(true); // Rend la fenêtre visible
 
-        frame.pack();
+        System.out.println("La fenêtre de création a été affichée."); // Affiche un message dans la console pour indiquer que la fenêtre a été affichée
-        frame.setLocationRelativeTo(null); // Centrer la fenêtre sur l'écran
-        frame.setVisible(true);
-
-        System.out.println("La fenêtre de création a été affichée.");
     }
 }

src/FenetrePrincipale.java

@@ -1,25 +1,53 @@
-
 import javax.swing.*;
 import java.awt.*;
 
-
+/**
+ * La classe <code>FenetrePrincipale</code> est utilisée pour afficher la fenêtre principale du jeu Sudoku.
+ * Elle affiche une grille de Sudoku dans une fenêtre Swing.
+ * 
+ * Elle prend en compte le mode de jeu (automatique ou manuel) pour personnaliser l'affichage.
+ * Si le mode est manuel, un bouton de réinitialisation est également affiché.
+ * 
+ * @author Dick Adrien
+ * @version 2.0
+ */
 public class FenetrePrincipale {
+    /**
+     * Affiche la fenêtre principale du Sudoku.
+     * 
+     * @param modeAutomatique Indique si le mode de jeu est automatique ou manuel.
+     * @param grille La grille de Sudoku à afficher.
+     */
     public void afficher(boolean modeAutomatique, int[][] grille) {
+        // Crée une nouvelle fenêtre avec un titre.
         JFrame frame = new JFrame("Sudoku");
+        
+        // Définit l'opération de fermeture par défaut de la fenêtre.
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        
+        // Crée un composant pour la saisie de la grille de Sudoku.
         SaisieGrille saisieGrille = new SaisieGrille(grille);
 
+        // Si le mode n'est pas automatique, ajoute un bouton de réinitialisation.
         if (!modeAutomatique) {
             JButton reinitialiserButton = new JButton("Réinitialiser");
             reinitialiserButton.addActionListener(new ReinitialiserActionListener(grille, saisieGrille));
             frame.add(reinitialiserButton, BorderLayout.SOUTH);
         }
 
+        // Ajoute le composant de saisie de la grille à la fenêtre.
         frame.add(saisieGrille, BorderLayout.CENTER);
+        
+        // Ajuste la taille de la fenêtre en fonction de son contenu.
         frame.pack();
+        
+        // Centre la fenêtre sur l'écran.
         frame.setLocationRelativeTo(null);
+        
+        // Rend la fenêtre visible.
         frame.setVisible(true);
 
+        // Affiche un message dans la console pour indiquer que la fenêtre Sudoku a été affichée.
         System.out.println("La fenêtre Sudoku a été affichée.");
     }
 }

src/GenerateurSudoku.java

@@ -1,20 +0,0 @@
-import javax.swing.*;
-
-public class GenerateurSudoku {
-    public static int[][] genererGrille() {
-        // grille par défaut
-        int[][] grille = {
-            {0, 0, 0, 0, 9, 5, 0, 0, 4},
-            {5, 3, 0, 4, 0, 8, 7, 0, 2},
-            {0, 0, 0, 7, 0, 0, 6, 0, 3},
-            {9, 0, 0, 0, 3, 4, 0, 8, 0},
-            {0, 4, 0, 0, 1, 0, 0, 7, 0},
-            {0, 2, 0, 5, 7, 0, 0, 0, 6},
-            {4, 0, 9, 0, 0, 2, 0, 0, 0},
-            {6, 0, 7, 9, 0, 3, 0, 2, 1},
-            {2, 0, 0, 6, 5, 0, 0, 0, 0}
-        };
-
-        return grille;
-    }
-}

src/GrilleExisteActionListener.java

@@ -1,37 +1,63 @@
 import javax.swing.*;
-import java.awt.*;
+import javax.swing.filechooser.FileNameExtensionFilter;
 import java.awt.event.*;
 import java.io.*;
-import java.io.File;
-import java.io.PrintWriter;
-import java.io.FileWriter;
-import java.io.IOException;
-import javax.swing.JFileChooser;
-import javax.swing.filechooser.FileNameExtensionFilter;
 
-public class GrilleExisteActionListener implements ActionListener{
+/**
+ * La classe <code>GrilleExisteActionListener</code> est un écouteur d'événements utilisé pour gérer l'action de sélectionner une grille existante.
+ * 
+ * Lorsque l'utilisateur clique sur le bouton pour choisir une grille existante, cet écouteur est déclenché.
+ * 
+ * Il ferme la fenêtre de choix actuelle, ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille existant, puis charge la grille à partir de ce fichier.
+ * 
+ * Si l'utilisateur sélectionne un fichier valide, la grille est chargée à partir de ce fichier et une nouvelle fenêtre de modification est affichée avec cette grille.
+ * 
+ * @author Raban Hugo
+ * @version 4.0
+ */
+public class GrilleExisteActionListener implements ActionListener {
     private JFrame choixFrame;
 
+    /**
+     * Constructeur de la classe GrilleExisteActionListener.
+     * 
+     * @param choixFrame La fenêtre de choix actuelle.
+     */
     public GrilleExisteActionListener(JFrame choixFrame) {
         this.choixFrame = choixFrame;
     }
 
+    /**
+     * Méthode actionPerformed qui est appelée lorsque l'action est déclenchée (l'utilisateur clique sur le bouton).
+     * 
+     * @param e L'événement d'action associé à cette action.
+     */
     @Override
-
     public void actionPerformed(ActionEvent e) {
+        // Ferme la fenêtre de choix actuelle
         choixFrame.dispose();
-        int [][] grille = new int [9][9];
-        JFileChooser fileChooser = new JFileChooser();
 
-        FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri");
+        // Crée une nouvelle grille vide
+        int[][] grille = new int[9][9];
+
+        // Ouvre le sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille
+        JFileChooser fileChooser = new JFileChooser();
+        FileNameExtensionFilter filter = new FileNameExtensionFilter("Fichier grille", "gri");
         fileChooser.setFileFilter(filter);
 
+        // Définit le répertoire de travail actuel comme répertoire initial du sélecteur de fichiers
         File workingDirectory = new File(System.getProperty("user.dir"));
         fileChooser.setCurrentDirectory(workingDirectory);
-        JPanel panneau = new JPanel();
+
-        int valeur_de_retour = fileChooser.showOpenDialog(panneau);
+        // Affiche le sélecteur de fichiers dans un panneau
-        if(valeur_de_retour == JFileChooser.APPROVE_OPTION) {
+        JPanel panel = new JPanel();
+        int returnValue = fileChooser.showOpenDialog(panel);
+
+        // Si l'utilisateur a sélectionné un fichier valide
+        if (returnValue == JFileChooser.APPROVE_OPTION) {
+            // Charge la grille à partir du fichier sélectionné
             Lecteur.lecture(fileChooser.getSelectedFile(), grille);
+            // Affiche une nouvelle fenêtre de modification avec la grille chargée
             FenetreModif.fenetreModification(grille);
         }
     }

src/GrillePainter.java

@@ -1,11 +1,31 @@
 import java.awt.*;
 
+/**
+ * La classe <code>GrillePainter</code> est utilisée pour dessiner la grille de Sudoku et ses valeurs dans le panneau de saisie.
+ * 
+ * Elle fournit une méthode statique <code>dessinerGrille</code> qui prend en charge le dessin de la grille et des valeurs de la grille.
+ * 
+ * Elle utilise les informations fournies par le panneau de saisie (<code>SaisieGrille</code>) pour dessiner correctement la grille.
+ * 
+ * Elle utilise la classe Graphics2D pour dessiner des formes et des textes.
+ * 
+ * @author Dick Adrien
+ * @version 4.0
+ */
 public class GrillePainter {
+    
+    /**
+     * Méthode statique pour dessiner la grille de Sudoku et ses valeurs dans le panneau de saisie.
+     * 
+     * @param g Le contexte graphique dans lequel dessiner.
+     * @param panel Le panneau de saisie de la grille de Sudoku.
+     */
     public static void dessinerGrille(Graphics g, SaisieGrille panel) {
         Graphics2D g2d = (Graphics2D) g;
         Stroke ancienStroke = g2d.getStroke();
         g2d.setStroke(new BasicStroke(4));
 
+        // Dessine les lignes de la grille
         for (int i = 0; i <= panel.getTailleGrille() * panel.getTailleRegion(); i++) {
             if (i % panel.getTailleRegion() == 0) {
                 g2d.drawLine(0, i * panel.getTailleCellule(), panel.getTailleGrille() * panel.getTailleRegion() * panel.getTailleCellule(), i * panel.getTailleCellule());
@@ -15,6 +35,7 @@ public class GrillePainter {
 
         g2d.setStroke(ancienStroke);
 
+        // Dessine les valeurs de la grille
         for (int i = 0; i < panel.getTailleGrille() * panel.getTailleRegion(); i++) {
             for (int j = 0; j < panel.getTailleGrille() * panel.getTailleRegion(); j++) {
                 g.setColor(Color.BLACK);
@@ -22,9 +43,11 @@ public class GrillePainter {
 
                 int valeur = panel.getGrille()[i][j];
                 if (valeur != 0) {
+                    // Dessine la valeur dans la case
                     if (valeur < 10) {
                         g.drawString(String.valueOf(valeur), j * panel.getTailleCellule() + panel.getTailleCellule() / 2, i * panel.getTailleCellule() + panel.getTailleCellule() / 2);
                     } else {
+                        // Si la valeur est incertaine, la décompose et la dessine dans les sous-cases
                         int[] valeurs = decomposerValeurs(valeur);
                         for (int k = 0; k < valeurs.length; k++) {
                             int xOffset = (k % 2) * panel.getTailleCellule() / 2;
@@ -37,6 +60,12 @@ public class GrillePainter {
         }
     }
 
+    /**
+     * Méthode privée pour décomposer une valeur incertaine en ses sous-valeurs.
+     * 
+     * @param valeursIncertaines La valeur incertaine à décomposer.
+     * @return Un tableau d'entiers contenant les sous-valeurs.
+     */
     private static int[] decomposerValeurs(int valeursIncertaines) {
         int[] valeurs = new int[4];
         for (int i = 0; i < 4; i++) {

src/GrilleVideActionListener.java

@@ -1,28 +1,44 @@
 import javax.swing.*;
-import java.awt.*;
 import java.awt.event.*;
 import java.io.*;
-import java.io.File;
-import java.io.PrintWriter;
-import java.io.FileWriter;
-import java.io.IOException;
-import javax.swing.JFileChooser;
-import javax.swing.filechooser.FileNameExtensionFilter;
 
-public class GrilleVideActionListener implements ActionListener{
+/**
+ * La classe <code>GrilleVideActionListener</code> est un écouteur d'événements utilisé pour gérer l'action de sélectionner une grille vide.
+ * 
+ * Lorsque l'utilisateur clique sur le bouton pour choisir une grille vide, cet écouteur est déclenché.
+ * 
+ * Il crée une grille vide, ferme la fenêtre de choix actuelle, puis affiche une nouvelle fenêtre de modification avec cette grille vide.
+ * 
+ * @author Raban Hugo
+ * @version 2.0
+ */
+public class GrilleVideActionListener implements ActionListener {
     private JFrame choixFrame;
 
+    /**
+     * Constructeur de la classe GrilleVideActionListener.
+     * 
+     * @param choixFrame La fenêtre de choix actuelle.
+     */
     public GrilleVideActionListener(JFrame choixFrame) {
         this.choixFrame = choixFrame;
     }
 
+    /**
+     * Méthode actionPerformed qui est appelée lorsque l'action est déclenchée (l'utilisateur clique sur le bouton).
+     * 
+     * @param e L'événement d'action associé à cette action.
+     */
     @Override
-    
     public void actionPerformed(ActionEvent e) {
-        int [][] grille = new int [9][9];
+        // Crée une nouvelle grille vide
-        choixFrame.dispose();
+        int[][] grille = new int[9][9];
         Grilles.grilleVide(grille);
+
+        // Ferme la fenêtre de choix actuelle
+        choixFrame.dispose();
+
+        // Affiche une nouvelle fenêtre de modification avec la grille vide
         FenetreModif.fenetreModification(grille);
     }
-    
 }

src/Grilles.java

@@ -0,0 +1,65 @@
+import javax.swing.*;
+import java.io.*;
+
+/**
+ * La classe <code>Grilles</code> contient des méthodes pour manipuler les grilles Sudoku.
+ * 
+ * Elle comporte deux méthodes statiques :
+ * - <code>grilleExiste</code> pour lire une grille à partir d'un fichier existant et stocker ses valeurs dans une grille.
+ * - <code>grilleVide</code> pour initialiser une grille avec des valeurs vides (0).
+ * 
+ * @author Raban Hugo
+ * @version 2.0
+ */
+public class Grilles {
+    /**
+     * Méthode statique pour lire les données d'un fichier et les stocker dans une grille.
+     * 
+     * @param name Le nom du fichier à lire.
+     */
+    public static void grilleExiste(String name) {
+        int valeur[] = new int[9]; // Tableau pour stocker les valeurs lues temporairement
+        int valeurEnFin[][] = new int[9][9]; // Tableau pour stocker les valeurs de la grille
+
+        int valeurActuelle = 0;
+
+        try {
+            FileInputStream fichier = new FileInputStream(name); // Crée un flux pour lire le fichier
+            DataInputStream flux = new DataInputStream(fichier); // Crée un flux de données pour lire les données à partir du flux de fichier
+
+            try {
+                // Lecture des données du fichier
+                for (int i = 0; i < 9; i++) {
+                    valeur[i] = flux.readInt(); // Lecture d'une ligne de valeurs dans le tableau temporaire
+                }
+                flux.close(); // Fermeture du flux de données
+            } catch (IOException e) {
+                System.out.println("Erreur lors de la lecture du fichier."); // Gestion des erreurs de lecture
+            }
+        } catch (FileNotFoundException e) {
+            System.out.println("Fichier non trouvé."); // Gestion des erreurs de fichier non trouvé
+        }
+
+        // Transformation des valeurs lues en tableau 2D pour la grille
+        for (int i = 0; i < 9; i++) {
+            for (int j = 8; j >= 0; j--) {
+                valeurActuelle = valeur[i] % 10; // Extrait le chiffre des unités de la valeur
+                valeur[i] = (valeur[i] - valeurActuelle) / 10; // Supprime le chiffre extrait de la valeur
+                valeurEnFin[i][j] = valeurActuelle; // Stocke la valeur dans la grille
+            }
+        }
+    }
+
+    /**
+     * Méthode statique pour initialiser une grille avec des valeurs vides (0).
+     * 
+     * @param g La grille à initialiser.
+     */
+    public static void grilleVide(int[][] g) {
+        for (int i = 0; i < 9; i++) {
+            for (int j = 0; j < 9; j++) {
+                g[i][j] = 0; // Initialise chaque cellule de la grille avec la valeur 0
+            }
+        }
+    }
+}

src/Lecteur.java

@@ -1,45 +1,49 @@
-import javax.swing.*;
-import java.awt.*;
 import java.io.*;
-import javax.swing.filechooser.FileNameExtensionFilter;
 
-public class Lecteur{
+/**
-	public static void lecture(File name, int [][] g) {
+ * La classe <code>Lecteur</code> est utilisée pour lire les données d'un fichier de grille.
+ * 
+ * Elle comporte une méthode statique <code>lecture</code> qui prend en entrée un fichier et une grille, puis lit les données du fichier pour les stocker dans la grille.
+ * 
+ * Le fichier doit contenir une grille Sudoku sous forme de chiffres, où chaque ligne représente une ligne de la grille et chaque chiffre représente une valeur dans la grille.
+ * 
+ * @author Raban Hugo
+ * @version 5.0
+ */
+public class Lecteur {
+    /**
+     * Méthode statique pour lire les données d'un fichier et les stocker dans une grille.
+     * 
+     * @param fichier Le fichier à lire.
+     * @param grille La grille dans laquelle stocker les données lues.
+     */
+    public static void lecture(File fichier, int[][] grille) {
+        int[] valeurs = new int[9]; // Tableau pour stocker les valeurs lues temporairement
 
-    int valeur[] = new int[9];
+        try {
-    int valeur_en_fin[][]= new int[9][9];
+            FileInputStream fileInputStream = new FileInputStream(fichier); // Crée un flux pour lire le fichier
+            DataInputStream dataInputStream = new DataInputStream(fileInputStream); // Crée un flux de données pour lire les données à partir du flux de fichier
 
-    int valeur_actuelle=0;
+            try {
-
+                // Lecture des données du fichier
-    try{
+                for (int i = 0; i < 9; i++) {
-      FileInputStream fichier = new FileInputStream(name);
+                    valeurs[i] = dataInputStream.readInt(); // Lecture d'une ligne de valeurs dans le tableau temporaire
-      DataInputStream flux = new DataInputStream(fichier);
+                }
-
+                dataInputStream.close(); // Fermeture du flux de données
-      try{
+            } catch (IOException e) {
-        for(int i=0; i<9; i++){
+                System.out.println("Erreur lors de la lecture du fichier."); // Gestion des erreurs de lecture
-          valeur[i]=flux.readInt();
+            }
-          System.out.print(valeur[i]);
+        } catch (FileNotFoundException e) {
+            System.out.println("Fichier non trouvé."); // Gestion des erreurs de fichier non trouvé
+        }
+
+        // Transformation des valeurs lues en tableau 2D pour la grille
+        for (int i = 0; i < 9; i++) {
+            for (int j = 8; j >= 0; j--) {
+                int valeurActuelle = valeurs[i] % 10; // Extrait le chiffre des unités de la valeur
+                valeurs[i] = (valeurs[i] - valeurActuelle) / 10; // Supprime le chiffre extrait de la valeur
+                grille[i][j] = valeurActuelle; // Stocke la valeur dans la grille
+            }
         }
-        flux.close();
-      }catch(IOException e){
-        System.out.println("Lecture fichier impossible");
-      }
-    }catch(FileNotFoundException e){
-      System.out.println("Fichier non trouvé");
     }
-
-    for(int i=0; i<9; i++){
-      for(int j=8; j>=0; j--){
-        valeur_actuelle=valeur[i];
-
-        valeur_actuelle=valeur_actuelle%10;
-        valeur[i]=(valeur[i]-valeur_actuelle)/10;
-
-        valeur_en_fin[i][j]=valeur_actuelle;
-        System.out.print(valeur_actuelle);
-        g[i][j] = valeur_actuelle;
-      }
-      valeur_actuelle=0;
-    }
-  }
 }

src/MainCreation.java

@@ -1,24 +1,31 @@
 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
-import java.io.*;
-import java.io.File;
-import java.io.PrintWriter;
-import java.io.FileWriter;
-import java.io.IOException;
-import javax.swing.JFileChooser;
-import javax.swing.filechooser.FileNameExtensionFilter;
 
+/**
+ * La classe <code>MainCreation</code> est utilisée pour démarrer l'application de création de grille de Sudoku.
+ * 
+ * Elle crée une fenêtre de sélection pour choisir entre une grille vide ou une grille existante.
+ * 
+ * L'utilisateur peut sélectionner l'une des deux options en cliquant sur les boutons correspondants.
+ * 
+ * Les actions des boutons sont gérées par des écouteurs d'événements spécifiques.
+ * 
+ * Elle utilise les classes GrilleVideActionListener et GrilleExisteActionListener pour gérer les actions des boutons.
+ * 
+ * @author Raban Hugo
+ * @version 3.0
+ */
 public class MainCreation {
     public static void main(String[] args) {
-        //Création de la fenetre de selection + choix du dossier
+        // Création de la fenetre de selection + choix du dossier
         JFrame selF = new JFrame("Choix de résolution du Sudoku");
         selF.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         selF.setSize(400, 200);
         selF.setLayout(new BorderLayout());
         selF.setLocationRelativeTo(null);
-        JLabel sel = new JLabel("Quelle grilles souhaitez vous ?");
+        JLabel sel = new JLabel("Quelle grille souhaitez-vous ?");
-        //Création des boutons
+        // Création des boutons
         sel.setHorizontalAlignment(JLabel.CENTER);
         JButton grilleVide = new JButton("Grille vide");
         JButton grilleExiste = new JButton("Grille Existante");
@@ -31,34 +38,8 @@ public class MainCreation {
         selF.add(sel, BorderLayout.NORTH);
         selF.add(boutonsSelect, BorderLayout.CENTER);
         selF.setVisible(true);
-        //Action des bouton
+        // Action des boutons
         grilleVide.addActionListener(new GrilleVideActionListener(selF));
         grilleExiste.addActionListener(new GrilleExisteActionListener(selF));
-        /*grilleVide.addActionListener(new ActionListener() {
-           public void actionPerformed(ActionEvent e) {
-                selF.dispose();
-                Grilles.grilleVide(grille);
-                FenetreModif.fenetreModification(grille);
-            }
-        });*/
-        /* grilleExiste.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                selF.dispose();
-                JFileChooser fileChooser = new JFileChooser();
-
-                FileNameExtensionFilter filter = new FileNameExtensionFilter("File grille","gri");
-                fileChooser.setFileFilter(filter);
-
-                File workingDirectory = new File(System.getProperty("user.dir"));
-                fileChooser.setCurrentDirectory(workingDirectory);
-                JPanel panneau = new JPanel();
-                int valeur_de_retour = fileChooser.showOpenDialog(panneau);
-                if(valeur_de_retour == JFileChooser.APPROVE_OPTION) {
-                    Lecteur.lecture(fileChooser.getSelectedFile(), grille);
-                    FenetreModif.fenetreModification(grille);
-                }
-            }
-        });*/
     }
 }

src/MainJeu.java

@@ -1,9 +1,24 @@
-
+/**
+ * La classe <code>MainJeu</code> est utilisée pour démarrer le programme du jeu.
+ * Elle crée une instance de la classe FenetreChoix et affiche la fenêtre de choix du jeu.
+ * 
+ * @author Dick Adrien
+ * @version 2.0
+ */
 public class MainJeu {
+    /**
+     * La méthode principale qui lance le programme.
+     * 
+     * @param args les arguments de la ligne de commande (non utilisés dans cet exemple)
+     */
     public static void main(String[] args) {
+        // Affiche un message indiquant que le programme principal a démarré.
         System.out.println("Le programme Main a démarré.");
 
+        // Crée une instance de la classe FenetreChoix pour afficher la fenêtre de choix du jeu.
         FenetreChoix fenetreChoix = new FenetreChoix();
+
+        // Appelle la méthode pour afficher la fenêtre de choix du jeu.
         fenetreChoix.afficher();
     }
 }

src/ManuelActionListener.java

@@ -2,30 +2,55 @@ import javax.swing.*;
 import java.awt.event.*;
 import java.io.File;
 
+/**
+ * La classe <code>ManuelActionListener</code> est un écouteur d'événements utilisé pour gérer l'action
+ * lorsqu'on clique sur le bouton "Manuel" dans la fenêtre de choix.
+ * Elle permet de choisir un fichier contenant une grille de Sudoku et d'afficher la grille dans une nouvelle fenêtre
+ * pour que l'utilisateur puisse la résoudre manuellement.
+ * 
+ * Elle implémente l'interface ActionListener pour écouter les événements liés au bouton.
+ * 
+ * @author Dick Adrien
+ * @version 2.0
+ */
 public class ManuelActionListener implements ActionListener {
     private JFrame choixFrame;
 
+    /**
+     * Constructeur de la classe ManuelActionListener.
+     * 
+     * @param choixFrame La fenêtre de choix du Sudoku.
+     */
     public ManuelActionListener(JFrame choixFrame) {
         this.choixFrame = choixFrame;
     }
 
+    /**
+     * Méthode appelée lorsque l'action associée à ce listener est déclenchée, c'est-à-dire lorsque le bouton
+     * "Manuel" est cliqué.
+     * 
+     * @param e L'événement associé à l'action.
+     */
     @Override
     public void actionPerformed(ActionEvent e) {
+        // Ferme la fenêtre de choix du Sudoku.
         choixFrame.dispose();
 
-        int[][] grille = new int[9][9]; // Création d'une grille vide
+        // Crée une grille vide de Sudoku.
+        int[][] grille = new int[9][9];
 
-        // Ouverture du sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille
+        // Ouvre un sélecteur de fichiers pour que l'utilisateur choisisse un fichier de grille.
         JFileChooser fileChooser = new JFileChooser();
         int returnValue = fileChooser.showOpenDialog(null);
 
+        // Vérifie si l'utilisateur a sélectionné un fichier.
         if (returnValue == JFileChooser.APPROVE_OPTION) {
             File selectedFile = fileChooser.getSelectedFile();
 
-            // Lecture de la grille à partir du fichier sélectionné
+            // Lit la grille à partir du fichier sélectionné.
             Lecteur.lecture(selectedFile, grille);
 
-            // Affichage de la grille dans la fenêtre principale en mode manuel
+            // Affiche la grille dans la fenêtre principale en mode manuel.
             FenetrePrincipale fenetrePrincipale = new FenetrePrincipale();
             fenetrePrincipale.afficher(false, grille);
         }

src/Register.java

@@ -3,36 +3,48 @@ import java.awt.*;
 import java.io.*;
 import javax.swing.filechooser.FileNameExtensionFilter;
 
+/**
+ * La classe <code>Register</code> est utilisée pour enregistrer une grille Sudoku dans un fichier.
+ * Elle comporte une méthode statique <code>sauvegarde</code> qui prend en paramètre un fichier et une grille Sudoku, puis enregistre la grille dans le fichier.
+ * 
+ * @author Raban Hugo
+ * @version 3.0
+ */
 public class Register{
-	public static void sauvegarde(File name, int [][] g){
+    /**
-		int val[] = new int[9];
+     * Méthode statique pour enregistrer une grille Sudoku dans un fichier.
+     * 
+     * @param name Le fichier dans lequel enregistrer la grille.
+     * @param g La grille Sudoku à enregistrer.
+     */
+    public static void sauvegarde(File name, int [][] g){
+        int val[] = new int[9]; // Tableau pour stocker temporairement les valeurs à écrire dans le fichier
 
-  		int actuVal=0;
+        int actuVal=0;
-  		int v=0;
+        int v=0;
 
-  		try{
+        try{
-    		FileOutputStream fichier = new FileOutputStream(name);
+            FileOutputStream fichier = new FileOutputStream(name); // Crée un flux de sortie vers le fichier spécifié
-    		DataOutputStream flux = new DataOutputStream(fichier);
+            DataOutputStream flux = new DataOutputStream(fichier); // Utilise un flux de données pour écrire dans le fichier
 
-    		try{
+            try{
-
+                // Parcourt la grille et écrit chaque valeur dans le fichier
-
+                for(int i=0; i<9; i++){
-      			for(int i=0; i<9; i++){
+                    for(int j=0; j<9; j++){
-        			for(int j=0; j<9; j++){
+                        actuVal = g[i][j];
-          				actuVal = g[i][j];
+                        v = (v*10) - actuVal;
-          				v = (v*10) - actuVal;
+                    }
-        			}
+                    flux.writeInt(-v); // Écrit la valeur dans le fichier (avec un signe négatif pour distinguer les valeurs positives)
-        			flux.writeInt(-v);
+                    v=0; // Réinitialise la valeur temporaire
-        			v=0;
+                    actuVal=0;
-        			actuVal=0;
+                }
-      			}
+                flux.close(); // Ferme le flux de sortie
-      			flux.close();
+            }catch(IOException e){
-    		}catch(IOException e){
+                System.out.println("Lecture fichier imposible"); // Affiche un message d'erreur en cas de problème lors de l'écriture dans le fichier
-      			System.out.println("Lecture fichier imposible");
+            }
-    		}
+        }catch(FileNotFoundException e){
-  		}catch(FileNotFoundException e){
+            System.out.println("Fichier non trouvé"); // Affiche un message d'erreur si le fichier spécifié n'est pas trouvé
-    		System.out.println("Fichier non trouvé");
+        }
-  		}
+        System.out.print("Fichier enregistré"); // Affiche un message de confirmation dans la console une fois que l'enregistrement est terminé
-      System.out.print("Fichier enregistrer");
+    }
-	}
 }

src/Reinitialiser.java

@@ -1,22 +1,41 @@
 import javax.swing.*;
 import java.awt.event.*;
 
+/**
+ * La classe <code>Reinitialiser</code> est un écouteur d'événements utilisé pour réinitialiser la grille Sudoku.
+ * Elle implémente l'interface ActionListener.
+ * 
+ * @author Dick Adrien
+ * @version 1.0
+ */
 public class Reinitialiser implements ActionListener {
-    private int[][] grille;
+    private int[][] grille; // La grille Sudoku
-    private SaisieGrille panneauSaisie;
+    private SaisieGrille panneauSaisie; // Le panneau de saisie de la grille
 
+    /**
+     * Constructeur de la classe Reinitialiser.
+     * 
+     * @param grille La grille Sudoku à réinitialiser.
+     * @param panneauSaisie Le panneau de saisie associé à la grille.
+     */
     public Reinitialiser(int[][] grille, SaisieGrille panneauSaisie) {
         this.grille = grille;
         this.panneauSaisie = panneauSaisie;
     }
 
+    /**
+     * Méthode appelée lorsqu'un événement d'action est déclenché, en l'occurrence lorsque le bouton de réinitialisation est cliqué.
+     * Cette méthode réinitialise la grille en copiant la grille initiale et redessine le panneau de saisie.
+     * 
+     * @param e L'événement d'action.
+     */
     @Override
     public void actionPerformed(ActionEvent e) {
         // Réinitialiser la grille en copiant la grille initiale
         for (int i = 0; i < grille.length; i++) {
             System.arraycopy(panneauSaisie.getGrilleInitiale()[i], 0, grille[i], 0, grille[i].length);
         }
-        // Redessiner le panneau
+        // Redessiner le panneau de saisie
         panneauSaisie.repaint();
     }
 }

src/ReinitialiserActionListener.java

@@ -1,19 +1,37 @@
-
 import javax.swing.*;
 import java.awt.event.*;
 
-
+/**
+ * La classe <code>ReinitialiserActionListener</code> est un écouteur d'événements utilisé pour gérer les actions associées à la réinitialisation de la grille Sudoku.
+ * Elle implémente l'interface ActionListener.
+ * 
+ * @author Dick Adrien
+ * @version 1.0
+ */
 public class ReinitialiserActionListener implements ActionListener {
-    private int[][] grille;
+    private int[][] grille; // La grille Sudoku
-    private SaisieGrille saisieGrille;
+    private SaisieGrille saisieGrille; // Le panneau de saisie de la grille
 
+    /**
+     * Constructeur de la classe ReinitialiserActionListener.
+     * 
+     * @param grille La grille Sudoku à réinitialiser.
+     * @param saisieGrille Le panneau de saisie associé à la grille.
+     */
     public ReinitialiserActionListener(int[][] grille, SaisieGrille saisieGrille) {
         this.grille = grille;
         this.saisieGrille = saisieGrille;
     }
 
+    /**
+     * Méthode appelée lorsqu'un événement d'action est déclenché, en l'occurrence lorsque le bouton de réinitialisation est cliqué.
+     * Cette méthode crée une instance de la classe Reinitialiser et appelle sa méthode actionPerformed.
+     * 
+     * @param e L'événement d'action.
+     */
     @Override
     public void actionPerformed(ActionEvent e) {
+        // Créer une instance de Reinitialiser et appeler sa méthode actionPerformed
         Reinitialiser reinitialiser = new Reinitialiser(grille, saisieGrille);
         reinitialiser.actionPerformed(e);
     }

src/Resolveur.java

@@ -1,4 +1,17 @@
+/**
+ * La classe <code>Resolveur</code> est utilisée pour résoudre une grille Sudoku.
+ * Elle comporte une méthode statique <code>resoudreSudoku</code> qui prend en paramètre une grille Sudoku à résoudre.
+ * 
+ * @author Dick Adrien
+ * @version 1.0
+ */
 public class Resolveur {
+    /**
+     * Méthode statique pour résoudre une grille Sudoku.
+     * 
+     * @param grille La grille Sudoku à résoudre.
+     * @return true si la grille est résolue avec succès, false sinon.
+     */
     public static boolean resoudreSudoku(int[][] grille) {
         int row = -1;
         int col = -1;
@@ -41,7 +54,15 @@ public class Resolveur {
         return false;
     }
 
-    // Vérifie si un nombre peut être placé dans une cellule spécifique
+    /**
+     * Vérifie si un nombre peut être placé dans une cellule spécifique de la grille.
+     * 
+     * @param grille La grille Sudoku.
+     * @param row L'indice de ligne de la cellule.
+     * @param col L'indice de colonne de la cellule.
+     * @param num Le nombre à vérifier.
+     * @return true si le nombre peut être placé dans la cellule, false sinon.
+     */
     private static boolean estCoupValide(int[][] grille, int row, int col, int num) {
         // Vérifie la ligne
         for (int x = 0; x < 9; x++) {

src/SaisieGrille.java

@@ -2,6 +2,18 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
 
+/**
+ * La classe <code>SaisieGrille</code> est un composant graphique utilisé pour afficher et manipuler une grille de Sudoku.
+ * Elle permet à l'utilisateur de sélectionner des cellules et d'y entrer des chiffres.
+ * Elle fournit également des méthodes pour valider les chiffres entrés et vérifier si la grille est complète.
+ * 
+ * Elle étend JPanel pour être utilisée comme composant graphique dans une fenêtre Swing.
+ * 
+ * Elle utilise un gestionnaire d'événements de souris pour gérer la sélection des cellules.
+ * 
+ * @author Dick Adrien
+ * @version 8.0
+ */
 public class SaisieGrille extends JPanel {
     private static final int TAILLE_GRILLE = 3;
     private static final int TAILLE_REGION = 3;
@@ -11,6 +23,11 @@ public class SaisieGrille extends JPanel {
     private int ligneSelectionnee = -1;
     private int colonneSelectionnee = -1;
 
+    /**
+     * Constructeur de la classe SaisieGrille.
+     * 
+     * @param grille La grille de Sudoku à afficher et à manipuler.
+     */
     public SaisieGrille(int[][] grille) {
         this.grille = grille;
         this.grilleInitiale = new int[grille.length][grille[0].length];
@@ -22,9 +39,12 @@ public class SaisieGrille extends JPanel {
         setPreferredSize(new Dimension(TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE, TAILLE_GRILLE * TAILLE_REGION * TAILLE_CELLULE));
         setFocusable(true);
 
+        // Ajoute un écouteur d'événements de souris pour gérer la sélection des cellules.
         addMouseListener(new CaseMouseListener(this));
     }
 
+    // Méthodes d'accès aux attributs
+
     public int[][] getGrilleInitiale() {
         return grilleInitiale;
     }
@@ -61,27 +81,29 @@ public class SaisieGrille extends JPanel {
         return grille;
     }
 
+    // Méthodes de validation et de vérification de la grille
+
     public boolean validerChiffre(int ligne, int colonne, int chiffre) {
-        // Vérifier si le chiffre est entre 1 et 9
+        // Vérifie si le chiffre est entre 1 et 9
         if (chiffre < 1 || chiffre > 9) {
             return false;
         }
 
-        // Vérifier la ligne
+        // Vérifie la ligne
         for (int j = 0; j < grille.length; j++) {
             if (grille[ligne][j] == chiffre && j != colonne) {
                 return false;
             }
         }
 
-        // Vérifier la colonne
+        // Vérifie la colonne
         for (int i = 0; i < grille.length; i++) {
             if (grille[i][colonne] == chiffre && i != ligne) {
                 return false;
             }
         }
 
-        // Vérifier la région
+        // Vérifie la région
         int regionX = colonne / TAILLE_REGION;
         int regionY = ligne / TAILLE_REGION;
         for (int i = regionY * TAILLE_REGION; i < (regionY + 1) * TAILLE_REGION; i++) {
@@ -92,7 +114,7 @@ public class SaisieGrille extends JPanel {
             }
         }
 
-        // Vérifier les valeurs incertaines dans la cellule
+        // Vérifie les valeurs incertaines dans la cellule
         int valeursIncertaines = grille[ligne][colonne];
         for (int i = 0; i < 4; i++) {
             int valeur = (valeursIncertaines >> (i * 4)) & 0xF;
@@ -115,12 +137,16 @@ public class SaisieGrille extends JPanel {
         return true;
     }
 
+    // Méthode de dessin de la grille
+
     @Override
     protected void paintComponent(Graphics g) {
         super.paintComponent(g);
         GrillePainter.dessinerGrille(g, this);
     }
 
+    // Méthode pour afficher un message de réussite
+
     public void afficherBravo() {
         JOptionPane.showMessageDialog(this, "Bravo ! La grille est complétée avec succès.");
     }