src/main/java/edu/mermet/tp8/ActionFonctionnalite.java

+package edu.mermet.tp8;
+
+import java.awt.event.ActionEvent;
+import java.util.ResourceBundle;
+
+import javax.swing.AbstractAction;
+
+public abstract class ActionFonctionnalite extends AbstractAction {
+
+	Application app;
+	String nomFonctionnalite;
+	float complexite;
+	
+	public ActionFonctionnalite(String nomFonc, Application a) {
+		super(nomFonc);
+		app = a;
+		nomFonctionnalite = nomFonc;
+		ResourceBundle b = ResourceBundle.getBundle("fonctionnalites");
+		complexite = Float.parseFloat(b.getString(nomFonc.replace(' ', '_')));
+	}
+	
+	public void xp() {
+		Preferences.getInstance().upNiveau(complexite / 10);
+		Preferences.getInstance().persist();
+		app.refreshMenuMode();
+	}
+
+}

src/main/java/edu/mermet/tp8/Application.java

@@ -5,6 +5,15 @@ import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.InputEvent;
 import java.awt.event.KeyEvent;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Properties;
+import java.util.ResourceBundle;
+
 import javax.swing.AbstractAction;
 import javax.swing.Action;
 import javax.swing.JDesktopPane;
@@ -16,16 +25,25 @@ import javax.swing.JMenuItem;
 import javax.swing.KeyStroke;
 import javax.swing.SwingUtilities;
 
+import edu.mermet.tp8.aide.ConfigurationMenus;
+import edu.mermet.tp8.aide.FenetreHowTo;
+import edu.mermet.tp8.aide.FenetreSuggestion;
 import edu.mermet.tp8.fenetres.FenetreBoutons;
 import edu.mermet.tp8.fenetres.FenetreConversion;
 import edu.mermet.tp8.fenetres.FenetreDiaporama;
 import edu.mermet.tp8.fenetres.FenetreTexte;
+import edu.mermet.tp8.Preferences;
 
 /**
  *
  * @author brunomermet
  */
 public class Application extends JFrame {
+	
+	public final static String MENU_MODE_AUTO = "auto";
+	public final static String MENU_MODE_AFFICHE = "affichée";
+	public final static String MENU_MODE_CACHE = "cachée";
+	
     private JInternalFrame conversion;
     private JInternalFrame texte;
     private JInternalFrame diaporama;
@@ -34,6 +52,12 @@ public class Application extends JFrame {
     private Action actionAfficherTexte;
     private Action actionAfficherDiaporama;
     private Action actionAfficherBoutons;
+    private Action actionHowTo;
+    private Action actionConfigurationMenus;
+    JMenuItem itemConversion;
+    JMenuItem itemTexte;
+    JMenuItem itemDiaporama;
+    JMenuItem itemBoutons;
     public Application() {
         super("multi-fenêtres");
         this.setContentPane(new JDesktopPane());
@@ -44,13 +68,7 @@ public class Application extends JFrame {
         JMenu menuFichier = new JMenu("Fichier");
         menuFichier.setMnemonic(KeyEvent.VK_F);
         JMenuItem quitter = new JMenuItem("Quitter");
-        quitter.addActionListener (new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent aev) {
-                System.exit(0);
-            }
-        });
-        quitter.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q, InputEvent.CTRL_DOWN_MASK));
+        quitter.addActionListener (new ActionQuitter());
         menuFichier.add(quitter);
         barre.add(menuFichier);
         this.setJMenuBar(barre);
