Ajout de la JavaDoc sur les bouton,crud,fenetre modification et rappel.... + ajout du package

src/fr/iutfbleau/papillon/BtnAjouter.java

@@ -1,13 +1,38 @@
-// package fr.iutfbleau.papillon;
+package fr.iutfbleau.papillon;
 
+import java.util.ArrayList;
 import javax.swing.*;
-import java.awt.*;
 import java.awt.event.*;
+import java.awt.*;
 
+/**
+ * La classe <code>BtnAjouter</code> représente un bouton permettant
+ * d’ouvrir la fenêtre d’ajout d’un nouveau rappel dans l’application <b>Papillon</b>.
+ * <p>
+ * Lorsqu’un utilisateur clique sur ce bouton, une instance de la fenêtre
+ * <code>FenetreAjout</code> est affichée, tandis que la fenêtre principale est masquée.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */ 
 public class BtnAjouter extends JButton implements ActionListener{
 
+    /**
+     * Référence vers la fenêtre principale de l’application.
+     * Elle permet de gérer la visibilité des fenêtres lors de l’ajout d’un rappel.
+     */
     private Main main;
 
+    /**
+     * Construit un bouton "Ajouter" associé à la fenêtre principale.
+     * <p>
+     * Ce bouton est configuré avec une taille fixe et un écouteur d’action
+     * pour réagir aux clics de l’utilisateur.
+     * </p>
+     *
+     * @param main la fenêtre principale de l’application <b>Papillon</b>
+     */
     public BtnAjouter(Main main){
         super("Ajouter");
         this.main = main;
@@ -18,6 +43,17 @@ public class BtnAjouter extends JButton implements ActionListener{
         
     }
 
+    /**
+     * Méthode appelée lorsqu’un clic est détecté sur le bouton.
+     * <p>
+     * Ouvre une nouvelle fenêtre d’ajout (<code>FenetreAjout</code>),
+     * positionnée au même endroit que la fenêtre principale, puis
+     * masque cette dernière.
+     * </p>
+     *
+     * @param e l’événement d’action généré par le clic sur le bouton
+     */
+    @Override
     public void actionPerformed(ActionEvent e){
         if(e.getSource()==this){
             FenetreAjout f = new FenetreAjout(main);

src/fr/iutfbleau/papillon/BtnModifier.java

@@ -1,14 +1,46 @@
-import javax.swing.*;
+package fr.iutfbleau.papillon;
-import java.awt.*;
+
-import java.awt.event.*;
 import java.util.ArrayList;
+import javax.swing.*;
+import java.awt.event.*;
+import java.awt.*;
 import java.util.List;
 
+/**
+ * La classe <code>BtnModifier</code> représente un bouton permettant
+ * de modifier un rappel existant dans l’application <b>Papillon</b>.
+ * <p>
+ * Lorsqu’un utilisateur clique sur ce bouton, il vérifie qu’un seul rappel
+ * est sélectionné. Si c’est le cas, la fenêtre de modification
+ * (<code>FenetreModif</code>) s’ouvre pour permettre à l’utilisateur
+ * de modifier les informations du rappel choisi.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */
 public class BtnModifier extends JButton implements ActionListener {
 
+    /**
+     * Référence vers le rappel actuellement sélectionné.
+     */
     private Rappel rappel;
+    
+    /**
+     * Référence vers la fenêtre principale de l’application.
+     * Elle permet de gérer la visibilité des fenêtres lors de la modification d’un rappel.
+     */
     private final Main main;
 
+    /**
+     * Construit un bouton "Modifier" associé à la fenêtre principale.
+     * <p>
+     * Ce bouton est configuré avec une taille fixe et un écouteur d’action
+     * pour réagir aux clics de l’utilisateur.
+     * </p>
+     *
+     * @param main la fenêtre principale de l’application <b>Papillon</b>
+     */
     public BtnModifier(Main main) {
         super("Modifier");
         this.main = main;

src/fr/iutfbleau/papillon/BtnSupprimer.java

@@ -1,4 +1,4 @@
-// package fr.iutfbleau.papillon;
+package fr.iutfbleau.papillon;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -6,11 +6,40 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
 
+/**
+ * La classe <code>BtnSupprimer</code> représente un bouton permettant
+ * de supprimer un ou plusieurs rappels dans l’application <b>Papillon</b>.
+ * <p>
+ * Lorsqu’un utilisateur clique sur ce bouton, une boîte de confirmation
+ * s’affiche afin de valider la suppression. Si l’utilisateur confirme,
+ * les rappels sélectionnés sont supprimés de la liste.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */
 public class BtnSupprimer extends JButton implements ActionListener{
     
+    /**
+     * Gestionnaire des rappels permettant d’effectuer la suppression.
+     */
     private GestionRappel ges;
+
+    /**
+     * Référence vers la fenêtre principale de l’application.
+     * Elle permet de gérer la visibilité des fenêtres lors de la suppression d’un rappel.
+     */
     private Main main;
 
+    /**
+     * Construit un bouton "Supprimer" associé à la fenêtre principale.
+     * <p>
+     * Ce bouton est configuré avec une taille fixe et un écouteur d’action
+     * pour réagir aux clics de l’utilisateur.
+     * </p>
+     *
+     * @param main la fenêtre principale de l’application <b>Papillon</b>
+     */
     public BtnSupprimer(Main main){
         super("Supprimer");
         this.main = main;
@@ -19,6 +48,18 @@ public class BtnSupprimer extends JButton implements ActionListener{
         
         setFocusPainted(false);
     }
+
+    /**
+     * Gère l’action effectuée lors d’un clic sur le bouton.
+     * <p>
+     * Si aucun rappel n’est sélectionné, un message d’avertissement est affiché.
+     * Sinon, une boîte de dialogue de confirmation s’ouvre avant de procéder
+     * à la suppression des rappels choisis.
+     * </p>
+     *
+     * @param e l’événement d’action déclenché par un clic
+     */
+    @Override
     public void actionPerformed(ActionEvent e){
    
     if(e.getSource()==this){

src/fr/iutfbleau/papillon/Crud.java

@@ -1,14 +1,39 @@
-// package fr.iutfbleau.papillon;
+package fr.iutfbleau.papillon;
 
 import java.util.ArrayList;
 import javax.swing.*;
 
+/**
+ * La classe <code>Crud</code> regroupe les trois boutons principaux
+ * de gestion des rappels dans l’application <b>Papillon</b> :
+ * <ul>
+ *   <li><b>Ajouter</b> — pour créer un nouveau rappel,</li>
+ *   <li><b>Supprimer</b> — pour supprimer un ou plusieurs rappels,</li>
+ *   <li><b>Modifier</b> — pour éditer un rappel existant.</li>
+ * </ul>
+ * <p>
+ * Cette classe centralise leur création et leur ajout à l’interface.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */
 public class Crud extends ArrayList<JButton>{
 
+    /** Bouton d’ajout de rappel. */
     private BtnAjouter btnAjt;
+
+    /** Bouton de suppression de rappel. */
     private BtnSupprimer btnSpr;
+
+    /** Bouton de modification de rappel. */
     private BtnModifier btnMdf;
 
+    /**
+     * Constructeur de la barre d’actions CRUD.
+     *
+     * @param main la fenêtre principale de l’application <b>Papillon</b>
+     */
     public Crud(Main main){
         
 btnAjt = new BtnAjouter(main);

src/fr/iutfbleau/papillon/FenetreModif.java

@@ -1,19 +1,48 @@
+package fr.iutfbleau.papillon;
+
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * La classe <code>FenetreModif</code> permet d’afficher une fenêtre
+ * dédiée à la modification d’un rappel existant dans l’application <b>Papillon</b>.
+ * <p>
+ * Elle reprend les informations du rappel sélectionné et permet à l’utilisateur
+ * de les modifier avant de valider les changements.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */
 public class FenetreModif extends JFrame {
 
-
+    /** Gestionnaire des boutons de modification. */
     private GestionModif listBtnModif;
 
+    /** Champ de saisie pour le titre du rappel. */
     private final JTextField champTitre;
+
+    /** Champ de saisie pour le contenu du rappel. */
     private final JTextArea champContenu;
+
+    /** Liste de niveaux de priorité disponibles. */
     private Integer[] nombres = {1, 2, 3, 4, 5};
+
+    /** Sélecteur du niveau de priorité. */
     private JComboBox<Integer> rang = new JComboBox<>(nombres);
 
+    /** Liste des noms de thèmes disponibles. */
     private final String[] nomsCouleurs = {"Bleu", "Rouge", "Vert", "Jaune", "Rose"};
+
+    /** Sélecteur du thème du rappel. */
     private final JComboBox<String> comboTheme = new JComboBox<>(nomsCouleurs); 
 
+    /**
+     * Constructeur de la fenêtre de modification.
+     *
+     * @param parent la fenêtre principale de l’application <b>Papillon</b>
+     * @param rappel le rappel à modifier
+     */
     public FenetreModif(Main parent, Rappel rappel) {
         super("Modifier un rappel");
         ImageIcon logo = new ImageIcon("logo.png");
@@ -25,7 +54,7 @@ public class FenetreModif extends JFrame {
         setLocation(parent.getLocation()); // même position que Main
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
-        // UI
+        // Layout principal
         setLayout(new BorderLayout(10, 10));
         JPanel centre = new JPanel(new GridBagLayout());
         GridBagConstraints c = new GridBagConstraints();

src/fr/iutfbleau/papillon/FenetreRappel.java

@@ -1,14 +1,42 @@
+package fr.iutfbleau.papillon;
+
+import javax.swing.event.*;
+import java.awt.event.*;
 import javax.swing.*;
 import java.awt.*;
-import java.awt.event.*;
 
+/**
+ * La classe <code>FenetreRappel</code> représente la fenêtre d’affichage
+ * détaillée d’un rappel dans l’application <b>Papillon</b>.
+ * <p>
+ * Elle affiche les informations complètes du rappel sélectionné
+ * (titre, contenu, thème, et priorité) et permet à l’utilisateur
+ * de le modifier ou de fermer la fenêtre.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */
 public class FenetreRappel extends JFrame implements ActionListener{
 
+     /** Bouton permettant de fermer la fenêtre. */
     private final JButton btnFermer = new JButton("Fermer");
+
+    /** Bouton permettant d’ouvrir la fenêtre de modification du rappel. */
     private final JButton btnModifier = new JButton("Modifier");
+
+    /** Référence vers la fenêtre principale de l’application. */
     private final Main main;
+
+    /** Référence vers le rappel à afficher. */
     private Rappel rappel;
 
+    /**
+     * Constructeur de la fenêtre d’affichage d’un rappel.
+     *
+     * @param r le rappel à afficher
+     * @param main la fenêtre principale
+     */
     public FenetreRappel(Rappel r, Main main) {
         super("Rappel : " + r.getTitre());
         ImageIcon logo = new ImageIcon("logo.png");
@@ -73,6 +101,15 @@ public class FenetreRappel extends JFrame implements ActionListener{
         main.dispose();
     }
 
+    /**
+     * Gère les actions effectuées sur les boutons de la fenêtre.
+     * <ul>
+     *     <li><b>Fermer</b> : ferme la fenêtre actuelle.</li>
+     *     <li><b>Modifier</b> : ouvre la fenêtre de modification du rappel.</li>
+     * </ul>
+     *
+     * @param e l’événement d’action déclenché
+     */
     @Override
     public void actionPerformed(ActionEvent e) {
         if (e.getSource() == btnFermer) {

src/fr/iutfbleau/papillon/GestionModif.java

@@ -1,22 +1,66 @@
-import javax.swing.*;
+package fr.iutfbleau.papillon;
-import java.awt.event.*;
-import java.util.ArrayList;
 
+import java.util.ArrayList;
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+
+
+/**
+ * La classe <code>GestionModif</code> gère les boutons de la fenêtre
+ * de modification d’un rappel dans l’application <b>Papillon</b>.
+ * <p>
+ * Elle permet à l’utilisateur de valider ou d’annuler les changements
+ * effectués sur un rappel existant.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */
 public class GestionModif extends ArrayList<JButton> implements ActionListener{
 
+
+    /** Bouton de validation. */
     private final JButton boutonValider;
+
+    /** Bouton d'annulation. */
     private final JButton boutonAnnuler;
 
+    /** Champ de saisie pour le titre du rappel. */
     private final JTextField champTitre;
+
+    /** Champ de saisie pour le contenu du rappel. */
     private final JTextArea champContenu;
+
+    /** Sélecteur du niveau de priorité. */
     private JComboBox<Integer> rang;
+
+    /** Sélecteur du thème du rappel. */
     private final JComboBox<String> comboTheme;
+
+    /** Référence au rappel à modifier. */
     private Rappel rappel;
 
+    /** Gestionnaire des commandes agissant sur les rappels. */
     private final GestionRappel ges = new GestionRappel();
+
+    /** Référence à la fenêtre principale. */
     private final Main parent;
+
+    /** Référence à la fenêtre de modification. */
     private final JFrame f;    
 
+    /**
+     * Constructeur du gestionnaire de boutons pour la fenêtre de modification.
+     *
+     * @param f la fenêtre de modification
+     * @param parent la fenêtre principale
+     * @param champTitre le champ de texte pour le titre
+     * @param champContenu la zone de texte pour le contenu
+     * @param rang la liste déroulante de priorité
+     * @param comboTheme la liste déroulante du thème
+     * @param r le rappel à modifier
+     */
     public GestionModif(JFrame f, Main parent, JTextField champTitre, JTextArea champContenu, JComboBox<Integer> rang, JComboBox<String> comboTheme, Rappel r){
 
         this.f = f;
@@ -36,6 +80,15 @@ public class GestionModif extends ArrayList<JButton> implements ActionListener{
 
     }
 
+    /**
+     * Gère les actions effectuées sur les boutons de la fenêtre.
+     * <p>
+     * Si l’utilisateur clique sur <b>Annuler</b>, la fenêtre principale est réaffichée.  
+     * Si l’utilisateur clique sur <b>Valider</b>, les changements sont enregistrés.
+     * </p>
+     *
+     * @param e l’événement d’action déclenché par un bouton
+     */
     @Override
     public void actionPerformed(ActionEvent e) {
         Object src = e.getSource();

src/fr/iutfbleau/papillon/LimiteContenu.java

@@ -1,12 +1,40 @@
+package fr.iutfbleau.papillon;
+
 import javax.swing.text.*;
 
+/**
+ * La classe <code>LimiteContenu</code> permet de limiter le nombre
+ * de caractères pouvant être saisis dans un champ de texte Swing.
+ * <p>
+ * Elle hérite de <code>PlainDocument</code> et empêche toute insertion
+ * dépassant la limite définie.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */
 public class LimiteContenu extends PlainDocument {
+
+    /** Limite de caractères autorisés. */
     private int limite;
 
+    /**
+     * Constructeur qui définit la limite de caractères.
+     *
+     * @param limite le nombre maximum de caractères autorisés
+     */
     public LimiteContenu(int limite) {
         this.limite = limite;
     }
 
+    /**
+     * Insère une chaîne dans le document si elle ne dépasse pas la limite autorisée.
+     *
+     * @param offset la position d’insertion
+     * @param str la chaîne à insérer
+     * @param attr les attributs du texte
+     * @throws BadLocationException si la position est invalide
+     */
     @Override
     public void insertString(int offset, String str, AttributeSet attr)
             throws BadLocationException {

src/fr/iutfbleau/papillon/Start.java

@@ -1,6 +1,27 @@
+package fr.iutfbleau.papillon;
 
-
+/**
+ * La classe <code>Start</code> constitue le point d’entrée principal
+ * de l’application <b>Papillon</b>.
+ * <p>
+ * Elle initialise la fenêtre principale et lance l’interface graphique
+ * de l’application.
+ * </p>
+ *
+ * @version 1.0
+ * @author Seri-khane YOLOU, Aylane SEHL, Jenson VAL
+ */
 public class Start{
+    
+    /**
+     * Méthode principale exécutée au démarrage du programme.
+     * <p>
+     * Crée une instance de la fenêtre principale (<code>Main</code>)
+     * et l’affiche à l’écran.
+     * </p>
+     *
+     * @param args les arguments passés en ligne de commande (non utilisés)
+     */
     public static void main(String[] args) {
         Main f = new Main();
         f.setVisible(true);