MAJ 2.0.1

bin/.gitignore

@@ -9,3 +9,4 @@
 /onLine/
 /accueil_new_version.png
 /accueill new version.svg
+/baseEvaluation/

src/baseEvaluation/myTableBaseEvaluation.java

@@ -0,0 +1,78 @@
+package baseEvaluation;
+
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import javax.swing.table.AbstractTableModel;
+import xml.node;
+
+/**
+ * 
+ * @author pabr6
+ *
+ */
+public class myTableBaseEvaluation  extends AbstractTableModel{
+	private String[][] evaluation = new String[0][6]; 
+	private List<String> columNames = new ArrayList<>(Arrays.asList(new String[] {"Nom de l'évaluation","Date de création","Date de modification","Titre de l'exercice","Propriété personnalisé Sujet","Nom du fichier d'analyse"}));
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public int getRowCount() {
+		return evaluation.length;
+	}
+
+	@Override
+	public int getColumnCount() {
+		return columNames.size();
+	}
+
+	@Override
+	public String getValueAt(int rowIndex, int columnIndex) {
+		return evaluation[rowIndex][columnIndex];
+	}
+	
+
+	@Override
+	public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
+		evaluation[rowIndex][columnIndex] = (String) aValue;
+		fireTableCellUpdated(rowIndex, columnIndex);
+	}
+
+	public String getColumnName(int column) {
+        return columNames.get(column);
+    }
+	
+	public String getNameEvaluation(int rowIndex){
+		return evaluation[rowIndex][0];
+	}
+
+	
+	public void addOrUpdate() {
+		evaluation = new String[calc.commandes.evaluationsBase.getEnfants().size()][columNames.size()];
+		for(int i = 0 ; i<calc.commandes.evaluationsBase.getEnfants().size();i++) {
+			String dateCreation ="";
+			evaluation[i][0] = calc.commandes.evaluationsBase.getEnfants().get(i).getAttributs().get("name");
+			if(calc.commandes.evaluationsBase.getEnfants().get(i).getAttributs().get("date")!=null) {
+				dateCreation = calcul.formatDateWriter.DateEnClairFR( calcul.formatDateWriter.DateLibreOffice(calc.commandes.evaluationsBase.getEnfants().get(i).getAttributs().get("date") ));
+			}
+			evaluation[i][1] = dateCreation;
+			if(calc.commandes.evaluationsBase.getEnfants().get(i).getAttributs().get("dateModification")!=null) {
+				evaluation[i][2] =  calcul.formatDateWriter.DateEnClairFR( calcul.formatDateWriter.DateLibreOffice(calc.commandes.evaluationsBase.getEnfants().get(i).getAttributs().get("dateModification") ));
+			}else {
+				evaluation[i][2] =  dateCreation;
+			}
+			node fichier = calc.commandes.evaluationsBase.getEnfants().get(i).retourneFirstEnfant("fichier");
+			evaluation[i][3] = fichier.getAttributs().get("titre");
+			evaluation[i][4] = fichier.getAttributs().get("metaSujet");
+			evaluation[i][5] = fichier.getAttributs().get("analysis_filename");
+		}
+		fireTableRowsInserted(0, calc.commandes.evaluationsBase.getEnfants().size()-1);
+    }
+
+
+	
+}

src/baseEvaluation/recupeNodeBaseEvaluations.java

@@ -0,0 +1,137 @@
+package baseEvaluation;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+import java.nio.file.Paths;
+
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+
+import xml.node;
+/**
+ * Récupère la base des évaluations qui se trouve indiqué par commandes.<br>
+ * PathBaseEvaluationDefaut ou commandes.PathBaseEvaluations.
+ */
+public class recupeNodeBaseEvaluations {
+	
+	private boolean HasEvaluation = false;
+	
+	/**
+	 * Récupère la base des évaluations qui se trouve indiqué par commandes.<br>
+	 * PathBaseEvaluationDefaut ou commandes.PathBaseEvaluations.
+	 */
+	public recupeNodeBaseEvaluations() {
+		String directoryName = "";
+		File file = null;
+		if(calc.commandes.PathBaseEvaluationDefaut) {
+			directoryName = Paths.get("").toAbsolutePath().toString();
+		}else {
+			directoryName = calc.commandes.PathBaseEvaluations;
+		}
+		 
+		if(calc.commandes.os.contains("Win")) {
+			file = new File(directoryName + "\\" + calc.commandes.NameBaseEvaluations);
+		}else {
+			file = new File(directoryName + "/" + calc.commandes.NameBaseEvaluations);
+		}
+
+		System.out.println("Début de la récupération de la base.");
+		
+		if(file!=null) {
+			BufferedReader br;
+			try {
+				br = new BufferedReader(
+				        new InputStreamReader(
+				            new FileInputStream(file.getAbsoluteFile()), "UTF-8"));
+				String line;
+				StringBuilder targetString = new StringBuilder();
+				while ((line = br.readLine()) != null) {
+					targetString.append(line);
+				}
+				
+				node evaluations = new node();
+				evaluations = evaluations.allFirstNodesEvaluationFichierOnly(targetString.toString().replace("\t","").replace("\r", "").replace("\n", ""));
+							
+				if(evaluations!=null) {
+					calc.commandes.evaluationsBase = evaluations;
+					System.out.println("Fin de la récupération de la base.");
+				}
+				if(evaluations.getEnfants().size()>0) HasEvaluation=true;
+				
+			}catch (Exception e) {
+				JLabel texte = new JLabel("<html><p>La base de données des évaluations n'est pas située dans le même répertoire que celui de l'application.</p><br>"
+						+"<p>Vous pouvez charger ou créer une base de données depuis la fenêtre \"<b>base de données d'évaluation</b>\".</p></html>");
+				JOptionPane.showMessageDialog(null, texte);
+			}
+		}
+	}
+	
+	/**
+	 *  * Récupère la base des évaluations qui se trouve indiqué par commandes.<br>
+	 * directoryName et NameNewBase.
+	 * @param directoryName
+	 * @param NameNewBase
+	 */
+	public recupeNodeBaseEvaluations(String directoryName, String NameNewBase) {
+
+		File file = null;
+				 
+		if(calc.commandes.os.contains("Win")) {
+			file = new File(directoryName + "\\" + NameNewBase);
+		}else {
+			file = new File(directoryName + "/" + NameNewBase);
+		}
+			
+		
+		if(file!=null) {
+			BufferedReader br;
+			try {
+				br = new BufferedReader(
+				        new InputStreamReader(
+				            new FileInputStream(file.getAbsoluteFile()), "UTF-8"));
+				String line;
+				StringBuilder targetString = new StringBuilder();
+				while ((line = br.readLine()) != null) {
+					targetString.append(line);
+				}
+				String codeTexte = targetString.toString().replace("\t","").replace("\r", "").replace("\n", "");
+				
+				if(codeTexte.contains("<evaluations ")&&codeTexte.contains("</evaluations>")) {
+					node evaluations = new node();
+					evaluations = evaluations.allFirstNodesEvaluationFichierOnly(codeTexte);
+					if(evaluations!=null) {
+						if(evaluations.getEnfants().size()>0) {
+							if(evaluations.getNameNode().equals("evaluations")) {
+								calc.commandes.evaluationsBase = evaluations;
+								calc.commandes.PathBaseEvaluations = (directoryName);
+								calc.commandes.NameBaseEvaluations = NameNewBase;
+								calc.commandes.PathBaseEvaluationDefaut = false;
+							}
+						}
+					}
+				}else {
+					JLabel texte = new JLabel("<html><p>Ce fichier n'est pas une base de données des évaluations d'analyseWriter.</p></html>");
+					JOptionPane.showMessageDialog(null, texte);JOptionPane.showMessageDialog(null, texte);
+				}
+			}catch (Exception e) {
+				JLabel texte = new JLabel("<html><p>La base de données n'est pas située dans le même répertoire que celui de l'application.</p><br>"
+						+"<p>Vous pouvez charger ou créer une base de données depuis la fenêtre \"<b>base de données d'évaluation</b>\" de l'application.</p></html>");
+				JOptionPane.showMessageDialog(null, texte);JOptionPane.showMessageDialog(null, texte);
+			}
+		}
+	}
+
+	/**
+	 * Y a-t'il des évaluations ?<br>
+	 * @return
+	 */
+	public boolean isHasEvaluation() {
+		return HasEvaluation;
+	}
+
+
+	
+	
+}