@@ -58,18 +76,29 @@ public class Application extends JFrame {
         JMenu menuApplication = new JMenu("Applications");
         menuApplication.setMnemonic(KeyEvent.VK_A);
         actionAfficherConversion = new ActionAfficherConversion();
-        JMenuItem itemConversion = new JMenuItem(actionAfficherConversion);
+        itemConversion = new JMenuItem(actionAfficherConversion);
         menuApplication.add(itemConversion);
         actionAfficherTexte = new ActionAfficherTexte();
-        JMenuItem itemTexte = new JMenuItem(actionAfficherTexte);
+        itemTexte = new JMenuItem(actionAfficherTexte);
         menuApplication.add(itemTexte);
         actionAfficherDiaporama = new ActionAfficherDiaporama();
-        JMenuItem itemDiaporama = new JMenuItem(actionAfficherDiaporama);
+        itemDiaporama = new JMenuItem(actionAfficherDiaporama);
         menuApplication.add(itemDiaporama);
         actionAfficherBoutons = new ActionAfficherBoutons();
-        JMenuItem itemBoutons = new JMenuItem(actionAfficherBoutons);
+        itemBoutons = new JMenuItem(actionAfficherBoutons);
         menuApplication.add(itemBoutons);
+        refreshMenuMode();
         barre.add(menuApplication);
+        // ------ menu Aide ------
+        JMenu menuAide = new JMenu("Aide");
+        menuAide.setMnemonic(KeyEvent.VK_H); // "Help"
+        actionHowTo = new ActionHowTo();
+        JMenuItem itemHowTo = new JMenuItem(actionHowTo);
+        menuAide.add(itemHowTo);
+        actionConfigurationMenus = new ActionConfigurationMenus();
+        JMenuItem itemConfigurationMenus = new JMenuItem(actionConfigurationMenus);
+        menuAide.add(itemConfigurationMenus);
+        barre.add(menuAide);
         // ****** Fin barre de menu ******
         
         // ****** Création des fenêtres ******
@@ -90,61 +119,133 @@ public class Application extends JFrame {
         setSize(600,300);
         this.setLocationRelativeTo(null);
         setVisible(true);
+        new FenetreSuggestion(this);
+    }
+
+    public void refreshMenuMode() {
+    	// System.getenv("HOME") ne fonctionne pas sur ma machine
+    	Preferences pref = Preferences.getInstance();
+    	try {
+			itemConversion.setVisible(shouldHide(pref.getProperty("Conversion/MenuMode"), "Conversion Celsius/Farenheit"));
+			itemTexte.setVisible(shouldHide(pref.getProperty("Saisie de Texte/MenuMode"), "Saisie de texte"));
+			itemDiaporama.setVisible(shouldHide(pref.getProperty("Diaporama/MenuMode"), "Diaporama"));
+			itemBoutons.setVisible(shouldHide(pref.getProperty("Boutons/MenuMode"), "Boutons"));
+    	} catch(Exception e) {
+    		e.printStackTrace();
+    		System.err.println("Impossible d'utiliser les données de l'utilisateur");
+    	}
     }
+    
+    private static boolean shouldHide(String menuMode, String nomFonc) {
+    	switch(menuMode) {
+    	case MENU_MODE_AFFICHE:
+    		return true;
+		case MENU_MODE_CACHE:
+    		return false;
+		default: 
+    	case MENU_MODE_AUTO:
+    		ResourceBundle b = ResourceBundle.getBundle("fonctionnalites");
+    		Float niveauRequis = Float.parseFloat(b.getString(nomFonc.replace(' ', '_')));
+    		return Preferences.getInstance().getNiveau() >= niveauRequis;
+    	}
+    }
+
+    private class ActionQuitter extends ActionFonctionnalite {
+        public ActionQuitter() {
+            super("Quitter", Application.this);
+            putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_Q, InputEvent.CTRL_DOWN_MASK));
+        }
 
-    private class ActionAfficherBoutons extends AbstractAction {
+        @Override
+        public void actionPerformed(ActionEvent ae) {
+            xp();
+            System.exit(0);
+        }
+    }
+    
+	private class ActionAfficherBoutons extends ActionFonctionnalite {
         public ActionAfficherBoutons() {
-            super("Boutons");
-            putValue(Action.ACCELERATOR_KEY,KeyStroke.getKeyStroke(KeyEvent.VK_B, InputEvent.CTRL_DOWN_MASK));
-            putValue(Action.MNEMONIC_KEY,KeyEvent.VK_B);
+            super("Boutons", Application.this);
+            putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_B, InputEvent.CTRL_DOWN_MASK));
+            putValue(Action.MNEMONIC_KEY, KeyEvent.VK_B);
         }
 
         @Override
         public void actionPerformed(ActionEvent ae) {
             boutons.setVisible(true);
             enableBoutons(false);
+            xp();
         }
     }
