Bonjour a tous,

Dans le cadre d'un TP en Java, je dois mettre en place une interface graphique représentant une mémoire (une ArrayList) constituée de blocs et donc ces blocs peuvent soit être des blocs vides (qui sont en fait des fichiers avec le nom "vide" et une taille donnée), soit peuvent être des fichiers (caractérisés par un nom et une taille)

En fait sur cette interface, on peut trouver :

+ Les 3/4 supérieurs de l'interface est en fait un dessin (qui doit être géré selon le TP par la classe Graphic) qui représente de gauche a droite la mémoire (l'arraylist) que l'on a et qui doit représenter les blocs (fichiers) vide par un rectangle de couleur claire (sur laquelle on écrit le nom "vide" et le taille de ce bloc) et les blocs non vides par des rectangles de couleur foncée (on écrit le nom du fichier et sa taille) et bien sur l'image représentant chaque bloc doit être proportionnelle en largeur a par rapport a la taille maximale de la mémoire.

+ Le 1/4 inférieur de l'interface est réservé au fonction Add et Remove qui sont en fait représentés par deux boutons :
-Add : ajoute dans la mémoire (d’après certaines conditions) le fichier dont on aura écrit le nom et la taille dans deux espaces JTextField précédant le bouton Add
-Remove : efface de la mémoire le fichier dont on aura écrit le nom dans un espace JTextField précédant le bouton Remove.

Donc, à chaque Add et Remove je dois redessiner la mémoire dans la partie supérieure .
Désole de la longueur mais je voulais expliquer le contexte du TP pour pouvoir poser mes questions : (Je travaille avec NetBeans)

1) Comment arriver a Dessiner sur la partie qui m’intéresse en sachant que j'ai déjà mis un JFrame pour la surface de toutes l'interface et un JPanel1 englobant toute cette surface et qui contient les boutons Add et Remove dans la partie inférieure. (je précise que mon interface est non redimensionnable)
[EDIT]Problème 1 résolu[/EDIT]

2) Ayant déjà développé la fonction qui gère l'ajout du fichier dans la mémoire et l'ayant testé hors de l'interface je ne remarque rien d'anormal , par contre quand je configure le bouton Add pour faire appel a cette méthode j'ai des résultats erroné alors que tout les paramètres sont passés correctement . (ayant fait plusieurs test sans succès je m'en remet a vous pour m'aider)

Remarque 1 : la fonction d'ajout est comme suit :

-Si un bloc vide contient assez de mémoire on met le fichier dedans et on génère un autre fichier vide contenant le reste.

-S'il n'y a aucun fichier vide contenant assez de mémoire pour le fichier , on défragmente la mémoire et on rassemble tout les blocs vide en un seul et effectue l'ajout si le nouveau bloc vide peut contenir la taille du fichier sinon on n'ajoute pas le fichier