src/calc/commandes.java

@@ -2,6 +2,7 @@ package calc;
 
 
 import java.io.IOException;
+import java.nio.file.Paths;
 
 import javax.swing.JTree;
 
@@ -28,10 +29,25 @@ public class commandes {
 	public static String branch = "Origin";
 	public static String Annee ="2022";
 	
-	//** Le node base de données des évaluations
+	//*********************************************
+	//** Le node base de données des évaluations **
+	//*********************************************
+	/** node des évalations (contient toutes les évaluations) */
 	public static node evaluationsBase = null;
+	/** node de l'évaluation chargée en mémoire */
 	public static node evaluationChargeEnMemoire = null;
+	/** Hash code de l'évaluation enregistrée */
 	public static int hashCodeEvaluationSave = 0;
+	/** Chemin vers le dossier de la base de données */
+	public static String PathBaseEvaluations = Paths.get("").toAbsolutePath().toString();
+	/** Base de données par défaut qui se trouve dans le même dossier que l'application */
+	public static boolean PathBaseEvaluationDefaut = true; //Flag si ce n'est pas le chemin par défaut vers la base de données
+	/** Nom du fichier de la base de données des évaluation*/
+	public static String NameBaseEvaluations="base_evaluations_analyseCalc.xml"; //Nom par défaut de la base de données
+	/** Nom de l'évaluation chargée en mémoire */
+	public static String NameEvaluationCharger = "";
+	/** Index dans la table de l'évaluation chargée en mémoire */
+	public static int IndexEvaluationCharger = -1;
 	
 	//***************************************************
 	//** Les commandes par défaut à travers la console **
@@ -62,6 +78,7 @@ public class commandes {
 	public static String path ="";
 	public static String pathDestination =""; //Pour le mode console uniquement
 	public static String Command =""; //récupère le texte de la commande dans la console
+	public static String os = System.getProperty("os.name");
 	
 	//** setting valeur par défaut
 	public static String culture = "FR";

src/calcul/formatDateWriter.java

@@ -45,4 +45,52 @@ public class formatDateWriter {
 		return  d;
 	}
 	
+	/**
+	 * Retourne une String au format dd/MM/yyy HH:mm:ss à partir d'une date.</br>
+	 * @param date
+	 * @return
+	 */
+	public static String DateEnClairFR(Date date) {
+		SimpleDateFormat simpledateformat = new SimpleDateFormat("EEEE dd MMM yyy' à 'hh:mm:ss");
+		String d1 = simpledateformat.format(date);
+		
+		return d1;
+	}
+	
+	/**
+	 * Retourne une String au format YYYY-MM-JJTHH:MM:SS à partir d'une date.</br>
+	 * @param d
+	 * @return
+	 * @throws ParseException
+	 */
+	public static String DateLibreOffice(Date date) throws ParseException {
+		SimpleDateFormat simpledateformat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+		String d1 = simpledateformat.format(date);
+		
+		return d1;
+	}
+	
+	/**
+	 * Retourne sous la forme d'un string au format LibreOffice la date d'aujourd'hui.<br>
+	 * @return
+	 * @throws ParseException
+	 */
+	public static String dateTodayLibreOffice() throws ParseException {
+		Date aujourdhui = new Date();
+		return DateLibreOffice(aujourdhui);
+	}
+	
+	/**
+	 * Retourne la date du fichier du node commandes.sujet<br>
+	 * Si ne trouve pas la date alors retourne un null.
+	 * @return
+	 */
+	public static Date dateNodeSujet() {
+		if(calc.commandes.sujet.getAttributs().get("date")!=null) {
+			String dateString = calc.commandes.sujet.getAttributs().get("date");
+			return calcul.formatDateWriter.DateLibreOffice(dateString);
+		}
+		return null;
+	}
+	
 }

src/fenetres/ChargePathBaseEvaluation.java

@@ -0,0 +1,198 @@
+package analyseWriter.fenetres;
+
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.HeadlessException;
+import java.awt.Image;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.text.ParseException;
+import java.util.ArrayList;
+
+import javax.swing.ImageIcon;
+import javax.swing.JDialog;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.filechooser.FileNameExtensionFilter;
+
+import analyseWriter.MEPTL.commandes;
+import analyseWriter.baseEvaluations.creerNouvelleEvaluation;
+import analyseWriter.baseEvaluations.recupeNodeBaseEvaluations;
+import cXML.node;
+
+/**
+ * 
+ * @author pabr6
+ *
+ */
+public class ChargePathBaseEvaluation extends JFileChooser {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	boolean avecFusion = false;
+	public static boolean erreurLecture = false;
+	/**
+	 * fusionWithDefaut : True avec fusion de la base par défaut.
+	 * @param fusionWithDefaut
+	 */
+	public ChargePathBaseEvaluation(Boolean fusionWithDefaut) {
+		erreurLecture=false;
+		avecFusion = fusionWithDefaut;
+		setDialogTitle("Sélectionner la base de données des évaluations.");
+		 FileNameExtensionFilter filter = new FileNameExtensionFilter("Base de données des évaluations", "xml");
+		 setFileFilter(filter);
+		 setPreferredSize(new Dimension(550, 420));
+		int response =  showOpenDialog(null);
+		if(response == JFileChooser.APPROVE_OPTION) {
+			 if (Files.isReadable(getSelectedFile().toPath())) {
+					File file = new File(getSelectedFile().getAbsolutePath());
+					String ext = file.getName().substring(file.getName().lastIndexOf("."));
+					if(ext.equals(".xml")){
+						if(!avecFusion) {
+							openFileXML(file);
+						}else {
+							try {
+								fusionBaseWithDefaut(file);
+							} catch (ParseException e) {
+								e.printStackTrace();
+							}
+						}
+					}
+			 }else {
+				 erreurLecture = true;
+				 JFrame frame = new JFrame();
+					JLabel texte = new JLabel("<html><h1>Problème avec la lecture de la base de données</h1>"
+								+ "<p>"+ getSelectedFile().getAbsolutePath() +"</p>"
+										+ "<p>Vous devez avoir des droits pour lire dans ce dossier.</p></html>");
+					JOptionPane.showMessageDialog(frame, texte);
+			 }
+		}
+	}
+	
+	
+	
+
+	
+	@Override
+     protected JDialog createDialog( Component parent ) throws HeadlessException {
+        JDialog dialog = super.createDialog( parent );
+        Image img = new ImageIcon(getClass().getResource("/resources/evalwriter.png") ).getImage();
+        dialog.setIconImage(img);
+        return dialog;
+    }
+
+	
+	/**
+	 * 
+	 * @param file
+	 */
+	private void openFileXML(File file) {
+		
+		if(Files.isReadable(file.toPath())) {
+			if(commandes.os.contains("Win")) {
+				commandes.path = file.getPath().substring(0,file.getPath().lastIndexOf("\\"));  // Sur Windows
+			}else {
+				commandes.path = file.getPath().substring(0,file.getPath().lastIndexOf("/")); // Sur mac & Linux
+			}
+			String directoryName = getCurrentDirectory().getPath();
+			String nameNewBase = file.getName().toString();
+			new recupeNodeBaseEvaluations(directoryName,nameNewBase);
+		}else {
+			 JFrame frame = new JFrame();
+				JLabel texte = new JLabel("<html><h1>Problème avec la lecture de la base de données</h1>"
+							+ "<p>"+ getSelectedFile().getAbsolutePath() +"</p>"
+									+ "<p>Vous devez avoir des droits pour lire dans ce dossier.</p></html>");
+				JOptionPane.showMessageDialog(frame, texte);
+		}	
+	}
+
+	private void fusionBaseWithDefaut(File file) throws ParseException {
+		
+		if(!Files.isReadable(file.toPath())) {
+			 JFrame frame = new JFrame();
+				JLabel texte = new JLabel("<html><h1>Problème avec la lecture de la base de données</h1>"
+							+ "<p>"+ getSelectedFile().getAbsolutePath() +"</p>"
+									+ "<p>Vous devez avoir des droits pour lire dans ce dossier.</p></html>");
+				JOptionPane.showMessageDialog(frame, texte);
+				return;
+		}
+		
+		node copieDefault = new node();
+		
+		try {
+			commandes.PathBaseEvaluations = Paths.get("").toAbsolutePath().toString();
+			commandes.NameBaseEvaluations = "base_evaluations_analyseWriter.xml";
+			commandes.PathBaseEvaluationDefaut = true;
+			copieDefault = commandes.evaluationsBase.clone();
+		} catch (CloneNotSupportedException e) {
+			e.printStackTrace();
+		}
+		
+
+		
+		if(!copieDefault.isVide() && !commandes.evaluationsBase.isVide()) {
+			
+			BufferedReader br;
+			node evaluations = new node();
+			try {
+				br = new BufferedReader(
+				        new InputStreamReader(
+				            new FileInputStream(file.getAbsoluteFile()), "UTF-8"));
+				String line;
+				StringBuilder targetString = new StringBuilder();
+				while ((line = br.readLine()) != null) {
+					targetString.append(line);
+				}
+				String CodeTexte = targetString.toString().replace("\t","").replace("\r", "").replace("\n", "");
+				evaluations = new node(CodeTexte);
+				
+			}catch (Exception e) {
+				JFrame frame = new JFrame("Erreur");
+				JLabel texte = new JLabel("<html><h1>Erreur</h1><p>L'évaluation n'a pas été trouvé dans la base de données.</p></html>");
+				JOptionPane.showMessageDialog(frame, texte);
+			}
+			
+			
+			for(int i = 0 ; i < evaluations.getNodes().size();i++) {
+				String date = evaluations.getNodes().get(i).getAttributs().get("date");
+				if(date==null) continue;
+				ArrayList<node> A = copieDefault.retourneEnfantsByNameAndValueAttribut("evaluation", "date", date, new ArrayList<node>());
+				
+				// l'évaluation n'existe pas dans la base par défaut et ce n'est pas une importation
+				if(A.size()==0) {
+					String name = evaluations.getNodes().get(i).getAttributs().get("name");
+					new creerNouvelleEvaluation(evaluations.getNodes().get(i), name, false,true);
+				}else {
+					// L'évaluation  existe dans la base par défaut
+//					for(int j = 0; j < A.size();j++) {
+//						evaluations.getNodes().get(i).getAttributs().put("dateModification", analyseWriter.calcul.formatDateWriter.DateLibreOffice(new Date()));
+//						String name = evaluations.getNodes().get(i).getAttributs().get("name");
+//						new creerNouvelleEvaluation(evaluations.getNodes().get(i), name, false,true);
+//						
+//					}
+				}
+			}
+			new recupeNodeBaseEvaluations();
+		}
+	}
+
+
+
+
+
+	public static boolean isErreurLecture() {
+		return erreurLecture;
+	}
+
+	
+	
+	
+}

src/fenetres/baseDonneesEvaluations.java

@@ -0,0 +1,680 @@
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.FlowLayout;
+import java.awt.Font;
+import java.awt.SystemColor;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextPane;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingConstants;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.table.TableColumnModel;
+
+import baseEvaluation.myTableBaseEvaluation;
+import net.lingala.zip4j.exception.ZipException;
+import net.miginfocom.swing.MigLayout;
+import xml.node;
+
+
+/**
+ * 
+ * @author pabr6
+ *
+ */
+public class baseDonneesEvaluations extends JFrame {    /**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	private static baseDonneesEvaluations instance;
+	private myTableBaseEvaluation model = new myTableBaseEvaluation();
+	static JTable table = new JTable();
+	private JPanel panelHaut = new JPanel();
+	private JPanel panelBas = new JPanel();
+	private JPanel panelGauche = new JPanel();
+	private JLabel lblInformationBaseEvluation = new JLabel("");
+	private  JButton btnSupprimeEvaluation = new JButton("<html>Supprimer une<br>évaluation</html>");
+	private  JButton btnSaveEvaluation = new JButton("<html>Enregistrer ou renommer<br>l'évaluation chargée en mémoire.</html>");
+	private  JButton btnRenommeFichierAnalyse = new JButton("<html>Renommer le fichier d'analyse<br>de l'évaluation sélectionnée</html>");
+	private  JButton btnRenommerEvaluation = new JButton("<html>Renommer l'évaluation<br>sélectionnée</html>");
+	private  JButton btndefautBaseEvaluation = new JButton("<html>Base par défaut</html>");
+	public static boolean isDispose = true;
+	int indexSelect=0;
+	ListSelectionModel lsm = null;
+	JScrollPane scrollPaneTable = new JScrollPane();
+	JScrollPane scrollPaneBoutons = new JScrollPane();
+	private final JButton btnChargerNewBase = new JButton("<html>Utiliser une autre<br>base d'évaluation</html>");
+	private final JButton btnFermer = new JButton("<html>Femer</html>");
+	private final JTextPane textPane = new JTextPane();
+	private final JTextPane textPane_1 = new JTextPane();
+	private final JButton btnExtraireFileAnalysis = new JButton("<html>Extraire le fichier d'analyse<br>de l'évaluation sélectionnée</html>");
+	private final JButton btnFusionnerBase = new JButton("<html>Importer des évaluations<br>depuis une autre base</html>");
+	private final JButton btnChargerFichierAnalyse = new JButton("<html>Créer une évaluation à <br>partir d'un fichier d'analyse</html>");
+	private final static JLabel lblCheminVersBase = new JLabel(calc.commandes.PathBaseEvaluations);
+	private final JButton btnArchiveBase = new JButton("<html>Copie de sauvegarde</html>");
+
+	
+public baseDonneesEvaluations() {
+    super();
+    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+    setLocationRelativeTo( null );
+    setSize(1600,900);
+    int screenWidth = (int) java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds().getWidth();
+	int screenHeight = (int) java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds().getHeight();
+	setLocation(( (screenWidth) - getWidth()) / 2, (screenHeight - getHeight()) / 2);
+	
+	ImageIcon img = new ImageIcon(getClass().getResource("/resources/evalwriter.png") );
+	setIconImage(img.getImage());
+	setTitle(calc.commandes.Titre + " - La base de données des évaluations");
+	
+	getContentPane().setLayout(new BorderLayout(2, 2));
+	
+	
+	model.addOrUpdate();
+	table = new JTable(model);
+	table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+	TableColumnModel columnModel = table.getColumnModel();
+     columnModel.getColumn(0).setPreferredWidth(300);
+     columnModel.getColumn(0).setMaxWidth(400);
+     columnModel.getColumn(1).setPreferredWidth(300);
+     columnModel.getColumn(1).setMaxWidth(400);
+     columnModel.getColumn(2).setPreferredWidth(300);
+     columnModel.getColumn(2).setMaxWidth(400);
+     columnModel.getColumn(3).setPreferredWidth(300);
+     columnModel.getColumn(3).setMaxWidth(400);
+     columnModel.getColumn(3).setPreferredWidth(300);
+     columnModel.getColumn(3).setMaxWidth(400);
+     columnModel.getColumn(4).setPreferredWidth(300);
+     columnModel.getColumn(4).setMaxWidth(400);
+     columnModel.getColumn(5).setPreferredWidth(300);
+     columnModel.getColumn(5).setMaxWidth(400);
+	
+	table.setFont(new Font("Tahoma", Font.PLAIN, 14));
+
+	scrollPaneTable = new JScrollPane(table);
+ 
+    //Add the scroll pane to this panel.
+    getContentPane().add(scrollPaneTable,BorderLayout.CENTER);
+    
+	 getContentPane().add(panelBas, BorderLayout.SOUTH);
+	 FlowLayout fl_panelBas = new FlowLayout(FlowLayout.LEADING, 10, 10);
+	 panelBas.setLayout(fl_panelBas);
+	 textPane.setBackground(SystemColor.menu);
+	 panelBas.add(textPane);
+	 textPane_1.setBackground(SystemColor.menu);
+	 
+	 panelBas.add(textPane_1);
+	 lblCheminVersBase.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/BaseEvaluationsmini.png")));
+	 
+	 panelBas.add(lblCheminVersBase);
+	 if(calc.commandes.evaluationChargeEnMemoire!=null) {
+		 textPane.setText("Evaluation chargée en mémoire : " + calc.commandes.evaluationChargeEnMemoire.getAttributs().get("name"));
+	 }
+	 
+	 
+	 //*Le haut
+	getContentPane().add(panelHaut, BorderLayout.NORTH);
+	panelHaut.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5));
+	
+	
+	lblInformationBaseEvluation.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/accueilChargeEvaluation.png")));
+	lblInformationBaseEvluation.setFont(new Font("Tahoma", Font.BOLD, 14));
+	panelHaut.add(lblInformationBaseEvluation);
+	panelGauche.setBorder(null);
+	
+	
+	scrollPaneBoutons = new JScrollPane(panelGauche);
+	
+	getContentPane().add(scrollPaneBoutons, BorderLayout.WEST);
+	panelGauche.setLayout(new MigLayout("", "[:300px:400px,fill]", "[53px][][][][20px:n][][][][][30.00][20px:n][][][]"));
+	btndefautBaseEvaluation.setToolTipText("Recharge la base de données par défaut.");
+	
+	btndefautBaseEvaluation.setHorizontalAlignment(SwingConstants.LEFT);
+	btndefautBaseEvaluation.setForeground(new Color(0, 128, 192));
+	panelGauche.add(btndefautBaseEvaluation, "cell 0 0,grow");
+	btndefautBaseEvaluation.setFont(new Font("Tahoma", Font.BOLD, 18));
+	btndefautBaseEvaluation.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/defautBaseEvaluation.png")));
+	
+	btnChargerNewBase.setToolTipText("Charge les évaluations d'une autre base de données.");
+	btnChargerNewBase.setHorizontalAlignment(SwingConstants.LEFT);
+	btnChargerNewBase.setForeground(new Color(0, 128, 192));
+	panelGauche.add(btnChargerNewBase, "cell 0 1,growx,aligny top");
+	btnChargerNewBase.setFont(new Font("Tahoma", Font.BOLD, 15));
+	btnChargerNewBase.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/sauvegardehistoriqueevaluation.png")));
+	btnArchiveBase.setToolTipText("Archiver la base de données pour la sauvegarder et la réutiliser.");
+	
+	btnArchiveBase.setForeground(new Color(128, 128, 192));
+	btnArchiveBase.setFont(new Font("Tahoma", Font.BOLD, 15));
+	btnArchiveBase.setHorizontalAlignment(SwingConstants.LEFT);
+	btnArchiveBase.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/saveZipEvaluation.png")));
+	
+	panelGauche.add(btnArchiveBase, "cell 0 2,growx,aligny top");
+	
+	btnFusionnerBase.setToolTipText("Importer des évaluations dans la base par défaut depuis une autre base.");
+	btnFusionnerBase.setForeground(new Color(56, 184, 149));
+	btnFusionnerBase.setHorizontalAlignment(SwingConstants.LEFT);
+	btnFusionnerBase.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/fusionneBaseEvaluation.png")));
+	btnFusionnerBase.setFont(new Font("Tahoma", Font.BOLD, 15));
+	panelGauche.add(btnFusionnerBase, "cell 0 3,growx,aligny top");
+	btnSaveEvaluation.setToolTipText("Enregistre l'évaluation chargée en mémoire.");
+	
+	btnSaveEvaluation.setHorizontalAlignment(SwingConstants.LEFT);
+	btnSaveEvaluation.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/saveEvaluation.png")));
+	panelGauche.add(btnSaveEvaluation, "flowy,cell 0 5,growx,aligny top");
+	
+	btnSaveEvaluation.setForeground(new Color(0, 64, 128));
+	btnSaveEvaluation.setFont(new Font("Tahoma", Font.BOLD, 14));
+	btnRenommerEvaluation.setToolTipText("Renommer l'évaluation sélectionnée.");
+	btnRenommerEvaluation.setHorizontalAlignment(SwingConstants.LEFT);
+	btnRenommerEvaluation.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/renommeEvaluaton.png")));
+	panelGauche.add(btnRenommerEvaluation, "cell 0 6,growx,aligny top");
+	btnRenommerEvaluation.setForeground(new Color(153, 50, 204));
+	btnRenommerEvaluation.setFont(new Font("Tahoma", Font.BOLD, 15));
+
+	btnChargerFichierAnalyse.setToolTipText("Création d'une évaluation à partir d'un fichier d'analyse au format XML.");
+	btnChargerFichierAnalyse.setForeground(new Color(0, 64, 128));
+	btnChargerFichierAnalyse.setHorizontalAlignment(SwingConstants.LEFT);
+	btnChargerFichierAnalyse.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/fichierAnalyse.png")));
+	btnChargerFichierAnalyse.setFont(new Font("Tahoma", Font.BOLD, 15));
+	panelGauche.add(btnChargerFichierAnalyse, "cell 0 7,growx,aligny top");
+	btnExtraireFileAnalysis.setToolTipText("Extraire le fichier d'analyse de l'évaluation sélectionnée.");
+
+	
+	btnExtraireFileAnalysis.setHorizontalAlignment(SwingConstants.LEFT);
+	btnExtraireFileAnalysis.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/extraireFichierAnalyse.png")));
+	btnExtraireFileAnalysis.setForeground(new Color(209, 105, 35));
+	btnExtraireFileAnalysis.setFont(new Font("Tahoma", Font.BOLD, 15));
+	
+	panelGauche.add(btnExtraireFileAnalysis, "cell 0 8,growx,aligny top");
+	btnRenommeFichierAnalyse.setHorizontalAlignment(SwingConstants.LEFT);
+	btnRenommeFichierAnalyse.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/fichierAnalyseRenomme.png")));
+	
+	panelGauche.add(btnRenommeFichierAnalyse, "cell 0 9,growx,aligny top");
+	btnRenommeFichierAnalyse.setForeground(new Color(255, 140, 0));
+	
+	
+	btnRenommeFichierAnalyse.setFont(new Font("Tahoma", Font.BOLD, 15));
+	btnSupprimeEvaluation.setForeground(new Color(255, 0, 0));
+	btnSupprimeEvaluation.setFont(new Font("Tahoma", Font.BOLD, 15));
+	btnSupprimeEvaluation.setHorizontalAlignment(SwingConstants.LEFT);
+	btnSupprimeEvaluation.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/removeEvaluaton.png")));
+	panelGauche.add(btnSupprimeEvaluation, "cell 0 11,growx,aligny top");
+	
+	
+	btnFermer.setIcon(new ImageIcon(baseDonneesEvaluations.class.getResource("/resources/quitteEvaluation.png")));
+	btnFermer.setHorizontalAlignment(SwingConstants.LEFT);
+	btnFermer.setFont(new Font("Tahoma", Font.BOLD, 15));
+	
+	panelGauche.add(btnFermer, "cell 0 12,growx,aligny top");
+
+	//*Détection de la ligne sélectionnée
+	table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+    ListSelectionModel rowSM = table.getSelectionModel();
+    rowSM.addListSelectionListener(new ListSelectionListener() {
+		@Override
+		public void valueChanged(ListSelectionEvent e) {
+			//Ignore extra messages.
+            if (e.getValueIsAdjusting()) return;
+            	lsm = (ListSelectionModel)e.getSource();
+            if (lsm.isSelectionEmpty()) {
+                System.out.println("Aucune ligne sélectionnée.");
+            } else {
+            	indexSelect = lsm.getMinSelectionIndex();
+                System.out.println("La ligne " + indexSelect + " est sélectionnée.");
+            }
+		}
+    });
+    
+	ListenerAction();
+    
+}
+
+
+
+
+public static baseDonneesEvaluations getInstance() {
+	if (isDispose) {
+        instance = new baseDonneesEvaluations();
+    }
+//	afficheLesBoutonGestionBase();
+    instance.setVisible(true);
+    if(calc.commandes.IndexEvaluationCharger!=-1) {
+    	selectRow(calc.commandes.IndexEvaluationCharger);
+    }
+    isDispose=false;
+    if(calc.commandes.PathBaseEvaluationDefaut) {
+    	 lblCheminVersBase.setText(calc.commandes.PathBaseEvaluations);
+    }else {
+    	 lblCheminVersBase.setText(calc.commandes.PathBaseEvaluations+"/"+calc.commandes.NameBaseEvaluations);
+    }
+    return instance;
+}
+
+public static void selectRow(int indexRow) {
+	table.setRowSelectionInterval(indexRow, indexRow);
+}
+
+/**
+ * Ferme l'instance.
+ */
+public static void ferme() {
+	if(!isDispose) {
+		isDispose=true;
+		instance.dispose();
+	}
+}
+
+
+private void ListenerAction() {
+	
+	/**
+	 * Quitter le fenêtre.</br>
+	 */
+	addWindowListener(new java.awt.event.WindowAdapter() {
+	    @Override
+	    public void windowClosing(java.awt.event.WindowEvent windowEvent) {
+	    	isDispose=true;
+	    	dispose();
+	    }
+	});
+	
+	
+	/**
+	 * Archive la base des évaluations.
+	 */
+	btnArchiveBase.addActionListener(new ActionListener() {
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			if(Files.isReadable(Paths.get(""))) {
+				if(calc.commandes.evaluationsBase!=null) {
+					try {
+						String nameFile = Run.AddBaseToZip(Run.ecritureNode(commandes.evaluationsBase, 0));
+						JOptionPane.showMessageDialog(null, "La base des évaluations a été sauvegardée dans \"Archive des bases.zip\"\nSous le nom " + nameFile );
+					} catch (ZipException e1) {
+						e1.printStackTrace();
+					}
+				}
+			}else {
+				JFrame frame = new JFrame();
+				JLabel texte = new JLabel("<html><h1>Problème avec la lecture de la base de données</h1>"
+							+ "<p>"+ Paths.get("") +"</p>"
+									+ "<p>Vous devez avoir des droits pour lire dans ce dossier.</p></html>");
+				JOptionPane.showMessageDialog(frame, texte);
+			}
+		}
+	});
+	
+	
+	
+	/**
+	 * Extrait le fichier d'analyse de l'évaluation.
+	 */
+	btnExtraireFileAnalysis.addActionListener(new ActionListener() {
+
+		@Override
+		public void actionPerformed(ActionEvent e) {
+
+			if(lsm!=null) {
+				 if (!lsm.isSelectionEmpty()) {
+					 node evaluation = chargeEvaluation.retourneEvaluationSelected(indexSelect);
+					 String nameFile ="fichier analyse.xml";
+					 if(evaluation.getAttributs().get("analysis_filename")!=null) {
+						 nameFile = evaluation.getAttributs().get("analysis_filename");
+					 }
+					
+					 
+					 JFileChooser fileChooser = new JFileChooser();
+				       	fileChooser.setDialogTitle("Enregistrer sous..."); 
+				       	File file = null;
+				       	
+				       	String analysis_filename ="";
+				       if(evaluation.getAttributs().get("analysis_filename")!=null) {
+				    	   if(!evaluation.getAttributs().get("analysis_filename").isEmpty()) {
+				    		   file = new File(commandes.PathBaseEvaluations);
+					       		analysis_filename = evaluation.getAttributs().get("analysis_filename");
+					       }
+				    	}else {
+				    		 file = new File(commandes.PathBaseEvaluations);
+				    		 
+				    	}
+
+				       	fileChooser.setCurrentDirectory(file);
+				       	fileChooser.setSelectedFile(new File(nameFile));
+				       	 
+				       	int userSelection = fileChooser.showSaveDialog(null);
+				       	boolean notError = false;
+				       	if (userSelection == JFileChooser.APPROVE_OPTION) {
+				       	    File fileToSave = fileChooser.getSelectedFile();
+								try {								
+									if(commandes.os.contains("Win")) {
+										notError = Run.ecritureNodeEnXML(evaluation.retourneFirstEnfantsByName("fichier"), fileToSave.getName(), fileToSave.getPath().substring(0,fileToSave.getPath().lastIndexOf("\\")),Run.TypeFile.Sujet );
+									}else {
+										notError = Run.ecritureNodeEnXML(evaluation.retourneFirstEnfantsByName("fichier"), fileToSave.getName(), fileToSave.getPath().substring(0,fileToSave.getPath().lastIndexOf("/")),Run.TypeFile.Sujet  );					
+									}
+									if(notError) {
+										JFrame frame = new JFrame("Extration");
+										JLabel texte = new JLabel("<html><h1>Extration réussie</h1><p>Le fichier d'analyse <b>"+ analysis_filename +"</b> a été extrait de la base.</p>"
+												+ "<p>"+fileToSave.getAbsolutePath()+"<p></html>");
+										JOptionPane.showMessageDialog(frame, texte);
+									}else {
+										JFrame frame = new JFrame("Erreur");
+										JLabel texte = new JLabel("<html><h1>Erreur</h1><p>Le fichier d'analyse n'a pas été extrait de la base.</p>"
+												+ "<p><p></html>");
+										JOptionPane.showMessageDialog(frame, texte);
+									}
+					       	    } catch (IOException e1) {
+										e1.printStackTrace();
+								}
+				       	    System.out.println("Save as file: " + fileToSave.getAbsolutePath());
+							new recupeNodeBaseEvaluations();
+				       	}
+				          System.out.println( "Save as" );
+				 }
+			}
+		}	
+	});
+	
+	
+	/**
+	 * Charger un fichier d'analyse
+	 */
+	btnChargerFichierAnalyse.addActionListener(new ActionListener() {
+		public void actionPerformed(ActionEvent e) {
+			new ChargeFichierXML();
+			
+			//Encapsulation du node d'analyse fichier dans un node evaluation.
+			node evaluation = new node();
+			evaluation.setNomElt("evaluation");
+			String name = "Nouvelle évaluation";
+			evaluation.getNodes().add(commandes.sujet);
+			
+			name = JOptionPane.showInputDialog(null,"Donner un nom à cette évaluation ?",name);
+		 	 
+			if(name!=null) {
+				if(!name.isBlank()) {	
+					evaluation.getNodes().add(commandes.sujet);
+					new creerNouvelleEvaluation(evaluation,name,false,false);
+					new recupeNodeBaseEvaluations();
+					model.addOrUpdate();
+					table.setModel(model);
+				}
+			}else {
+				JOptionPane.showConfirmDialog(null, "L'évaluation n'a pas été enregistrée.\nVous devez fournir un nom à l'évaluation.");
+			}
+
+		}
+	});
+	
+	
+	/**
+	 * Fusionner deux bases d'évaluations
+	 */
+	btnFusionnerBase.addActionListener(new ActionListener() {
+		@Override
+		public void actionPerformed(ActionEvent e) {
+			new ChargePathBaseEvaluation(true);
+			if(!ChargePathBaseEvaluation.isErreurLecture()) {
+				new trierParDateDecroissanteLaBase();
+				model.addOrUpdate();
+				table.setModel(model);
+				selectRow(commandes.IndexEvaluationCharger);
+			}
+		}
+	});
+    
+	
+	/**
+	 * Femer la fenêtre.
+	 */
+	btnFermer.addActionListener(new ActionListener() {
+		public void actionPerformed(ActionEvent e) {
+			isDispose=true;
+	    	dispose();
+		}
+	});
+	
+	/**
+	 * Charger une nouvelle base d'évaluation
+	 */
+	btnChargerNewBase.addActionListener(new ActionListener() {
+		public void actionPerformed(ActionEvent e) {
+			new ChargePathBaseEvaluation(false);
+			if(!ChargePathBaseEvaluation.isErreurLecture()) {
+				if(commandes.evaluationsBase!=null) {
+					baseDonneesEvaluations.getInstance();
+				}
+				if(commandes.PathBaseEvaluationDefaut) {
+			    	 lblCheminVersBase.setText(commandes.PathBaseEvaluations);
+			    }else {
+			    	 lblCheminVersBase.setText(commandes.PathBaseEvaluations+"/"+commandes.NameBaseEvaluations);
+			    }
+				model.addOrUpdate();
+				table = new JTable(model);
+			}
+		}
+	});
+	
+	/**
+	 * Charge la base par défaut
+	 */
+	btndefautBaseEvaluation.addActionListener(new ActionListener() {
+		public void actionPerformed(ActionEvent e) {
+			if(Files.isReadable(Paths.get(""))) {
+				commandes.PathBaseEvaluations = Paths.get("").toAbsolutePath().toString();
+				commandes.NameBaseEvaluations = "base_evaluations_analyseWriter.xml";
+				commandes.PathBaseEvaluationDefaut = true;
+				new recupeNodeBaseEvaluations();
+				 if(commandes.PathBaseEvaluationDefaut) {
+			    	 lblCheminVersBase.setText(commandes.PathBaseEvaluations);
+			    }else {
+			    	 lblCheminVersBase.setText(commandes.PathBaseEvaluations+"/"+commandes.NameBaseEvaluations);
+			    }
+				model.addOrUpdate();
+				table = new JTable(model);
+			}else {
+				JFrame frame = new JFrame();
+				JLabel texte = new JLabel("<html><h1>Problème avec la lecture de la base de données</h1>"
+							+ "<p>"+ Paths.get("") +"</p>"
+									+ "<p>Vous devez avoir des droits pour lire dans ce dossier.</p></html>");
+				JOptionPane.showMessageDialog(frame, texte);
+			}
+		}
+	});
+	
+	/**
+	 * Chargement d'une évaluation par double click.
+	 */
+	table.addMouseListener( new MouseListener() {
+		@Override
+		public void mouseClicked(MouseEvent e) {
+	        if (e.getClickCount() == 2) {
+				if (e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) {
+					 System.out.println("un click ou deux click");
+					if(lsm!=null) {
+						 if (!lsm.isSelectionEmpty()) {
+							 indexSelect = lsm.getMinSelectionIndex();
+							 chargeEvaluation.chargeEnMémoireEvaluationSelected(indexSelect);
+							 commandes.IndexEvaluationCharger = indexSelect;
+							 if(!create.isDispose) {
+								 create.getInstance();
+							 }else {
+								 evaluate.getInstance();
+							 }
+							 isDispose=true;
+							 dispose();
+						 }
+					}
+				}
+	        }
+		}
+
+		@Override
+		public void mousePressed(MouseEvent e) {
+		}
+
+		@Override
+		public void mouseReleased(MouseEvent e) {
+		}
+
+		@Override
+		public void mouseEntered(MouseEvent e) {
+		}
+
+		@Override
+		public void mouseExited(MouseEvent e) {
+		}
+	  });
+
+	
+	 
+	 /**
+	  * Bouton Sauvegarde de l'évaluation en cours</br>
+	  * avec renommage de l'évaluation.</br>
+	  */
+	 btnSaveEvaluation.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				if(commandes.evaluationChargeEnMemoire!=null) {
+					String	name = commandes.evaluationChargeEnMemoire.getAttributs().get("name");
+					name = JOptionPane.showInputDialog(null,"Voulez-vous renommer l'évaluation ?",name);
+					if(name!=null) {
+						if(!name.isBlank()) {
+							new creerNouvelleEvaluation(commandes.evaluationChargeEnMemoire, name,true,false);
+						}
+					}
+				}else {
+					String name = JOptionPane.showInputDialog(null,"Voulez-vous renommer l'évaluation ?","Nouvelle évaluation");
+					if(name!=null) {
+						if(!name.isBlank()) {
+							new creerNouvelleEvaluation(new node(), name,false,false);
+						}
+					}
+				}
+				new trierParDateDecroissanteLaBase();
+				new recupeNodeBaseEvaluations();			
+				model.addOrUpdate();
+				table.setModel(model);
+				selectRow(commandes.IndexEvaluationCharger);
+			}
+	 });
+	 
+	 /**
+	  * Bouton supprimer une évaluation.</br>
+	  */
+	 btnSupprimeEvaluation.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				if(lsm!=null) {
+					 if (!lsm.isSelectionEmpty()) {
+						 if(JOptionPane.showConfirmDialog(null,"Voulez-vous supprimer l'évaluation sélectionnée ?", 
+								 "Suppression", JOptionPane.YES_NO_OPTION,JOptionPane.WARNING_MESSAGE)==JOptionPane.YES_OPTION) {
+								indexSelect = lsm.getMinSelectionIndex();
+								
+								node evaluation = chargeEvaluation.retourneEvaluationSelected(indexSelect);
+								new removeEvaluation(evaluation);
+								
+								new recupeNodeBaseEvaluations();
+								model.addOrUpdate();
+								table.setModel(model);	
+						 	}
+					 	}
+					}
+				}
+			});
+	 
+	/**
+	 * Renomme le fichier d'analyse
+	 */
+	btnRenommeFichierAnalyse.addActionListener(new ActionListener() {
+		public void actionPerformed(ActionEvent e) {
+			if(lsm!=null)if (!lsm.isSelectionEmpty()) {
+//				indexSelect = lsm.getMinSelectionIndex();
+				
+				node evaluation = chargeEvaluation.retourneEvaluationSelected(indexSelect);
+				
+				String nomFichierAnalyse = "";
+				if(evaluation.retourneFirstEnfantsByName("fichier").getAttributs().get("analysis_filename")!=null) {
+					nomFichierAnalyse = evaluation.retourneFirstEnfantsByName("fichier").getAttributs().get("analysis_filename");
+				}
+				JPanel panel = new JPanel();
+				JLabel Text = new JLabel();
+				Text.setText("<html><p>Renommer le fichier d'analyse avec le nom : </p></html>");
+				panel.add(Text);
+
+
+				nomFichierAnalyse = JOptionPane.showInputDialog(null,panel, nomFichierAnalyse);
+				
+				if(nomFichierAnalyse!=null) {
+					if(nomFichierAnalyse!=null) {
+						if(!nomFichierAnalyse.isBlank()) {		
+							 Pattern pt = Pattern.compile("\\.xml$");
+						     Matcher match= pt.matcher(nomFichierAnalyse);
+						     if(!match.find()) {
+						    	 nomFichierAnalyse = nomFichierAnalyse + ".xml";
+						     }
+						     evaluation.retourneFirstEnfantsByName("fichier").getAttributs().put("analysis_filename", nomFichierAnalyse);
+						     evaluation.retourneFirstEnfantsByName("fichier").getAttributs().put("filenameAnalyse", nomFichierAnalyse);
+						     evaluation.getAttributs().put("analysis_filename", nomFichierAnalyse);
+							
+						     
+						     new creerNouvelleEvaluation(evaluation);
+						     
+						     new recupeNodeBaseEvaluations();
+						     
+							model.addOrUpdate();
+							table.setModel(model);		
+						}
+					}
+				}
+
+			}	
+		}
+	});
+	 
+	/**
+	 * Renommer une évaluation sélectionnée.
+	 */
+	btnRenommerEvaluation.addActionListener(new ActionListener() {
+		public void actionPerformed(ActionEvent e) {
+			if(lsm!=null)if (!lsm.isSelectionEmpty()) {
+				indexSelect = lsm.getMinSelectionIndex();
+				node evaluation = chargeEvaluation.retourneEvaluationSelected(indexSelect);
+				String nomEvaluation = "";
+				if(evaluation.getAttributs().get("name")!=null) {
+					nomEvaluation = evaluation.getAttributs().get("name");
+				}			
+				nomEvaluation = JOptionPane.showInputDialog(null,"Renommer cette évaluation ?",nomEvaluation);
+				if(!nomEvaluation.isBlank()) {		
+					evaluation.getAttributs().put("name",nomEvaluation);
+					new creerNouvelleEvaluation(evaluation);
+					new recupeNodeBaseEvaluations();
+					model.addOrUpdate();
+					table = new JTable(model);
+				}
+			}
+		}
+	});
+	
+}
+
+
+}