-
-    private class ActionAfficherDiaporama extends AbstractAction {
+	
+    private class ActionAfficherDiaporama extends ActionFonctionnalite {
         public ActionAfficherDiaporama() {
-            super("Diaporama");
-            putValue(Action.ACCELERATOR_KEY,KeyStroke.getKeyStroke(KeyEvent.VK_D, InputEvent.CTRL_DOWN_MASK));
-            putValue(Action.MNEMONIC_KEY,KeyEvent.VK_D);
+            super("Diaporama", Application.this);
+            putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_D, InputEvent.CTRL_DOWN_MASK));
+            putValue(Action.MNEMONIC_KEY, KeyEvent.VK_D);
         }
 
         @Override
         public void actionPerformed(ActionEvent ae) {
             diaporama.setVisible(true);
             enableDiaporama(false);
+            xp();
         }
     }
 
-    private class ActionAfficherTexte extends AbstractAction {
+    private class ActionAfficherTexte extends ActionFonctionnalite {
         public ActionAfficherTexte() {
-            super("Saisie de texte");
-            putValue(Action.ACCELERATOR_KEY,KeyStroke.getKeyStroke(KeyEvent.VK_T, InputEvent.CTRL_DOWN_MASK));
-            putValue(Action.MNEMONIC_KEY,KeyEvent.VK_T);
+            super("Saisie de texte", Application.this);
+            putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_T, InputEvent.CTRL_DOWN_MASK));
+            putValue(Action.MNEMONIC_KEY, KeyEvent.VK_T);
         }
 
         @Override
         public void actionPerformed(ActionEvent ae) {
             texte.setVisible(true);
             enableTexte(false);
+            xp();
         }
     }
     
-    public class ActionAfficherConversion extends AbstractAction {
+    public class ActionAfficherConversion extends ActionFonctionnalite {
         public ActionAfficherConversion() {
-            super("Conversion Celsius/Farenheit");
-            putValue(Action.ACCELERATOR_KEY,KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.CTRL_DOWN_MASK));
-            putValue(Action.MNEMONIC_KEY,KeyEvent.VK_C);
+            super("Conversion Celsius/Farenheit", Application.this);
+            putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.CTRL_DOWN_MASK));
+            putValue(Action.MNEMONIC_KEY, KeyEvent.VK_C);
         }
 
         @Override
         public void actionPerformed(ActionEvent ae) {
             conversion.setVisible(true);
             enableConversion(false);
+            xp();
+        }
+    }
+    
+    private class ActionHowTo extends AbstractAction {
+        public ActionHowTo() {
+            super("Comment faire ?");
+            putValue(Action.ACCELERATOR_KEY,KeyStroke.getKeyStroke(KeyEvent.VK_F, InputEvent.CTRL_DOWN_MASK));
+            putValue(Action.MNEMONIC_KEY,KeyEvent.VK_F);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent ae) {
+            new FenetreHowTo(Application.this);
+        }
+    }
+    
+    private class ActionConfigurationMenus extends AbstractAction {
+        public ActionConfigurationMenus() {
+            super("Configuration des menus");
+            putValue(Action.ACCELERATOR_KEY,KeyStroke.getKeyStroke(KeyEvent.VK_G, InputEvent.CTRL_DOWN_MASK));
+            putValue(Action.MNEMONIC_KEY,KeyEvent.VK_G);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent ae) {
+            new ConfigurationMenus(Application.this);
         }
     }
 
@@ -178,6 +279,5 @@ public class Application extends JFrame {
     public static void main(String[] args) {
         SwingUtilities.invokeLater(Application::new);
     }
-
     
 }

src/main/java/edu/mermet/tp8/Preferences.java