Remarque 2 : l'ArrayList en question est un attribut de classe représentant l'interface de gestion de la mémoire, d’où le
this.memoire
Voici le code de la fonction ajouter de du bouton qui le gère :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
public ArrayList<Fichier> ajoutFichier(Fichier newFichier, ArrayList<Fichier> oldList) {
 
    int tailleVide = 0;
    ArrayList<Fichier> newList = oldList;
 
    boolean fichierAjoute = false;
    boolean fichierExistant = false;
    boolean memoireSaturee = true;
 
    for (int k = 0; k < newList.size(); k++) {
        if (newList.get(k).nomFichier.equalsIgnoreCase("Vide")) {
            memoireSaturee = false;
            k = newList.size();
        }
    }
 
 
    for (int j = 0; j < newList.size(); j++) {
        if (newList.get(j).nomFichier.equalsIgnoreCase(newFichier.nomFichier)) {
            fichierExistant = true;
            j = newList.size();
        }
    }
 
 
    if (!memoireSaturee)  {
        if (!fichierExistant) {
 
            for (int i = 0; i < newList.size() && !fichierAjoute; i++) {
 
                if (newList.get(i).nomFichier.equalsIgnoreCase("Vide") && newFichier.tailleFichier <= newList.get(i).tailleFichier && !fichierAjoute) {
 
                    newList.get(i).tailleFichier = newList.get(i).tailleFichier - newFichier.tailleFichier;
                    if (newList.get(i).tailleFichier == 0) newList.remove(i);
 
                    newList.add((i), newFichier);
                    i = newList.size();
                    fichierAjoute = true;
 
                    JOptionPane.showConfirmDialog(this, "Ajout reussi du fichier : " + newFichier.nomFichier + " de taille : " + newFichier.tailleFichier, "Ajout de Fichier", JOptionPane.PLAIN_MESSAGE, JOptionPane.INFORMATION_MESSAGE);
                }
            }
 
            if (!fichierAjoute) {
 
                JOptionPane.showConfirmDialog(this, "Espace insuffisant , la defragmentation aura lieu !", "Ajout de fichier", JOptionPane.PLAIN_MESSAGE, JOptionPane.WARNING_MESSAGE);
 
 
                for (int i = 0; i < newList.size(); i++) {
                    if (newList.get(i).nomFichier.equalsIgnoreCase("Vide")) {
                        tailleVide = tailleVide + newList.get(i).tailleFichier;
                        newList.remove(i);
 
                        if (i==0) i=0;
                        else i--;
 
                    }
                }
 
                Fichier videDefrag = new Fichier("Vide", tailleVide);
                newList.add(videDefrag);
 
                int lastIndexVide = (newList.size() - 1);
                if (newFichier.tailleFichier <= tailleVide) {
                    newList.add((lastIndexVide), newFichier);
                    newList.get(newList.lastIndexOf(videDefrag)).tailleFichier -= newFichier.tailleFichier;
                    if (newList.get(newList.lastIndexOf(videDefrag)).tailleFichier == 0) 
                            newList.remove(videDefrag);
 
                    JOptionPane.showConfirmDialog(this, "Ajout reussi du fichier : " + newFichier.nomFichier + " de taille : " + newFichier.tailleFichier, "Ajout de Fichier", JOptionPane.PLAIN_MESSAGE, JOptionPane.INFORMATION_MESSAGE);
 
                } else {
                    JOptionPane.showConfirmDialog(this, "Espace insuffisant meme apres la defragmentation !", "Ajout de fichier", JOptionPane.PLAIN_MESSAGE, JOptionPane.WARNING_MESSAGE);
                }
            }
        } else {
            JOptionPane.showConfirmDialog(this, "Fichier : "+newFichier.nomFichier+" déjà existant !", "Ajout de fichier", JOptionPane.PLAIN_MESSAGE, JOptionPane.WARNING_MESSAGE);
        }
    } else {
          JOptionPane.showConfirmDialog(this, "Memoire saturée !", "Ajout de fichier", JOptionPane.PLAIN_MESSAGE, JOptionPane.WARNING_MESSAGE);
    }
 
    return newList;
}
Et voici maintenant la méthode du bouton qui est censée gérer cet Ajout :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
private void boutonAjoutActionPerformed(java.awt.event.ActionEvent evt) {                                            
    int tailleFichier = 0;
    String nomFichier = new String();
    boolean nomCorrect = false;
    boolean tailleCorrecte = false;
 
    try {
        tailleFichier = Integer.parseInt(this.tailleFichierAjout.getText());
        tailleCorrecte = true;
        //if (tailleFichier > this.tailleFinaleMemoire) throw new TailleAjouterFichierException;
        //this.tailleFichierAjout.setEnabled(false);
    } catch (NumberFormatException e) {
        tailleCorrecte = false;
        JOptionPane.showMessageDialog(this, "Nombre non correct !", "Taille Fichier à ajouter", JOptionPane.ERROR_MESSAGE);
    }
 
    try {
        nomFichier = nomFichierAjout.getText();
        if (nomFichier.equals("")) {
            int x = 3/0;
        }
        else {
            nomCorrect = true;
        }
    } catch (Exception e) {
        nomCorrect = false;
        JOptionPane.showMessageDialog(this, "Nom non correct !", "Nom Fichier à ajouter", JOptionPane.ERROR_MESSAGE);//*/
    }
 
    if (tailleCorrecte && nomCorrect) {
 
        Fichier newFichier = new Fichier(nomFichier, tailleFichier);
        this.memoire = ajoutFichier(newFichier, this.memoire);
   }
}
Le problème est que quand j'affiche ma mémoire manuellement avec le System.out, je remarque que l'on a soustrait la taille du nouveau fichier de la taille de tous les blocs vides.

Quelqu'un saurait-il me guider ?

Merci d'avance pour votre aide.

PS : Je sais que ce code n'est pas très optimal mais je n'ai eu que 3 jours pour me familiariser avec le concept d'interface graphique et pour tout écrire...