src/fenetres/chargeBaseAuDemarrage.java

@@ -0,0 +1,178 @@
+package fenetres;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.FlowLayout;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingConstants;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import baseEvaluation.myTableBaseEvaluation;
+import fenetres.create_act.actOpenBaseEvaluation;
+import net.miginfocom.swing.MigLayout;
+
+public class chargeBaseAuDemarrage extends JFrame {
+
+	private static final long serialVersionUID = 1L;
+	private myTableBaseEvaluation model = new myTableBaseEvaluation();
+	private JTable table= new JTable();
+	private JPanel panelHaut = new JPanel();
+	private JPanel panelBas = new JPanel();
+	JLabel lblInformationBaseEvluation = new JLabel("");
+	int indexSelect=0;
+	ListSelectionModel lsm = null;
+	JScrollPane scrollPane = new JScrollPane();
+	private final JButton btnCheminVersBaseDonnees = new JButton("<html>Travailler avec une autre base<br>d'évaluation</html>");
+	private final JPanel panelGauche = new JPanel();
+	private final JPanel panelDroite = new JPanel();
+	private final JLabel label = new JLabel(calc.commandes.PathBaseEvaluations);
+	
+	public chargeBaseAuDemarrage() {
+	    setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+		
+		setBounds(100, 100, 1200, 600);
+		int screenWidth = (int) java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds().getWidth();
+		int screenHeight = (int) java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds().getHeight();
+		setLocation(( (screenWidth) - getWidth()) / 2, (screenHeight - getHeight()) / 2);
+		
+		ImageIcon img = new ImageIcon(getClass().getResource("/resources/evalwriter.png") );
+		setIconImage(img.getImage());
+		setTitle(calc.commandes.Titre + " - La base de données des évaluations");
+		
+		getContentPane().setLayout(new BorderLayout(2, 2));
+		
+	
+	
+		model.addOrUpdate();
+		table = new JTable(model);
+	    scrollPane = new JScrollPane(table);
+	 
+	    //Add the scroll pane to this panel.
+	    getContentPane().add(scrollPane,BorderLayout.CENTER);
+		panelBas.setLayout(new MigLayout("", "[394px][394px][]", "[53px]"));
+		
+		panelBas.add(label, "flowy,cell 0 0,grow");
+	
+	    
+		 getContentPane().add(panelBas, BorderLayout.SOUTH);
+		 btnCheminVersBaseDonnees.setForeground(new Color(0, 128, 192));
+		 btnCheminVersBaseDonnees.setFont(new Font("Tahoma", Font.BOLD, 16));
+		 btnCheminVersBaseDonnees.setIcon(new ImageIcon(chargeBaseAuDemarrage.class.getResource("/resources/sauvegardehistoriqueevaluation.png")));
+		 btnCheminVersBaseDonnees.setSelectedIcon(new ImageIcon(chargeBaseAuDemarrage.class.getResource("/resources/sauvegardehistoriqueevaluation.png")));
+		 panelBas.add(btnCheminVersBaseDonnees, "cell 2 0,alignx right,growy");
+		 lblInformationBaseEvluation.setIcon(new ImageIcon(chargeBaseAuDemarrage.class.getResource("/resources/accueilChargeEvaluation.png")));
+		 
+		 //*Le haut
+		lblInformationBaseEvluation.setHorizontalAlignment(SwingConstants.CENTER);
+		getContentPane().add(panelHaut, BorderLayout.NORTH);
+		lblInformationBaseEvluation.setFont(new Font("Tahoma", Font.BOLD, 16));
+		panelHaut.add(lblInformationBaseEvluation);
+		
+		
+		//*Détection de la ligne sélectionnée
+		table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		FlowLayout flowLayout_1 = (FlowLayout) panelGauche.getLayout();
+		flowLayout_1.setHgap(10);
+		
+		getContentPane().add(panelGauche, BorderLayout.WEST);
+		FlowLayout flowLayout = (FlowLayout) panelDroite.getLayout();
+		flowLayout.setHgap(10);
+		
+		getContentPane().add(panelDroite, BorderLayout.EAST);
+	    ListSelectionModel rowSM = table.getSelectionModel();
+	    rowSM.addListSelectionListener(new ListSelectionListener() {
+			@Override
+			public void valueChanged(ListSelectionEvent e) {
+				//Ignore extra messages.
+	            if (e.getValueIsAdjusting()) return;
+	            lsm = (ListSelectionModel)e.getSource();
+	            if (lsm.isSelectionEmpty()) {
+	                System.out.println("No rows are selected.");
+	            } else {
+	            	indexSelect = lsm.getMinSelectionIndex();
+	                System.out.println("Row " + indexSelect + " is now selected.");
+	            }
+			}
+	    });
+	    
+		ListenerAction();
+		setVisible(true);
+	    
+	}
+
+
+
+private void ListenerAction() {
+	
+	/**
+	 * Quitter le fenêtre.</br>
+	 */
+	addWindowListener(new java.awt.event.WindowAdapter() {
+	    @Override
+	    public void windowClosing(java.awt.event.WindowEvent windowEvent) {
+	    	mainApp.getInstance();
+	    	dispose();
+	    }
+	});
+	
+
+	
+	/**
+	 * Chargement d'une évaluation par double click.
+	 */
+	table.addMouseListener(new MouseAdapter() {
+
+		@Override
+		public void mouseClicked(MouseEvent e) {
+	        if (e.getClickCount() == 2) {
+				if (e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) {
+					 System.out.println("double clicked");
+					if(lsm!=null) {
+						 if (!lsm.isSelectionEmpty()) {
+							 indexSelect = lsm.getMinSelectionIndex();
+							 chargeEvaluation.chargeEnMémoireEvaluationSelected(indexSelect);
+							 calc.commandes.IndexEvaluationCharger = indexSelect;
+							 evaluate.getInstance();
+							 dispose();
+						 }
+					}
+				}
+	        }
+		}
+	  });
+
+	
+	 /**
+	  * Bouton chargement depuis un autre emplacement de la base de données.
+	  */
+	 btnCheminVersBaseDonnees.addActionListener(new ActionListener() {
+		public void actionPerformed(ActionEvent e) {
+			new ChargePathBaseEvaluation(false);
+			if(!ChargePathBaseEvaluation.isErreurLecture()) {
+				new actOpenBaseEvaluation();
+				label.setText(calc.commandes.PathBaseEvaluations);
+				model.addOrUpdate();
+				table = new JTable(model);
+				revalidate();
+			}
+		}
+	 });
+	 
+	
+}
+
+
+}

