petite correction + fin des commentaires

Sudoku/Grille.java

@@ -2,33 +2,45 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.awt.event.FocusListener;
 import java.awt.event.FocusEvent;
 import java.awt.event.FocusAdapter;
 import java.io.*;
-import javax.swing.border.Border;
-import javax.swing.text.PlainDocument;
-import javax.swing.text.AttributeSet;
-import javax.swing.text.BadLocationException;
 
 
-
+/**
-public class grille extends JComponent{
+ * La classe Grille est une composante Swing pour représenter une grille de Sudoku.
+ *
+ * @author Julian GALLEGO
+ * @author Wilfried BRIGITTE 
+ */
+public class Grille extends JComponent {
     private static JLabel etat_exportation = new JLabel();
 
-	/*tableau de valeurs de la grille de sudoku*/
+    /**
+     * Tableau des valeurs de la grille de Sudoku.
+     */
     public static int[][] grid_values = null;
 
-	/*Panneau pour la grille */
+    /**
+     * Panneau pour la grille.
+     */
     public static JPanel place_grille = new JPanel();
 
-	/*variable de la fenetre*/
+    /**
-
+     * Fenêtre de l'application.
+     */
     public static JFrame fenetre = new JFrame();
 
-	/*fonction pour afficher graphiquement la grille*/
+    /**
+     * Affiche graphiquement la grille de Sudoku.
+     *
+     * @param grille           La grille de Sudoku à afficher.
+     * @param editable         Indique si la grille est éditable.
+     * @param resolutionManuel Indique si la résolution est manuelle.
+     * @param duree            La durée de résolution (en nanosecondes).
+     */
 	public static void AfficherGrille (int[][] grille, boolean editable, boolean resolutionManuel, long duree) {
-		/*paramètre de base de la fenetre*/
+		//paramètre de base de la fenetre
 		fenetre.setSize(900, 950);
 		fenetre.setResizable(false);
 	    fenetre.setLocationRelativeTo(null);
@@ -36,13 +48,13 @@ public class grille extends JComponent{
 
 		place_grille.setSize(900,900);
 		
-	    /*creation grille*/
+	    //creation grille
 	    GridLayout gestionnaire = new GridLayout(9,9,-2,-2);
 		place_grille.setLayout(gestionnaire);
 
 		JTextField[][] case_editable = null;
 		case_editable = new JTextField[9][9];
-		/*si la grille peut etre entierement éditée (dans le cas du programme1*/
+		//si la grille peut etre entierement éditée (dans le cas du programme1
 		if(editable){
 
 			for (int ligne = 0; ligne < 9; ligne++) {
@@ -111,12 +123,12 @@ public class grille extends JComponent{
 		    }
 		}
 
-		/*bouton(s) grille(s)*/
+		//bouton(s) grille(s)
 		JButton verifier = null;
 		JButton exporter = null;
 		JPanel bouton_grille = new JPanel();
 
-		/*affichage des boutons en fonction du programme lancé*/
+		//affichage des boutons en fonction du programme lancé
 		if(editable){
 			bouton_grille.add(etat_exportation);
 			exporter = new JButton("exporter");
@@ -136,10 +148,10 @@ public class grille extends JComponent{
 		fenetre.add(bouton_grille,BorderLayout.SOUTH);
 		fenetre.add(place_grille, BorderLayout.CENTER);
 
-		/*affichage fenetre*/
+		//affichage fenetre
 		fenetre.setVisible(true);
 
-		/*verification si un chiffre peut être placé à un endroit*/
+		//verification si un chiffre peut être placé à un endroit
 		for (int ligne = 0; ligne < 9; ligne++) {
 		    for (int col = 0; col < 9; col++) {
 		        final int finalLigne = ligne;
@@ -173,17 +185,27 @@ public class grille extends JComponent{
 		}
 
 
-		/*événement des boutons*/
+		//événement des boutons
-		if (verifier != null) { /* Vérification pour s'assurer que verifier a été initialisé */
+		if (verifier != null) { // Vérification pour s'assurer que verifier a été initialisé 
 		    verifier.addActionListener(new ActionListener() {
+				/**
+				 * verifie votre solution en appuyant sur le bouton verifier
+				 * 
+				 * @param verifier L'évènement d'action.
+				 */
 		        public void actionPerformed(ActionEvent verifier) {
 		           	VerificationGrilleFini(); 
 		        }
 		    });
 		}
 
-		if (exporter != null) { /* Vérification pour s'assurer que exporter a été initialisé */
+		if (exporter != null) { // Vérification pour s'assurer que exporter a été initialisé 
 		    exporter.addActionListener(new ActionListener() {
+				/**
+				 * permet d'exporter votre grille édité.
+				 * 
+				 * @param exporeter
+				 */
 		        public void actionPerformed(ActionEvent exporter) {        	
 		        	if (!(resolveurGrille.resoudreSudoku(GrilleActuelle()))){
 		        		etat_exportation.setHorizontalAlignment(SwingConstants.LEFT);
@@ -199,7 +221,12 @@ public class grille extends JComponent{
 	} 
 
 
-	/*fonction pour passer d'un fichier.gri à un tableau de valeur*/
+	/**
+	 * Charge une grille à partir d'un fichier.
+	 *
+	 * @param cheminFichier Le chemin du fichier contenant la grille.
+	 * @return Un tableau représentant la grille.
+	 */
 	public static int[][] ChargerGrille(String cheminFichier){
 		try {
 			FileInputStream fs = new FileInputStream(cheminFichier);
@@ -236,7 +263,11 @@ public class grille extends JComponent{
 		return null;
 	}
 
-	/*fonction pour exporter une grille en fichier .gri*/
+	/**
+	 * Exporte une grille vers un fichier.
+	 *
+	 * @param grille La grille à exporter.
+	 */
 	public static void ExporterGrille(int[][] grille){
 
 		try {
@@ -270,7 +301,11 @@ public class grille extends JComponent{
 		}
 	}
 
-	/*fonction pour récupérer les valeurs ACTUELLES de la grille est les placer dans un tableau*/
+	/**
+	 * Récupère les valeurs actuelles de la grille et les place dans un tableau.
+	 *
+	 * @return Un tableau représentant la grille actuelle.
+	 */
 	public static int[][] GrilleActuelle(){
 		int[][] grilleActuelle = new int[9][9];
 
@@ -291,7 +326,11 @@ public class grille extends JComponent{
 	    return grilleActuelle;
 	}
 
-	/*fonction pour verifier si la grille actuelle correspond à la grille trouvé en solution*/
+	/**
+	 * Vérifie si la grille actuelle correspond à la grille résolue.
+	 *
+	 * @return true si la grille est résolue correctement, sinon false.
+	 */
 	public static boolean VerificationGrilleFini(){
 		int[][] soluce_de_la_grille = new int[9][9];
 		soluce_de_la_grille = resolveurGrille.resoudreGrille(grid_values);

Sudoku/JTextFieldCharLimit.java

@@ -2,6 +2,13 @@ import javax.swing.text.PlainDocument;
 import javax.swing.text.AttributeSet;
 import javax.swing.text.BadLocationException;
 
+/**
+ * Cette classe limite le nombre de caractères à 4 et limite les caractères a des chiffres 
+ * pour les JTextField
+ * 
+ * @author Julian GALLEGO
+ * @author Wilfried BRIGITTE
+ */
 public class JTextFieldCharLimit extends PlainDocument 
 {
    private int max;
@@ -9,6 +16,15 @@ public class JTextFieldCharLimit extends PlainDocument
       super();
       this.max = max;
    }
+
+   /**
+    * Vérifie si le texte répond aux exigences 
+    * 
+    * @param offset L'offset auquel insérer le texte.
+    * @param text   La chaîne de texte à insérer.
+    * @param attr   Les attributs à appliquer au texte inséré.
+    * @throws BadLocationException Si l'offset est invalide.
+    */
    public void insertString(int offset, String text, AttributeSet attr) throws BadLocationException {
       if (text == null){
          return;
@@ -17,7 +33,7 @@ public class JTextFieldCharLimit extends PlainDocument
       sb.append(getText(0, getLength())); 
       sb.insert(offset, text);
 
-      /* Vérifier si le texte ne contient que des chiffres de 1 à 9 et si il ne depasse pas 4 caractères */
+      // Vérifier si le texte ne contient que des chiffres de 1 à 9 et si il ne depasse pas 4 caractères 
       if (sb.length() <= max && sb.toString().matches("[1-9]*")) {
          super.insertString(offset, text, attr);
       }

Sudoku/JeuFini.java

@@ -2,8 +2,14 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
 
+/**
+ * La classe JeuFini affiche une fenêtre de fin de jeu pour un Sudoku résolu.
+ * 
+ * @author Julian GALLEGO
+ * @author Wilfried BRIGITTE
+ */
 public class JeuFini {
-	/*afficher la fenetre de fin*/
+	// Créer une nouvelle fenêtre
 	public static void JeuFini(){
 		JFrame fenetre = new JFrame();
         fenetre.setSize(500, 200);
@@ -12,23 +18,29 @@ public class JeuFini {
         fenetre.setLocationRelativeTo(null);
         fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
+        // Utiliser un gestionnaire de disposition pour organiser les composants
         GridLayout gestionnaire = new GridLayout(2,1);
         fenetre.setLayout(gestionnaire);
 
+        // Ajouter un texte à la fenêtre
         JLabel titre = new JLabel("Bravo vous avez résolu le Sudoku");
         titre.setHorizontalAlignment(JLabel.CENTER);
         titre.setFont(new Font("Arial", Font.PLAIN, 30));
         fenetre.add(titre, BorderLayout.CENTER);
 
+        // Ajouter un bouton "Quitter"
         JPanel ligne2 = new JPanel();
         JButton quitter = new JButton("Quitter");
         ligne2.add(quitter);
         fenetre.add(ligne2, BorderLayout.CENTER);
 
+        // Rendre la fenêtre visible
         fenetre.setVisible(true);
 
+        // Définir un évènement pour le bouton "Quitter"
         quitter.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
+                // Quitter l'application lorsque le bouton "Quitter" est cliqué
             	System.exit(0);
             }
         });

Sudoku/Makefile

@@ -14,13 +14,13 @@ mainProgramme2.class : mainProgramme2.java menuProgramme2.class
 mainProgramme1.class : mainProgramme1.java menuProgramme1.class
 	${JC} ${JCFLAGS} mainProgramme1.java
 
-grille.class : grille.java resolveurGrille.class JTextFieldCharLimit.class JeuFini.class
+Grille.class : Grille.java resolveurGrille.class JTextFieldCharLimit.class JeuFini.class
-	${JC} ${JCFLAGS} grille.java
+	${JC} ${JCFLAGS} Grille.java
 
-menuProgramme2.class : menuProgramme2.java resolveurGrille.class grille.class
+menuProgramme2.class : menuProgramme2.java resolveurGrille.class Grille.class
 	${JC} ${JCFLAGS} menuProgramme2.java
 
-menuProgramme1.class : menuProgramme1.java resolveurGrille.class grille.class
+menuProgramme1.class : menuProgramme1.java resolveurGrille.class Grille.class
 	${JC} ${JCFLAGS} menuProgramme1.java
 
 resolveurGrille.class : resolveurGrille.java
@@ -34,10 +34,10 @@ JeuFini.class : JeuFini.java
 
 ### REGLES OPTIONNELLES ###
 
-run1 : mainProgramme1.class
+editeur : mainProgramme1.class
 	${JVM} ${JVMFLAGS} mainProgramme1
 
-run2 : mainProgramme2.class
+resolveur : mainProgramme2.class
 	${JVM} ${JVMFLAGS} mainProgramme2
 	
 clean :

Sudoku/mainProgramme1.java

@@ -1,5 +1,16 @@
 
+/**
+ * Classe principale pour exécuter le programme 1.
+ * 
+ * @author Julian GALLEGO
+ * @author Wilfried BRIGITTE
+ */
 public class mainProgramme1 {
+    /**
+     * Méthode principale pour exécuter le programme 1.
+	 * 
+     * @param args Les arguments de la ligne de commande.
+     */
     public static void main(String[] args) {
         menuProgramme1.menuProgramme1();
     }

Sudoku/mainProgramme2.java

@@ -1,5 +1,15 @@
-
+/**
+ * Classe principale pour exécuter le programme 2.
+ * 
+ * @author Julian GALLEGO
+ * @author Wilfried BRIGITTE
+ */
 public class mainProgramme2 {
+    /**
+     * Méthode principale pour exécuter le programme 2.
+	 * 
+     * @param args Les arguments de la ligne de commande.
+     */
     public static void main(String[] args) {
         menuProgramme2.menuProgramme2();
     }

Sudoku/menuProgramme1.java

@@ -3,13 +3,22 @@ import java.awt.*;
 import java.awt.event.*;
 import java.io.*;
 
-
+/**
+ * Menu pour le Programme 1 (Créateur de Sudoku).
+ * 
+ * @author Julian GALLEGO
+ * @author Wilfried BRIGITTE
+ */
 public class menuProgramme1 {
 
     private static String cheminFichier = null;
 
+    /**
+     * Affiche le menu du Programme 1 qui permet créer et d'editer une grille .
+     */
     public static void menuProgramme1() {
-        /*fenetre*/
+
+        // création de la fenêtre
         JFrame fenetre = new JFrame();
         fenetre.setSize(500, 200);
         fenetre.setTitle("Sudoku Creator (By Wilfried BRIGITTE & Julian GALLEGO)");
@@ -19,8 +28,7 @@ public class menuProgramme1 {
         GridLayout gestionnaire = new GridLayout(4,1);
         fenetre.setLayout(gestionnaire);
 
-        /*composants G*/
+        //composants graphique
-
         JLabel titre = new JLabel("Sudoku Creator");
         titre.setHorizontalAlignment(JLabel.CENTER);
         titre.setFont(new Font("Arial", Font.PLAIN, 25));
@@ -47,11 +55,16 @@ public class menuProgramme1 {
         InfoLogiciel.setFont(new Font("Arial", Font.PLAIN, 11));
         fenetre.add(InfoLogiciel);
 
-        /*affichage*/
+        //affichage de la fenêtre
         fenetre.setVisible(true);
 
-        /*evenements*/
+        //Evenements
         ouvrir.addActionListener(new ActionListener() {
+            /**
+             * Ouvre un sélecteur de fichiers pour choisir un fichier de grille à charger.
+             *
+             * @param e L'événement d'action.
+             */
             public void actionPerformed(ActionEvent e) {
                 try {
                     JFileChooser filechooser = new JFileChooser();
@@ -71,6 +84,11 @@ public class menuProgramme1 {
         });
 
         editerGrilleVierge.addActionListener(new ActionListener(){
+            /**
+             * Crée une grille vide et l'affiche pour l'édition.
+             *
+             * @param e4 L'événement d'action.
+             */
             public void actionPerformed(ActionEvent e4){
                 int[][] grille_vide = null;
                 grille_vide = new int[9][9];
@@ -82,23 +100,33 @@ public class menuProgramme1 {
                 }
 
                 fenetre.dispose();
-                grille.AfficherGrille(grille_vide, true, false, 0);
+                Grille.AfficherGrille(grille_vide, true, false, 0);
             }
         });
 
         editerGrilleSelectionner.addActionListener(new ActionListener(){
+            /**
+             * Charge une grille à partir du fichier sélectionné et l'affiche pour l'édition.
+             *
+             * @param e4 L'événement d'action.
+             */
             public void actionPerformed(ActionEvent e4){
                 if (cheminFichier == null){
                     InfoLogiciel.setText(" Info : Erreur : Veuillez selectionner un fichier .gri");
                     InfoLogiciel.setForeground(Color.RED);
                 }else{
                     fenetre.dispose();
-                    grille.AfficherGrille(grille.ChargerGrille(cheminFichier), true, false, 0);
+                    Grille.AfficherGrille(Grille.ChargerGrille(cheminFichier), true, false, 0);
                 }
             }
         });    
 
         quitter.addActionListener(new ActionListener() {
+            /**
+             * Ferme l'application.
+             *
+             * @param e3 L'événement d'action.
+             */
             public void actionPerformed(ActionEvent e3) {
             	System.exit(0);
             }

Sudoku/menuProgramme2.java

@@ -3,14 +3,29 @@ import java.awt.*;
 import java.awt.event.*;
 import java.io.*;
 
-
+/**
+ * Menu pour le Programme 2 (Résolveur de Sudoku).
+ * 
+ * @author Julian GALLEGO
+ * @author Wilfried BRIGITTE
+ */
 public class menuProgramme2 {
 
+    /**
+     * designe le chemin du fichier
+     */
     private static String cheminFichier = null;
+    /**
+     * permet de savoir si l'utilisateur veut resoudre le sudoku lui même 
+     * ou si il veut voir la solution
+     */
     private static boolean ResolutionManuel = true;
 
+    /**
+     * Affiche le menu du Programme 2.
+     */
     public static void menuProgramme2() {
-        /*fenetre*/
+        //Création de la fenêtre
         JFrame fenetre = new JFrame();
         fenetre.setSize(500, 250);
         fenetre.setTitle("Sudoku Resolver (By Wilfried BRIGITTE & Julian GALLEGO)");
@@ -20,8 +35,7 @@ public class menuProgramme2 {
         GridLayout gestionnaire = new GridLayout(5,1);
         fenetre.setLayout(gestionnaire);
 
-        /*composants G*/
+        //Composants graphique 
-
         JLabel titre = new JLabel("Sudoku Resolver");
         titre.setHorizontalAlignment(JLabel.CENTER);
         titre.setFont(new Font("Arial", Font.PLAIN, 25));
@@ -58,11 +72,16 @@ public class menuProgramme2 {
         InfoLogiciel.setFont(new Font("Arial", Font.PLAIN, 11));
         fenetre.add(InfoLogiciel);
 
-        /*affichage*/
+        //Affichage de la fenêtre
         fenetre.setVisible(true);
 
         /*evenements*/
         ouvrir.addActionListener(new ActionListener() {
+            /**
+             * Ouvre un sélecteur de fichiers pour choisir un fichier de grille.
+             *
+             * @param e L'événement d'action.
+             */
             public void actionPerformed(ActionEvent e) {
                 try {
                     JFileChooser filechooser = new JFileChooser();
@@ -82,19 +101,24 @@ public class menuProgramme2 {
         });
 
         lancer.addActionListener(new ActionListener() {
+             /**
+             * Lance la résolution du Sudoku en fonction du mode choisi.
+             *
+             * @param e2 L'événement d'action.
+             */
             public void actionPerformed(ActionEvent e2) {
             	if(cheminFichier != null){
                     if (ResolutionManuel == true) {
 	            	   fenetre.dispose();
-                       grille.AfficherGrille(grille.ChargerGrille(cheminFichier),false, true, 0);
+                       Grille.AfficherGrille(Grille.ChargerGrille(cheminFichier),false, true, 0);
                     } else {
                         fenetre.dispose();
                         long debut = System.nanoTime();
                         int[][] grille_resolue = new int[9][9];
-                        grille_resolue = resolveurGrille.resoudreGrille(grille.ChargerGrille(cheminFichier));
+                        grille_resolue = resolveurGrille.resoudreGrille(Grille.ChargerGrille(cheminFichier));
                         long fin = System.nanoTime();
                         long duree = fin - debut;
-                        grille.AfficherGrille(grille_resolue,false, false, duree);
+                        Grille.AfficherGrille(grille_resolue,false, false, duree);
                     }
                 } else {
                 	InfoLogiciel.setText(" Info : Erreur : Veuillez selectionner un fichier .gri");
@@ -104,12 +128,22 @@ public class menuProgramme2 {
         });
 
         quitter.addActionListener(new ActionListener() {
+             /**
+             * Ferme l'application.
+             *
+             * @param e3 L'événement d'action.
+             */
             public void actionPerformed(ActionEvent e3) {
             	System.exit(0);
             }
         });
 
         manuel.addActionListener(new ActionListener() {
+             /**
+             * Définit le mode de résolution manuel.
+             *
+             * @param e1 L'événement d'action.
+             */
             @Override
             public void actionPerformed(ActionEvent e1) {
                 ResolutionManuel = true;
@@ -117,6 +151,11 @@ public class menuProgramme2 {
         });
         
         auto.addActionListener(new ActionListener() {
+             /**
+             * Définit le mode de résolution automatique.
+             *
+             * @param e L'événement d'action.
+             */
             @Override
             public void actionPerformed(ActionEvent e) {
                 ResolutionManuel = false;

Sudoku/resolveurGrille.java

@@ -1,29 +1,48 @@
 import java.util.Arrays;
 
+/**
+ * Classe pour résoudre une grille de Sudoku.
+ * 
+ * @author Julian GALLEGO
+ * @author Wilfried BRIGITTE
+ */
 public class resolveurGrille {
 
     private static int[][] solution = new int[9][9];
     private static boolean stop = false;
+
+    /**
+     * Résout une grille de Sudoku.
+     *
+     * @param grille La grille à résoudre.
+     * @return La grille résolue.
+     */
     public static int[][] resoudreGrille(int[][] grille) {
-        /*remise à zéro de la solution*/
+        // Remise à zéro de la solution
         for (int i = 0; i < 9; i++) {
             for (int j = 0; j < 9; j++) {
                 solution[i][j] = 0;
             }
         }
 
-        /* Réinitialiser la valeur de stop à chaque début de résolution*/
+        // Réinitialiser la valeur de stop à chaque début de résolution
         resoudreSudoku(grille);
         return solution;
     }
 
+    /**
+     * Résout une grille de Sudoku.
+     *
+     * @param grille La grille à résoudre.
+     * @return true si une solution a été trouvée, sinon false.
+     */
     public static boolean resoudreSudoku(int[][] grille) {
-        /*parcourage la grille*/
+        //Parcours la grille
         stop = false;
         for (int row = 0; row < 9; row++) {
             for (int col = 0; col < 9; col++) {
                 if (grille[row][col] == 0) {
-                    /*essayer les chiffres de 1 a 9 pour la case vide*/
+                    //essayer les chiffres de 1 a 9 pour la case vide
                     for (int num = 1; num <= 9; num++) {
                         if (isValid(grille, row, col, num)) {
                             grille[row][col] = num;
@@ -31,37 +50,45 @@ public class resolveurGrille {
                             if (stop) {
                                 return true;
                             }
-                            grille[row][col] = 0; /*réinitialiser la case si la solution n'est pas trouvée*/
+                            grille[row][col] = 0; //réinitialiser la case si la solution n'est pas trouvée
                         }
                     }
-                    return false; /* Si aucune solution trouvée à cette étape on s'arrêtee*/
+                    return false; //Si aucune solution trouvée à cette étape on s'arrête
                 }
             }
         }
 
-        /*copier l a grille résolue dans la solution*/
+        //copier l a grille résolue dans la solution
         for (int i = 0; i < 9; i++) {
             System.arraycopy(grille[i], 0, solution[i], 0, 9);
         }
         return stop = true;
     }
 
-    /*Méthode pour vérifier la validité d'un chiffre dans une case donnée*/
+    /**
+     * Vérifie si un chiffre est valide dans une case donnée.
+     *
+     * @param grille La grille de Sudoku.
+     * @param row    L'indice de ligne de la case.
+     * @param col    L'indice de colonne de la case.
+     * @param num    Le chiffre à vérifier.
+     * @return true si le chiffre est valide, sinon false.
+     */
     public static boolean isValid(int[][] grille, int row, int col, int num) {
-        /*Vérifier la ligne*/
+        //Vérifier la ligne
         for (int x = 0; x < 9; x++) {
             if (grille[row][x] == num) {                       
                     return false;
             }
         }
-        /*Vérifier la colonne*/
+        //Vérifier la colonne
         for (int x = 0; x < 9; x++) {
             if (grille[x][col] == num) {
                 return false;
             }
         }
 
-        /*Vérifier la sous-grille 3x3*/
+        //Vérifier la sous-grille 3x3
         int startRow = row - row % 3;
         int startCol = col - col % 3;
         for (int i = 0; i < 3; i++) {