+package edu.mermet.tp8;
+
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Properties;
+import java.util.Set;
+
+import edu.mermet.tp8.Application;
+
+public class Preferences {
+	
+	static Preferences instance;
+	Properties prefUtilisateur;
+	String path;
+
+	
+	private Preferences() {	
+		prefUtilisateur = new Properties();
+		path =  System.getProperty("user.home") + "/.ihm/" + System.getProperty("user.name") + ".xml";
+		try {
+			File donneesUtilisateur = new File(path);
+			if(!donneesUtilisateur.exists()) {
+				File ihmDirectory = new File(System.getProperty("user.home") + "/.ihm");
+				if(!Files.isDirectory(ihmDirectory.toPath())) {
+					Files.createDirectory(ihmDirectory.toPath());
+				}
+				System.out.println("ah bah non");
+				OutputStream os = new FileOutputStream(donneesUtilisateur);
+				prefUtilisateur.setProperty("Conversion/MenuMode", Application.MENU_MODE_AUTO);
+				prefUtilisateur.setProperty("Saisie de Texte/MenuMode", Application.MENU_MODE_AUTO);
+				prefUtilisateur.setProperty("Diaporama/MenuMode", Application.MENU_MODE_AUTO);
+				prefUtilisateur.setProperty("Boutons/MenuMode", Application.MENU_MODE_AUTO);
+				prefUtilisateur.setProperty("Niveau", String.valueOf(1.));
+				prefUtilisateur.storeToXML(os, null, "UTF-8");
+			} else {
+				prefUtilisateur.loadFromXML(new FileInputStream(new File(path)));
+			}
+		} catch(Exception e) {
+			e.printStackTrace();
+			System.out.println("Impossible d'utiliser les données de l'utilisateur");
+		}
+	}
+	
+	public static Preferences getInstance() {
+		if(instance == null)
+			instance = new Preferences();
+		return instance;
+	}
+	
+	public Collection<String> getSuggestionIndesirables() {
+		String suggInd  = prefUtilisateur.getProperty("SuggestionsIndesirables");
+		if(suggInd == null) {
+			return new ArrayList<>();
+		} else {
+			String[] res = suggInd.split(",");
+			return new ArrayList<>(Arrays.asList(res));
+		}
+	}
+	
+	public void addSuggestionIndesirable(String keySuggestion) {
+		String suggInd  = prefUtilisateur.getProperty("SuggestionsIndesirables");
+		if("".equals(suggInd) || suggInd == null)
+			suggInd = keySuggestion;
+		else
+			suggInd += "," + keySuggestion;
+		prefUtilisateur.setProperty("SuggestionsIndesirables", suggInd);
+	}
+	
+	public void setProperty(String key, String value) {
+		prefUtilisateur.setProperty(key, value);
+	}
+	
+	public String getProperty(String key) {
+		return prefUtilisateur.getProperty(key);
+	}
+	
+	public Set<String> getMenuModeSet() {
+		Set<Object> propertiesNames = prefUtilisateur.keySet();
+    	Set<String> MenuModeNames = new HashSet<>();
+    	for(Object name : propertiesNames) {
+    		if(((String) name).contains("/MenuMode")) {
+    			MenuModeNames.add((String) name);
+    		}
+    	}
+    	return MenuModeNames;
+	}
+	
+	public float getNiveau() {
+		return Float.parseFloat(prefUtilisateur.getProperty("Niveau"));
+	}
+	
+	public void upNiveau(float xp) {
+		float niveauActuel = getNiveau();
+		prefUtilisateur.setProperty("Niveau", String.valueOf(niveauActuel + xp));
+	}
+	
+	public void persist() {
+		try {
+			prefUtilisateur.storeToXML(new FileOutputStream(new File(path)), null);
+		} catch (Exception e) {
+			e.printStackTrace();
+			System.out.println("Impossible d'utiliser les données de l'utilisateur");
+		}
+	}
+}

src/main/java/edu/mermet/tp8/aide/ConfigurationMenus.java