src/fenetres/create_act/actOpenBaseEvaluation.java

@@ -0,0 +1,47 @@
+package fenetres.create_act;
+
+import java.awt.event.ActionEvent;
+import java.text.ParseException;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.ImageIcon;
+
+import analyseWriter.baseEvaluations.recupeNodeBaseEvaluations;
+import xml.node;
+
+public class actOpenBaseEvaluation extends AbstractAction{
+	{
+        putValue( Action.NAME, "Charger une évaluation" );
+        putValue( Action.SMALL_ICON, new ImageIcon(fenetres.create.class.getResource("/resources/BaseEvaluationsmini.png")) );
+        putValue( Action.SHORT_DESCRIPTION, "Charger une évaluation" );
+    }
+	private static final long serialVersionUID = 1L;
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		new recupeNodeBaseEvaluations();
+		if(calc.commandes.evaluationsBase!=null) {
+			baseDonneesEvaluations.getInstance();
+		}else {
+			creationNewNodeBaseEvaluation();
+			baseDonneesEvaluations.getInstance();
+		}
+	}
+	
+
+	/**
+	 * Création d'un nouveau node evaluationBase.<br>
+	 */
+	private void creationNewNodeBaseEvaluation() {
+		calc.commandes.evaluationsBase = new node();
+		calc.commandes.evaluationsBase.setNameNode("evaluations");
+		try {
+			calc.commandes.evaluationsBase.getAttributs().put("date", calcul.formatDateWriter.dateTodayLibreOffice());
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		
+	}
+	
+}

