Enregistrement des grille bon pour un type

Ecriture.java

@@ -1,39 +1,37 @@
-import java.io.BufferedWriter;
+import java.io.*;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-
-import javax.swing.JFileChooser;
-import javax.swing.JOptionPane;
-import javax.swing.filechooser.FileNameExtensionFilter;
 
 public class Ecriture {
+    private byte[] tabHeader;
+    private String[] tabOffSet;
+    private String filePath;
 
-    public static void main(String[] args) {
+    public Ecriture(byte[] tabBytes, String[] tabOctetsBinaires, String chemin) {
-        Ecriture enregistreur = new Ecriture();
+        this.tabHeader = tabBytes;
-        enregistreur.enregistrerFichier();
+        this.tabOffSet = tabOctetsBinaires;
-    }
+        this.filePath = chemin;
 
-    public void enregistrerFichier() {
+        FileOutputStream fichierSortie = null;
-        JFileChooser chooser = new JFileChooser();
-        FileNameExtensionFilter filter = new FileNameExtensionFilter(
-                "Fichiers .lab", "lab");
-        chooser.setFileFilter(filter);
-        int returnVal = chooser.showSaveDialog(null);
-        if(returnVal == JFileChooser.APPROVE_OPTION) {
-            String nomFichier = chooser.getSelectedFile().getName();
-            if(!nomFichier.endsWith(".lab")) {
-                nomFichier += ".lab";
-            }
-            String contenu = "Contenu du fichier .lab";
-            File fichier = chooser.getSelectedFile();
         try {
-                BufferedWriter writer = new BufferedWriter(new FileWriter(fichier));
+            fichierSortie = new FileOutputStream(this.filePath);
-                writer.write(contenu);
+            
-                writer.close();
+            // Ecriture du tableau de bytes dans le fichier
-                JOptionPane.showMessageDialog(null, "Le fichier a été enregistré avec succès");
+            fichierSortie.write(tabBytes);
+            
+            // Ecriture du tableau d'octets binaires dans le fichier
+            for (String flags : this.tabOffSet) {
+                fichierSortie.write((byte) Integer.parseInt(flags, 2));
+            }
+            
         } catch (IOException e) {
-                JOptionPane.showMessageDialog(null, "Une erreur est survenue lors de l'enregistrement du fichier");
+            e.printStackTrace();
+        } finally {
+            // Fermeture du fichier
+            if (fichierSortie != null) {
+                try {
+                    fichierSortie.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
             }
         }
     }

FenetreImpGrille.java

@@ -12,12 +12,11 @@ public class FenetreImpGrille extends Fenetre {
         super();
     }
 
-    public void ImporterGrille(int taille, int Lentre, int Centre, int Lortie, int Cortie, int[] un_tab){
+    public void ImporterGrille(int taille, int Lentre, int Centre, int Lortie, int Cortie, int[] tabGrille){
         /* ================================================================ Déclaration des variables ============================================================================= */
-            
-        int compteur=0;
         int[][] ce_double_tab = new int[taille][taille];
         this.grille = new boolean[taille][taille];
+        //System.out.println("LA TAILLE DE LA GRRILLE VAUT : "+tabGrille.length);
 
          /* =============================================================== Gestion des paramètres de la fenètre ========================================================================== */
         /*Création de la fenètre  */
@@ -28,9 +27,10 @@ public class FenetreImpGrille extends Fenetre {
         /* ================================================================================================================================================================ */
             
         /* remplissage du tab 1 */
+        int compteur=0;
         for(int i=0; i<taille; i++){
             for(int j=0; j<taille; j++){
-                ce_double_tab[j][i] = un_tab[compteur];
+                ce_double_tab[j][i] = tabGrille[compteur];
                 compteur++;
             }
         }

GestionExporter.java

@@ -26,7 +26,11 @@ public class GestionExporter implements ActionListener{
     public void actionPerformed(ActionEvent e){
         this.cet_event=e.getActionCommand();
         if (cet_event.equals(this.Reponses1)){
-            System.out.println("Sauvegardeeeeeeeeeee");
+            this.frameGrille.dispose();
+            this.frameModif.dispose();
+            this.framePopup.dispose();
+            //outils.PrintGrilleBool(this.cetteGrille, this.cetteTaille);
+            PreEcriture precriture = new PreEcriture(this.cetteGrille, this.grilleCellules, this.cetteTaille);
         }
         else if (cet_event.equals(this.Reponses2)){
             this.frameGrille.dispose();

Lecture.java

@@ -25,6 +25,8 @@ public class Lecture {
      * ===========================================================================================================================================================================
      */
 
+
+
     public int GetHeader(int n){  
         try {
             /* Ouverture du flux */
@@ -49,6 +51,8 @@ public class Lecture {
         }
     }
 
+
+
     /* ===========================================================================================================================================================================
      * 
      *                                                                          GET_OFFSET
@@ -67,7 +71,7 @@ public class Lecture {
             int cette_taille=fis.available();/*cette_taille prend une aproximation de la taille du flux */
 
             int ce_compteur = 0, temp;
-            int [] ce_tableau = new int[cette_taille]; /*-5 pour le header mais +1 pour le -1 de fin de fichier. */
+            int [] ce_tableau = new int[cette_taille-4]; /*-5 pour le header mais +1 pour le -1 de fin de fichier. */
             int [] ce_tableau_temp = new int[8]; /*C'est le tab qui va stocker les différents octets */
             int[] ce_tab_to_return = new int[0];; /*Tableau qui va être renvoyé et qui va contenir tous les bits dans le non ordre */
 
@@ -88,19 +92,16 @@ public class Lecture {
             /* =============================================================================================================================== */
             
             //Utilisation du tableau différent pour créer un tableau avec tout les octets mais dans le bon sens grace a ma superbe classe Outils ;)
-
+            //System.out.println("la taille du tableau vaut : "+ce_tableau.length);
-            outils ToolBox = new outils();
+            for(int m=0; m<ce_tableau.length; m++){ //length -1 car on ne veux pas traiter le -1;
-
-            for(int m=0; m<ce_tableau.length-1; m++){ //length -1 car on ne veux pas traiter le -1;
                 temp = ce_tableau[m];
-                
                 for(int n=0; n<8; n++){ //repetition 8 fois pour traiter les 8 bits
                     ce_tableau_temp[n] = temp&1;
-                    System.out.println("la bit vaut : "+ce_tableau_temp[n]);
                     temp = temp >> 1;
                 }
+                //outils.printInt(outils.reverse(ce_tableau_temp), 8);
     
-                ce_tab_to_return = ToolBox.concatenate(ce_tab_to_return, ToolBox.reverse(ce_tableau_temp));     
+                ce_tab_to_return = outils.concatenate(ce_tab_to_return, outils.reverse(ce_tableau_temp));     
             }
 
             /* =================================================================================================================================== */

Makefile

@@ -73,9 +73,16 @@ Affichage.class : Affichage.java outils.class
 Exporter.class : Exporter.java GestionExporter.class
 	${JC} ${JCFLAGS} Exporter.java
 
-GestionExporter.class : GestionExporter.java 
+GestionExporter.class : GestionExporter.java PreEcriture.class
 	${JC} ${JCFLAGS} GestionExporter.java
 
+PreEcriture.class : PreEcriture.java Ecriture.class
+	${JC} ${JCFLAGS} PreEcriture.java
+
+Ecriture.class : Ecriture.java
+	${JC} ${JCFLAGS} Ecriture.java
+
+
 # ================================
 
 ### REGLES OPTIONNELLES ###

PreEcriture.java

@@ -1,3 +1,100 @@
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import javax.swing.JFileChooser;
+import javax.swing.JOptionPane;
+import javax.swing.filechooser.FileNameExtensionFilter;
+
 public class PreEcriture {
-    public PreEcriture(){}
+    private int cetteTaille;
+    private String path;
+    private int ceCompteur;
+    private int octetRemaining;
+
+    private boolean[][] cetteGrille;
+    private Cellules[][] grilleCellules;
+
+    private int[] resultat;
+    private String[] tabTemp;
+    private byte[] resultatByte;
+    private byte[] resultatOffsetByte;
+
+
+    public PreEcriture(boolean[][] uneGrille, Cellules[][] uneGrilleCell , int uneTaille){
+        this.cetteTaille = uneTaille;
+        this.cetteGrille = uneGrille;
+        this.grilleCellules = uneGrilleCell;
+
+        /* ======================================== Confection du header ============================================== */
+
+        this.resultat = new int[5];
+        this.resultatByte = new byte[5];
+        int[] tabEntrortie = new int[4];
+
+        tabEntrortie=outils.ParcoursCell(this.grilleCellules, this.cetteTaille);
+
+        this.resultat[0]=this.cetteTaille;
+        this.resultat[1]=tabEntrortie[0];
+        this.resultat[2]=tabEntrortie[1];
+        this.resultat[3]=tabEntrortie[2];
+        this.resultat[4]=tabEntrortie[3];
+        this.resultatByte = outils.ConvertToByte(this.resultat);
+
+        /* ====================================== Confection de l'Offset ============================================ */
+
+        if((this.cetteTaille*this.cetteTaille)%8 == 0){ //définit les tailles s'il y a besoin d'un octet en plus ou pas
+            this.tabTemp = new String[(this.cetteTaille*this.cetteTaille)/8];
+            this.ceCompteur = (this.cetteTaille*this.cetteTaille)/8;
+            this.octetRemaining = this.cetteTaille*this.cetteTaille;
+        } else if((this.cetteTaille*this.cetteTaille)%8 > 0){
+            this.tabTemp = new String[(this.cetteTaille*this.cetteTaille)/8+1];
+            this.ceCompteur = ((this.cetteTaille*this.cetteTaille)/8)+1;
+            this.octetRemaining = (this.cetteTaille*this.cetteTaille)+(this.cetteTaille*this.cetteTaille)%8;
+        }
+        
+        String tempString = "";
+        boolean[] tabHorizontal = new boolean[this.cetteTaille*this.cetteTaille];
+        tabHorizontal = outils.PutToVertical(this.cetteGrille, this.cetteTaille);
+        
+        outils.printBool(tabHorizontal, this.cetteTaille);
+
+        // Transformation du tableau de boolean en un tableau de chaine de String qui stock des nombre sous formes de byte 
+        int compteur1=0; 
+        for(boolean cetteIteration : tabHorizontal){
+            if(cetteIteration==true){
+                tempString = tempString + "0";
+            } else if(cetteIteration==false){
+                tempString = tempString + "1";
+            }
+            if(tempString.length()==8 || this.octetRemaining<8){
+                tabTemp[compteur1] = tempString;
+
+                tempString="";
+                compteur1++;
+                this.octetRemaining = this.octetRemaining - 8;
+            }
+        }
+        
+        this.path = this.CreateFichier();
+        Ecriture stylo = new Ecriture(this.resultatByte, this.tabTemp, this.path);
+    }
+
+    public String CreateFichier() {
+        JFileChooser chooser = new JFileChooser();
+        FileNameExtensionFilter filter = new FileNameExtensionFilter("Fichiers .lab", "lab");
+        chooser.setFileFilter(filter);
+        int returnVal = chooser.showSaveDialog(null);
+        if(returnVal == JFileChooser.APPROVE_OPTION) {
+            String nomFichier = chooser.getSelectedFile().getName();
+            if(!nomFichier.endsWith(".lab")) {
+                nomFichier += ".lab";
+            }
+            String contenu = "Contenu du fichier .lab";
+            File fichier = chooser.getSelectedFile();
+            return fichier.getAbsolutePath();
+        }
+        return null;
+    }
 }

importer.java

@@ -19,7 +19,7 @@ public class Importer implements ActionListener {
   public void actionPerformed(ActionEvent e){
     this.cet_event=e.getActionCommand();
     if(cet_event.equals(this.cette_option)){
-      System.out.println("Importation de la grille");
+      //System.out.println("Importation de la grille");
 
       /*cherche le chemin du fichier */
       FileImport un_test = new FileImport();

outils.java

@@ -1,4 +1,11 @@
+import javax.swing.plaf.metal.OceanTheme;
+
 public class outils {
+    public static final int COULOIR=0;
+    public static final int MUR=1;
+    public static final int ENTREE=2;
+    public static final int SORTIE=3;
+
     protected outils(){
     }
 
@@ -33,7 +40,7 @@ public class outils {
         return tableau_temp;
     }
 
-    public static void PrintGrille(boolean[][] leTableau, int saTaille){
+    public static void PrintGrilleBool(boolean[][] leTableau, int saTaille){
         for(int i=0; i<saTaille; i++){
             for(int j=0; j<saTaille; j++){
                 System.out.print(leTableau[i][j]+" ");
@@ -52,4 +59,54 @@ public class outils {
         }
         System.out.print("\n ------------ \n FIN \n");
     }
+
+    public static int[] ParcoursCell(Cellules[][] leTableau, int saTaille){
+        int[] ceTableau = new int[4];
+        for(int i=0; i<saTaille; i++){
+            for(int j=0; j<saTaille; j++){
+                if(leTableau[i][j].getType() == ENTREE){
+                    ceTableau[0] = leTableau[i][j].getLigne();
+                    ceTableau[1] = leTableau[i][j].getColone();
+                } else if(leTableau[i][j].getType() == SORTIE){
+                    ceTableau[2] = leTableau[i][j].getLigne();
+                    ceTableau[3] = leTableau[i][j].getColone();
+                }
+            }
+        }
+        return ceTableau;
+    }
+
+    public static byte[] ConvertToByte(int[] leTableau){
+        byte[] taByte = new byte[leTableau.length];
+        for(int i=0; i<leTableau.length; i++){
+            taByte[i]=(byte) leTableau[i];
+        }
+        return taByte;
+    }
+
+    public static void printInt(int[] leTableau, int saTaille) {
+        for(int i=0; i<saTaille;i++){
+            System.out.print("["+leTableau[i] +"] ");
+        }
+        System.out.print("\n");
+    }
+
+    public static void printBool(boolean[] leTableau, int saTaille) {
+        for(int i=0; i<saTaille*saTaille;i++){
+            System.out.print("["+leTableau[i] +"] ");
+        }
+        System.out.print("\n");
+    }
+
+    public static boolean[] PutToVertical(boolean[][] leTableau, int saTaille){
+        boolean[] resultat = new boolean[saTaille*saTaille];
+        int compteur=0;
+        for(int i=0; i<saTaille; i++){
+            for(int j=0; j<saTaille;j++){
+                resultat[compteur] = leTableau[j][i];
+                compteur++;
+            }
+        }
+        return resultat;
+    }
 }