+package edu.mermet.tp8.aide;
+
+import java.awt.BorderLayout;
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Properties;
+import java.util.Set;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.ButtonGroup;
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JRadioButton;
+import javax.swing.KeyStroke;
+
+import edu.mermet.tp8.Application;
+import edu.mermet.tp8.Preferences;
+
+public class ConfigurationMenus extends JDialog {
+	
+	Application application;
+	
+	//tableau radio buttons
+	JPanel tableauRadio;
+	// Configuration de menus
+	Map<String, ButtonGroup> choixMenu; 
+	
+	//Barre de boutons
+	JPanel boutons;
+	JButton boutonValider;
+	JButton boutonAnnuler;
+	
+	public ConfigurationMenus(Application application) {
+		super(application, true);
+		this.application = application;
+		init();
+		setTitle("Configuration des menus");
+		pack();
+		setLocationRelativeTo(null);
+		setVisible(true);
+	}
+	
+	private void init() {
+		try {
+			Preferences pref = Preferences.getInstance();
+	    	Set<String> MenuModeNames = pref.getMenuModeSet();
+	    	choixMenu = new HashMap<>();
+			tableauRadio = new JPanel(new GridLayout(MenuModeNames.size(), 4));
+			for(String menuModeName : MenuModeNames) {
+				JLabel menuLabel = new JLabel(menuModeName.substring(0, menuModeName.length() - "/MenuMode".length()));
+				tableauRadio.add(menuLabel);
+				ButtonGroup menuRadio = new ButtonGroup();
+				JRadioButton autoButton = new JRadioButton("Auto");
+				autoButton.setActionCommand(Application.MENU_MODE_AUTO);
+				autoButton.setToolTipText("Le programme choisira d'afficher le menu en fonction du niveau de compétance de l'utilisateur");
+				menuRadio.add(autoButton);
+				tableauRadio.add(autoButton);
+				JRadioButton afficheButton = new JRadioButton("Affiché");
+				afficheButton.setActionCommand(Application.MENU_MODE_AFFICHE);
+				afficheButton.setToolTipText("Toujours affiché");
+				menuRadio.add(afficheButton);
+				tableauRadio.add(afficheButton);
+				JRadioButton cacheButton = new JRadioButton("Caché");
+				cacheButton.setActionCommand(Application.MENU_MODE_CACHE);
+				cacheButton.setToolTipText("Toujours caché");
+				menuRadio.add(cacheButton);
+				tableauRadio.add(cacheButton);
+				switch(pref.getProperty(menuModeName)) {
+				case Application.MENU_MODE_AUTO:
+					autoButton.setSelected(true);
+					break;
+				case Application.MENU_MODE_AFFICHE:
+					afficheButton.setSelected(true);
+					break;
+				case Application.MENU_MODE_CACHE:
+					cacheButton.setSelected(true);
+					break;
+				default:
+					autoButton.setSelected(true);
+				}
+				choixMenu.put(menuModeName, menuRadio);
+			}			
+			add(tableauRadio, BorderLayout.CENTER);
+			boutons = new JPanel();
+			boutonValider = new JButton(new ActionValider());
+			boutons.add(boutonValider);
+			boutonAnnuler = new JButton(new ActionAnnuler());
+			boutons.add(boutonAnnuler);
+			add(boutons, BorderLayout.SOUTH);
+		} catch(Exception e) {
+    		e.printStackTrace();
+    		System.err.println("Impossible d'utiliser les données de l'utilisateur");
+    		dispose();
+    	}
+	}
+	
+    private class ActionValider extends AbstractAction {
+        public ActionValider() {
+            super("Valider");
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent ae) {
+        	try {
+        		Preferences pref = Preferences.getInstance();
+	        	Set<Entry<String, ButtonGroup>> choix = choixMenu.entrySet();
+	        	for(Entry<String, ButtonGroup> entry : choix) {
+	        		pref.setProperty(entry.getKey() , entry.getValue().getSelection().getActionCommand());
+        		}
+	        	pref.persist();
+	            application.refreshMenuMode();
+	            dispose();
+        	} catch(Exception e) {
+        		e.printStackTrace();
+        		System.err.println("Impossible d'utiliser les données de l'utilisateur");
+        	}
+        }
+    }
+    
+    private class ActionAnnuler extends AbstractAction {
+        public ActionAnnuler() {
+            super("Annuler");
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent ae) {
+            dispose();
+        }
+    }
+}

src/main/java/edu/mermet/tp8/aide/FenetreHowTo.java