src/xml/node.java

@@ -13,6 +13,8 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 
 
@@ -876,6 +878,32 @@ private boolean nodeClose = false;
 			 }
 			 return false;
 		 }
+		 
+		 
+			/**
+			 * Cette méthode permet de lire uniquement les nodes evaluations.
+			 * @param code
+			 * @return
+			 */
+			public node allFirstNodesEvaluationFichierOnly(String code) {
+				node evaluations = new node();
+				evaluations.setNameNode("evaluationsCalc");
+				Pattern p = Pattern.compile("<\\bevaluation\\b.*?<\\bfichier\\b.*?>");
+				Matcher m = p.matcher(code.trim());
+				StringBuilder LesEvals = new StringBuilder();
+				while(m.find()) {
+					LesEvals.append(code.substring(m.start(), m.end())+"</fichier></evaluation>");
+				}
+				node nodRetourne = new node("<!-- A -->"+LesEvals.toString().replaceAll(">/{1,}<", "><")); //Le node A est nécessaire.
+				if(nodRetourne.getNameNode().equals("fichier")) {
+					evaluations.getEnfants().addAll(nodRetourne.getEnfants());
+				}else {
+					evaluations.getEnfants().add(nodRetourne);
+				}
+				 //nécessaire pour la reconnaissance du node de donner le nom evaluations avec un s
+				return evaluations;
+			}
+		 
 		
 		
 }