+package edu.mermet.tp8.aide;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.ResourceBundle;
+import java.util.Scanner;
+
+import javax.swing.BoxLayout;
+import javax.swing.JDialog;
+import javax.swing.JEditorPane;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.ListSelectionModel;
+
+import edu.mermet.tp8.Application;
+
+public class FenetreHowTo extends JDialog{
+	
+	JSplitPane contenu;
+	JEditorPane textes;
+	JList titres;
+	
+	public FenetreHowTo(Application parent) {
+		super(parent, false);
+		init();
+		setTitle("Comment faire ?");
+		pack();
+		setLocationRelativeTo(null);
+		setVisible(true);
+	}
+	
+	private void init() {
+		loadTitres();
+		titres.addListSelectionListener(e->{loadTexte((String) titres.getSelectedValue());});
+		titres.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		textes = new JEditorPane();
+		textes.setEditable(false);
+		textes.setContentType("text/html");
+		loadTexte("Default");
+		contenu = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
+		contenu.setLeftComponent(titres);
+		contenu.setRightComponent(textes);
+		setContentPane(contenu);
+	}
+
+	private void loadTexte(String titre) {
+		ResourceBundle b = ResourceBundle.getBundle("HowTo.textes");
+		textes.setText(b.getString(titre.replace(" ", "_")));
+	}
+
+	private void loadTitres() {
+		Collection<String> data = new ArrayList<>();
+		ResourceBundle b = ResourceBundle.getBundle("HowTo.titres");
+		Iterator<String> itRes = b.getKeys().asIterator();
+		while(itRes.hasNext())
+			data.add(b.getString(itRes.next()));
+		titres = new JList(data.toArray());
+	}
+}

src/main/java/edu/mermet/tp8/aide/FenetreSuggestion.java

+package edu.mermet.tp8.aide;
+
+import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Random;
+import java.util.ResourceBundle;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JPanel;
+import javax.swing.JTextArea;
+import javax.swing.KeyStroke;
+
+import edu.mermet.tp8.Application;
+import edu.mermet.tp8.Preferences;
+
+public class FenetreSuggestion extends JDialog {
+	
+	Application application;
+	JTextArea tipArea;
+	JPanel boutons;
+	JButton btnFermer;
+	JButton btnNePlusAfficher;
+	boolean visible;
+	String suggestionKey;
+	
+	public FenetreSuggestion(Application a){
+		super(a, true);
+		application = a;
+		visible = true;
+		init();
+		setTitle("Configuration des menus");
+		pack();
+		setLocationRelativeTo(null);
+		setVisible(visible);
+	}
+	
+	private void init() {
+		tipArea = new JTextArea(pickATip());
+		tipArea.setEditable(false);
+		add(tipArea, BorderLayout.CENTER);
+		boutons = new JPanel();
+		btnFermer = new JButton(new ActionFermer());
+		boutons.add(btnFermer);
+		btnNePlusAfficher = new JButton(new ActionNePlusAfficher());
+		boutons.add(btnNePlusAfficher);
+		add(boutons, BorderLayout.SOUTH);
+	}
+
+	private String pickATip() {
+		ResourceBundle bSug = ResourceBundle.getBundle("Suggestions.suggestions");
+		// Récupération des suggestion et Suppression des indésirables
+		ResourceBundle bComp = ResourceBundle.getBundle("suggestions.complexites");
+		List<String> suggPossibles = bSug.keySet().stream()
+			.filter(key -> Float.parseFloat(bComp.getString(key)) <= Preferences.getInstance().getNiveau())
+			.collect(Collectors.toList());
+		suggPossibles.removeAll(Preferences.getInstance().getSuggestionIndesirables());
+		//-----------------------------------------
+		if(suggPossibles.isEmpty()) {
+			visible = false;
+			return "Plus d'astuces pour vous :(";
+		}
+		return bSug.getString(suggPossibles.get(new Random().nextInt(suggPossibles.size())));
+	}
+	
+	public class ActionFermer extends AbstractAction {
+        public ActionFermer() {
+            super("Fermer");
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent ae) {
+            dispose();
+        }
+    }
+	
+	public class ActionNePlusAfficher extends AbstractAction {
+        public ActionNePlusAfficher() {
+            super("Ne plus afficher");
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent ae) {
+        	Preferences.getInstance().addSuggestionIndesirable(suggestionKey);
+        	Preferences.getInstance().persist();
+            dispose();
+        }
+    }
+}

src/main/java/edu/mermet/tp8/fenetres/FenetreBoutons.java

@@ -29,8 +29,11 @@ public class FenetreBoutons extends AbstractFenetreInterne {
         super(action, "Boutons");
         setLayout(new FlowLayout());
         boutonTexte = new JButton(appli.getActionAfficherTexte());
+        boutonTexte.setToolTipText("Outil de saisie de texte");
         boutonDiaporama = new JButton(appli.getActionAfficherDiaporama());
+        boutonDiaporama.setToolTipText("Visionnez un diaporama");
         boutonDegres = new JButton(appli.getActionAfficherConversion());
+        boutonDegres.setToolTipText("Outil de conversion de degrés Celsius/Farenheit");
         add(boutonDegres);
         add(boutonTexte);
         add(boutonDiaporama);

src/main/java/edu/mermet/tp8/fenetres/FenetreConversion.java

@@ -6,13 +6,21 @@ import java.awt.GridLayout;
 import java.awt.event.ActionEvent;
 import java.awt.event.FocusEvent;
 import java.awt.event.FocusListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
 import javax.swing.AbstractAction;
 import javax.swing.Action;
+import javax.swing.ImageIcon;
 import javax.swing.JButton;
 import javax.swing.JInternalFrame;
 import javax.swing.JLabel;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
 import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
 import javax.swing.JTextField;
+import javax.swing.SwingUtilities;
 import javax.swing.event.InternalFrameAdapter;
 import javax.swing.event.InternalFrameEvent;
 import edu.mermet.tp8.Application;
@@ -27,6 +35,8 @@ public class FenetreConversion extends AbstractFenetreInterne {
     private JButton boutonConvertir;
     private Action actionConvertir;
     private boolean celsiusAFocus;
+
+    
     public FenetreConversion(Action action) {
         super(action,"Conversion celsius/Farenheit");
         this.setSize(new Dimension(100,50));
@@ -35,9 +45,18 @@ public class FenetreConversion extends AbstractFenetreInterne {
         ligneCelsius.setLayout(new FlowLayout(FlowLayout.TRAILING));
         JLabel labCelsius = new JLabel("Celsius :");
         champCelsius = new JTextField(15);
+        champCelsius.setToolTipText("Valeur en Celsius, veillez entrer un format numérique");
         labCelsius.setLabelFor(champCelsius);
+        ImageIcon helpIcon = new ImageIcon("src/main/resources/Icons/HelpIcon.png");
+        JLabel iconeAideCelsius = new JLabel(helpIcon);
+        iconeAideCelsius.addMouseListener(new MouseAdapter() {
+            @Override public void mousePressed(MouseEvent event) {
+                JOptionPane.showMessageDialog(FenetreConversion.this, "Valeur en degré Celsius");
+            }
+        });
         ligneCelsius.add(labCelsius);
         ligneCelsius.add(champCelsius);
+        ligneCelsius.add(iconeAideCelsius);
         this.add(ligneCelsius);
         celsiusAFocus = true;
         champCelsius.addFocusListener(new EcouteurFocus(true));
@@ -45,9 +64,17 @@ public class FenetreConversion extends AbstractFenetreInterne {
         ligneFarenheit.setLayout(new FlowLayout(FlowLayout.TRAILING));
         JLabel labFarenheit = new JLabel("Farenheit :");
         champFarenheit = new JTextField(15);
+        champFarenheit.setToolTipText("Valeur en Farenheit, veillez entrer un format numérique");
         labFarenheit.setLabelFor(champFarenheit);
+        JLabel iconeAideFarenheit = new JLabel(helpIcon);
+        iconeAideFarenheit.addMouseListener(new MouseAdapter() {
+            @Override public void mousePressed(MouseEvent event) {
+                JOptionPane.showMessageDialog(FenetreConversion.this, "Valeur en degré Farenheit");
+            }
+        });
         ligneFarenheit.add(labFarenheit);
         ligneFarenheit.add(champFarenheit);
+        ligneFarenheit.add(iconeAideFarenheit);
         this.add(ligneFarenheit);
         champFarenheit.addFocusListener(new EcouteurFocus(false));
         JPanel ligneValider = new JPanel();
@@ -56,6 +83,31 @@ public class FenetreConversion extends AbstractFenetreInterne {
         boutonConvertir = new JButton(actionConvertir);
         ligneValider.add(boutonConvertir);
         this.add(ligneValider);
+        // Menus contextuels :
+        //  Celsius
+        JPopupMenu popupMenuCelsius = new JPopupMenu();
+        JMenuItem itemAideCelsius = new JMenuItem("Aide");
+        itemAideCelsius.addActionListener((e)->{JOptionPane.showMessageDialog(this, "Valeur en degré Celsius");});
+        popupMenuCelsius.add(itemAideCelsius);
+        champCelsius.addMouseListener(new MouseAdapter() {
+            @Override public void mousePressed(MouseEvent event) {
+                if(event.isPopupTrigger() || SwingUtilities.isRightMouseButton(event)) {
+                	popupMenuCelsius.show(event.getComponent(), event.getX(), event.getY());
+                }
+            }
+        });
+        //  Farenheit
+        JPopupMenu popupMenuFarenheit = new JPopupMenu();
+        JMenuItem itemAideFarenheit = new JMenuItem("Aide");
+        itemAideFarenheit.addActionListener((e)->{JOptionPane.showMessageDialog(this, "Valeur en degré Farenheit");});
+        popupMenuFarenheit.add(itemAideFarenheit);
+        champFarenheit.addMouseListener(new MouseAdapter() {
+            @Override public void mousePressed(MouseEvent event) {
+                if(event.isPopupTrigger() || SwingUtilities.isRightMouseButton(event)) {
+                	popupMenuFarenheit.show(event.getComponent(), event.getX(), event.getY());
+                }
+            }
+        });
         
         pack();
         getRootPane().setDefaultButton(boutonConvertir);

src/main/resources/HowTo/textes.properties

+Default = <h1>Affichage de l'aide</h1>
+Comment_faire_? = <p>Pour afficher les aides, séléctionnez l'item <span style = "color: red">Comment faire ?</span> dans le menu <span style = "color: blue" >Aide</span></p>
+Quitter = <p>Pour <span style = "font-weight: bold;">Quitter</span> l'application, sélectionnez l'item <span style = "color: red">Quitter</span> dans le menu <span style = "color: blue">Fichier</span></p>
+conversion_Celsius_\u2192_Farenheit = c
+conversion_Farenheit_\u2192_Celsius = d
+mettre_du_texte_en_gras_dans_la_fenêtre_de_saisie_de_texte = e
+changer_la_couleur_du_texte_dans_la_fenêtre_de_saisie_de_texte = f
\ No newline at end of file

src/main/resources/HowTo/titres.properties

+0 = Comment faire ?
+1 = Quitter
+2 = conversion Celsius \u2192 Farenheit
+3 = conversion Farenheit \u2192 Celsius
+4 = mettre du texte en gras dans la fenêtre de saisie de texte
+5 = changer la couleur du texte dans la fenêtre de saisie de texte
\ No newline at end of file

src/main/resources/Suggestions/complexites.properties

+SUG1 = 4
+SUG2 = 8
+SUG3 = 4
+SUG4 = 2
+SUG5 = 1
+SUG6 = 1
+SUG7 = 1
+SUG8 = 4
+SUG9 = 8
+SUG10 = 4
+SUG11 = 2
\ No newline at end of file

src/main/resources/Suggestions/suggestions.properties

+SUG1 = Appuyez sur Ctrl + t pour ouvrir l'application de saisie de texte.
+SUG2 = Appuyez sur Ctrl + b pour ouvrir l'application de boutons.
+SUG3 = Appuyez sur Ctrl + c pour ouvrir l'application de conversion de degrés Celsius/Farenheit.
+SUG4 = Appuyez sur Ctrl + d pour ouvrir l'application de diaporama.
+SUG5 = Appuyez sur Ctrl + q pour quitter le programme.
+SUG6 = Appuyez sur Ctrl + f pour ouvrir le guide d'utilisation "Comment faire ?"
+SUG7 = Appuyez sur Ctrl + g pour ouvrir le menu de configuration des menus.
+SUG8 = L'option 'Conversion' permet de convertir des degrés Celsius en Farenheit ou inversement.
+SUG9 = L'option 'Boutons' permet d'afficher une barre de boutons pour accèder plus rapidement aux autres applications.
+SUG10 = L'option 'Saisie de texte' permet d'écrire du texte avec modification du style.
+SUG11 = L'option 'Diaporama' permet d'afficher un diaporama du Cotentin.
\ No newline at end of file

src/main/resources/fonctionnalites.properties

+#nom_fonctionnalit = niveau_de_complexit
+Quitter = 1
+Conversion_Celsius/Farenheit = 4
+Saisie_de_texte = 4
+Diaporama = 2
+Boutons = 8
\ No newline at end of file