griser un bouton après clic

Bonjour,

Je fait un jeu de lettres pour l'apprentissage de la lecture de mes enfants.

tout le code est sur mon github :
https://github.com/franckyy/jeux/tree/master/testZjeu

Je souhaite griser un bouton lorsqu'il aura été cliqué et mon problème est qu'aucun des boutons que je clique ne se grisent. Je dispose de boutons représentants toutes les lettres de l'alphabet et lorsque je clique sur une lettre, le bouton cliqué doit se griser.

Je reçois bien l’événement du clic bouton et je capte bien le JButton qui a été cliqué mais lorsque je fait le setEnabled(false), cela n'a aucun effet. Pourtant, j'ai bien vérifié au débugger d'éclipse que j'avais le même id de l'instance de JButton.

Pour bien comprendre, voici les classes que j'utilise avec des explications :
Tout d'abord, la classe qui me sert à construire mes boutons (cette classe est instanciée par le panneau qui s'ajoute lui même les boutons). j'y construit une HashMap<Character, JButton> qui est passé au panneau panelKeyboard pour qu'il ajoute les ActionListener et l'action command à chaque JButton.

Code:

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package com.francky.lettres.modele;
 
import java.util.HashMap;
 
import javax.swing.JButton;
 
import com.francky.lettres.ctrl.Ecouteur;
 
public class BoutonsMap {
 
	//DECLARATIONS
	private HashMap<Character, JButton> boutons;
 
	JButton btnA, btnB, btnC, btnD, btnE, btnF, btnG, btnH, btnI, btnJ, btnK, btnL
				, btnM, btnN, btnO, btnP, btnQ, btnR, btnS, btnT, btnU, btnV, btnW
				, btnX, btnY, btnZ, btnHelp;
 
	JButton btnVide, btnVide1, btnVide2;
 
	//CONSTRUCTEUR
	public BoutonsMap(Ecouteur btnListener) {
		super();
		boutons = new HashMap<Character, JButton>();
 
		boutons = remplissageBoutons();
	}
 
	//METHODES
	public HashMap<Character, JButton> remplissageBoutons(){
		btnA = new JButton("A");
		btnB = new JButton("B");
		btnC = new JButton("C");
		btnD = new JButton("D");
		btnE = new JButton("E");
		btnF = new JButton("F");
		btnG = new JButton("G");
		btnH = new JButton("H");
		btnI = new JButton("I");
		btnJ = new JButton("J");
		btnK = new JButton("K");
		btnL = new JButton("L");
		btnM = new JButton("M");
		btnN = new JButton("N");
		btnO = new JButton("O");
		btnP = new JButton("P");
		btnQ = new JButton("Q");
		btnR = new JButton("R");
		btnS = new JButton("S");
		btnT = new JButton("T");
		btnU = new JButton("U");
		btnV = new JButton("V");
		btnW = new JButton("W");
		btnX = new JButton("X");
		btnY = new JButton("Y");
		btnZ = new JButton("Z");
		btnHelp = new JButton("AIDE");
 
		btnVide = new JButton("");
		btnVide1 = new JButton("");
		btnVide2 = new JButton("");
 
 
		boutons.put('A', btnA);
		boutons.put('B', btnB);
		boutons.put('C', btnC);
		boutons.put('D', btnD);
		boutons.put('E', btnE);
		boutons.put('F', btnF);
		boutons.put('G', btnG);
		boutons.put('H', btnH);
		boutons.put('I', btnI);
		boutons.put('J', btnJ);
		boutons.put('K', btnK);
		boutons.put('L', btnL);
		boutons.put('M', btnM);
		boutons.put('N', btnN);
		boutons.put('O', btnO);
		boutons.put('P', btnP);
		boutons.put('Q', btnQ);
		boutons.put('R', btnR);
		boutons.put('S', btnS);
		boutons.put('T', btnT);
		boutons.put('U', btnU);
		boutons.put('V', btnV);
		boutons.put('W', btnW);
		boutons.put('X', btnX);
		boutons.put('Y', btnY);
		boutons.put('Z', btnZ);
		boutons.put('h', btnHelp);
		boutons.put('a', btnVide);
		boutons.put('b', btnVide1);
		boutons.put('c', btnVide2);
 
		return boutons;
	}
 
	public HashMap<Character, JButton> getBoutons() {
		return boutons;
	}
 
	public JButton getJBouton(String btnValue) {	
		return boutons.get(btnValue.charAt(0));
	}
 
	public void griserBouton(JButton jBouton) {
		jBouton.setEnabled(false);
	}
}

la classe PanelKeyboard qui instancie la classe BoutonsMap :

Code:

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package com.francky.lettres.vues.panneaux;
 
import java.awt.Dimension;
import java.awt.GridLayout;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
 
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
 
import com.francky.lettres.ctrl.Controleur;
import com.francky.lettres.ctrl.Ecouteur;
import com.francky.lettres.modele.BoutonsMap;
 
public class PanelKeyboard extends JPanel {
 
	/**
         * 
         */
	private static final long serialVersionUID = -4553507983435786002L;
 
	//************************************************************DECLARATIONS
 
	/*
	 * Nombre de touches dans le clavier
	 */
	private static final int ROWS_NUMBER = 6;
	private static final int COLS_NUMBER = 7;
 
	/*
	 * hauteur et largeur d'une touche de clavier en pixel
	 */
	private static final int KEY_HEIGHT = 50;
	private static final int KEY_WIDTH = 50;
 
	/*
	 * Marge autour d'une touche de clavier
	 */
	public static final int KEY_MARGE = 5;
	private static final int KEY_PANEL_MARGE_TOP = 5;
	private static final int KEY_PANEL_MARGE_BOTTOM = 5;
	private static final int KEY_PANEL_MARGE_LEFT = 5;
	private static final int KEY_PANEL_MARGE_RIGHT = 5;
 
	/*
	 * Calcul de la hauteur du panneaux clavier
	 * nombre de colonnes * hauteur d'une colonne + marge
	 */
	public static final int KEYBOARD_HEIGTH = ROWS_NUMBER * KEY_HEIGHT + KEY_MARGE;
	public static final int KEYBOARD_WIDTH = COLS_NUMBER * KEY_WIDTH + KEY_MARGE;
 
	/*
	 * Déclaration des boutons du clavier et d'une HashMap
	 */
 
	HashMap<Character, JButton> boutons;	//HashMap qui associe un JButton à une lettre de l'alphabet
	BoutonsMap bm;							//Création d'une instance de la classe BoutonsMap
	List<Character> lettres;				//Liste de toutes les lettres de l'alphabet
 
	/*
	 * Instanciation du controleur
	 */
	private Controleur ctrl;
	private Ecouteur btnListener;
 
 
	//************************************************************CONSTUCTEUR
	public PanelKeyboard(Controleur ctrl) {
		this.ctrl = ctrl;
		this.btnListener = new Ecouteur(ctrl);
 
		setPreferredSize(new Dimension(KEYBOARD_WIDTH, KEYBOARD_HEIGTH));
		setBackground(ctrl.COL_FOND);
 
		//paramétrage du layout du clavier
		setLayout(new GridLayout(ROWS_NUMBER, COLS_NUMBER, KEY_MARGE, KEY_MARGE));
 
		//Construction des boutons du clavier
		bm = new BoutonsMap(btnListener);					//Instanciation de BoutonsMap
 
		boutons = bm.getBoutons();				//chargement de la hashmap des boutons
		lettres = new ArrayList<Character>();	//instanciation de la liste des lettres
 
		//remplissage de la liste des lettres avec toutes les lettres de l'alphabet
		for(char alphabet = 'A'; alphabet <= 'Z';alphabet++) {
		    lettres.add(alphabet);
		}
 
		lettres.add('a');
		lettres.add('b');
		lettres.add('c');
		lettres.add('h');
 
		for(int i = 0; i < boutons.size(); i++){
			add(boutons.get(lettres.get(i)));
			boutons.get(lettres.get(i)).addActionListener(btnListener);
			boutons.get(lettres.get(i)).setActionCommand("" + lettres.get(i));
		}
 
		//définition d'une marge autour du panneau clavier
		setBorder(new EmptyBorder(KEY_PANEL_MARGE_TOP, KEY_PANEL_MARGE_LEFT, KEY_PANEL_MARGE_BOTTOM, KEY_PANEL_MARGE_RIGHT));
	}
 
	//************************************************************METHODES
	//modifier le background du panel
	public void modifieBackgroundColor() {
		setBackground(ctrl.COL_FOND);
	}
}

la classe Ecouteur, qui écoute les boutons et fait les demandes au Controleur lors des clics boutons ou lors d'un choix dans le menu (pour l'instant le choix dans le menu ne sert qu'à changer le thème des couleurs) :

Code:

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
package com.francky.lettres.ctrl;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
public class Ecouteur implements ActionListener {
 
	//DECLARATIONS
	Controleur ctrl;
 
	//CONSTRUCTEUR
	public Ecouteur(Controleur ctrl) {
		super();
		this.ctrl = ctrl;
	}
 
	@Override
	public void actionPerformed(ActionEvent e) {
		switch(e.getActionCommand()){
		case "A":
			//griser les boutons lorsqu'ils ont été cliqués
		case "B":
		case "C":
		case "D":
		case "E":
		case "F":
		case "G":
		case "H":
		case "I":
		case "J":
		case "K":
		case "L":
		case "M":
		case "N":
		case "O":
		case "P":
		case "Q":
		case "R":
		case "S":
		case "T":
		case "U":
		case "V":
		case "W":
		case "X":
		case "Y":
		case "Z":
			ctrl.btnGriseur(e.getActionCommand());
			ctrl.searchLetter(e.getActionCommand().charAt(0));
			break;
		case "h":
			break;
		case "THEME1":
		case "THEME2":
		case "THEME3":
		case "THEME4":
		case "THEME5":
			ctrl.resetColors(e.getActionCommand());
			ctrl.rafraichiJeu();
			break;
		}
	}
 
}

la classe controleur, qui centralise les actions ou les demandes d'actions :

Code:

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
package com.francky.lettres.ctrl;
 
import java.awt.Color;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Vector;
 
import com.francky.lettres.modele.BoutonsMap;
import com.francky.lettres.modele.CouleurThemes;
import com.francky.lettres.modele.Mot;
import com.francky.lettres.modele.MotDAO;
import com.francky.lettres.vues.FenetrePrincipale;
 
public class Controleur {
 
	//***********************************************************DECLARATIONS
	FenetrePrincipale fenetreprincipale;
	MotDAO motdao = new MotDAO("mots.xml");
	Vector<Mot> mots = null;		//contenant de tous les objets Mot
	public boolean debug;			//variable pour le débuggage
	private int randomNum;			//variable contenant le numéro trouvé par le random
	private BoutonsMap btnMap;		//Instance de BoutonsMap qui va m'aider à récupérer les btn pour les griser / dégriser
 
	/*
	 * Gestion du score et des statistiques
	 */
	private int score;
	private int motsTrouves;
	private int nbreLettres;
	private int niveau;
 
	/*
	 * Message d'information
	 */
	public String message;
 
	/*
	 * Gestion du mot à rechercher et à cacher
	 */
	private String mot;											//le mot qui a été choisi au hasard
	private ArrayList<Character> listeLettres;					//le tableau contenant toute les lettres du mot choisi au hasard
	private List<Character> listeLettresTrouvees;				//Liste des lettres qui ont été trouvées
	private Character lettreTrouvee;							//dernière lettre trouvée
 
	private ListenerClavier keyListener;
 
	/*
	 * Définition de la palette des couleurs pour le jeu 
	 */
	private String COLOR_THEME = "THEME3";	//THEME1 à THEME5
	public Color COL_FOND;
	public Color COL_TEXTE_1;
	public Color COL_TEXTE_2;
	public Color COL_MOT;
	public Color COL_GRAPH;
 
 
	Ecouteur ecouteur;
 
	//***********************************************************CONSTRUCTEUR
 
	public Controleur() {
		//************************************Initialisations
		resetGame();
 
		resetColors(COLOR_THEME);		
 
		keyListener = new ListenerClavier(this);
 
		choixNouveauMot();
 
		//************************************création de la fenêtre
		fenetreprincipale = new FenetrePrincipale(this);
 
		fenetreprincipale.addKeyListener(keyListener);
		fenetreprincipale.setVisible(true);
		fenetreprincipale.requestFocus();
	}
	//***********************************************************METHODES
 
	//recherche d'une lettre cliquée dans le mot
	public void searchLetter(Character lettreClic) {
		for(Character lettre : mot.toCharArray()) {
			if(lettre.equals(lettreClic)){
				message = "lettre trouvée !";
				listeLettresTrouvees.add(lettreClic);
				lettreTrouvee = lettreClic;
 
				//générer et ré afficher le mot caché
				listeLettres = setlisteLettres(listeLettres);
				fenetreprincipale.repaint();
				break;
			} else {
			}
		}
	}
 
 
	//Choix d'un nouveau mot parmi la liste, on retire le mot choisi de la liste,
	//on génère le tableau de lettres du mot choisi, on génère le mot caché 
	private void choixNouveauMot() {
 
		randomNum = randomNum();
 
		mot = mots.get(randomNum).getChaine();
 
		//on enleve de la liste le mot qui a été tiré au hazard pour qu'il ne soit pas choisi au hasard plusieurs fois
		mots.remove(randomNum);
 
		//lorsque le nouveau mot a été choisi, il faut remplir un tableau de Character avec des underscores
		for(int rank = 0; rank < mot.length(); rank++){
			listeLettres.add('_');
		}
	}
 
	//réinitialisation des couleurs
	public void resetColors(String theme) {
		//initialisation des couleurs - a l'avenir il faudra aller chercher le theme dans un .xml
		CouleurThemes coul = new CouleurThemes(theme);
 
		COL_FOND = coul.getColComplementaire_5();
		COL_TEXTE_1 = coul.getColPrimaire_3();
		COL_TEXTE_2 = coul.getColPrimaire_2();
		COL_MOT = coul.getColPrimaire_3();
		COL_GRAPH = coul.getColPrimaire_1();
 
	}
 
	//remise à zéro des paramètres d'initialisation
	private void resetGame() {
		debug = true;
		setScore(0);
		setMotsTrouves(0);
		setNbreLettres(0);
		setNiveau(1);
		listeLettres = new ArrayList<Character>();
		lettreTrouvee = ' ';
		ecouteur = new Ecouteur(this);
		btnMap = new BoutonsMap(ecouteur);
		listeLettresTrouvees = new ArrayList<Character>();
		mots = motdao.chargerMots();
	}
 
	//génération d'un entier au hasard compris entre 0 et les nombre de mots contenus dans la liste des mots en .xml
	private int randomNum(){
		Random rand = new Random();
		return rand.nextInt((mots.size()));
	}
 
	//création du mot qui sera affiché (on montre les lettres qui ont déjà été trouvées) prend en paramètre la liste
	private ArrayList<Character> setlisteLettres(ArrayList<Character> listeLettres){	
		for (int rank = 0; rank < listeLettres.size(); rank++){
			if(listeLettres.get(rank).equals('_')){
				if(lettreTrouvee.equals(mot.charAt(rank))){
					listeLettres.set(rank, lettreTrouvee);
				}
			}
		}		
 
		return listeLettres;
	}
 
	//griseur de boutons
	public void btnGriseur(String btnValue) {
		btnMap.griserBouton(btnMap.getJBouton(btnValue));
	}
 
	//repaint
	public void rafraichiJeu() {
		fenetreprincipale.modifieBackgrounds();
 
	}
 
	//modifieScore
	public void modifieScore(int ajout) {
		setScore(getScore() + ajout);
	}
	//***********************************************************GETTERS & SETTERS
	public int getScore() {return score;}
	public void setScore(int score) {this.score = score;}
 
	public int getMotsTrouves() {return motsTrouves;}
	public void setMotsTrouves(int motsTrouves) {this.motsTrouves = motsTrouves;}
 
	public int getNbreLettres() {return nbreLettres;}
	public void setNbreLettres(int nbreLettres) {this.nbreLettres = nbreLettres;}
 
	public int getNiveau() {return niveau;}
	public void setNiveau(int niveau) {this.niveau = niveau;}
 
	public String getMot() {return mot;}
	public void setMot(String mot) {this.mot = mot;}
 
	public List<Character> getListeLettres() {return listeLettres;}
}

la classe FenetrePrincipale qui instancie tous les panneaux :

Code:

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
package com.francky.lettres.vues;
 
import java.awt.BorderLayout;
 
import javax.swing.JFrame;
 
import com.francky.lettres.ctrl.Controleur;
import com.francky.lettres.vues.panneaux.PanelAffichage;
import com.francky.lettres.vues.panneaux.PanelKeyboard;
import com.francky.lettres.vues.panneaux.PanelScore;
 
public class FenetrePrincipale extends JFrame {
 
	/**
         * 
         */
	private static final long serialVersionUID = -221472257022120727L;
 
	//********************************************************DECLARATIONS
	private Controleur ctrl;
	Menu menu;
	PanelAffichage panelaffichage;
	PanelScore panelscore;
	PanelKeyboard panelkeyboard;
 
	public FenetrePrincipale(Controleur ctrl) {
		//construction de la fenêtre
		super("Lettres");
		setLayout(new BorderLayout());
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setResizable(false);
 
		this.ctrl = ctrl;
 
 
		// ajout d'un menu
		menu = new Menu(this, ctrl);
		/*
		 * Initialisation des panneaux
		 */
		//création du clavier
		panelkeyboard = new PanelKeyboard(ctrl);
		//ajout du clavier à la fenêtre
		add(panelkeyboard, BorderLayout.CENTER);
 
		//Création du panneau de score
		panelscore = new PanelScore(ctrl);
		add(panelscore, BorderLayout.EAST);
 
		//création du panneau d'affichage des mots
		panelaffichage = new PanelAffichage(ctrl);
		add(panelaffichage, BorderLayout.NORTH);
 
		pack();
		setLocationRelativeTo(null);
	}
 
	//demande la modification de la couleur de fond pour tous les panneaux
	public void modifieBackgrounds() {
		panelaffichage.modifieBackgroundColor();
		panelkeyboard.modifieBackgroundColor();
		panelscore.modifieBackgroundColor();
	}
}

puis le reste des classes pour avoir toutes les classes :
PanelScore :

Code:

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package com.francky.lettres.vues.panneaux;
 
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
 
import javax.swing.JPanel;
 
import com.francky.lettres.ctrl.Controleur;
 
public class PanelScore extends JPanel {
 
	/**
         * 
         */
	private static final long serialVersionUID = 5355849929954014794L;
 
 
	//************************************************************DECLARATIONS
	/*
	 * Définition de la hauteur et de la largeur
	 */
	private static final int SCORE_HEIGTH = PanelKeyboard.KEYBOARD_HEIGTH;
	public static final int SCORE_WIDTH = 200;
 
	/**
         * The number of pixels used on a small insets (generally used for categories).
         */
	private static final int SMALL_INSET = 20;
 
	/**
         * The number of pixels used on a large insets.
         */
	private static final int LARGE_INSET = 40;
 
	/**
         * The y coordinate of the stats category.
         */
	private static final int STATS_INSET = 20;
 
	/**
         * The y coordinate of the controls category.
         */
	private static final int SCORE_INSET = 220;
 
	/**
         * The number of pixels to offset between each string.
         */
	private static final int TEXT_STRIDE = 25;
 
	/**
         * The small font.
         */
	private static final Font SMALL_FONT = new Font("Arial", Font.BOLD, 12);
 
	/**
         * The large font.
         */
	private static final Font LARGE_FONT = new Font("Tahoma", Font.BOLD, 14);
	/**
         * The color to draw the text and preview box in.
         */
 
	//Contrôleur
	private Controleur ctrl;
 
	//************************************************************CONSTRUCTEUR
	public PanelScore(Controleur ctrl) {
		this.ctrl = ctrl;
 
		setPreferredSize(new Dimension(SCORE_WIDTH, SCORE_HEIGTH));
		setBackground(ctrl.COL_FOND);
 
	}
 
 
	//************************************************************METHODES
	//modifier le background du panel
	public void modifieBackgroundColor() {
		setBackground(ctrl.COL_FOND);
	}
 
	@Override
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		/*
		 * This variable stores the current y coordinate of the string.
		 * This way we can re-order, add, or remove new strings if necessary
		 * without needing to change the other strings.
		 */
		int offset;
 
		/*
		 * Draw the "Statistiques" category.
		 */
 
		g.setColor(ctrl.COL_TEXTE_1);
		g.setFont(LARGE_FONT);
		g.drawString("Statistiques", SMALL_INSET, offset = STATS_INSET);
		g.drawString("Niveau", LARGE_INSET, offset += TEXT_STRIDE);
		g.setColor(ctrl.COL_TEXTE_2);
		g.setFont(SMALL_FONT);
		g.drawString("" + ctrl.getNiveau(), LARGE_INSET, offset += TEXT_STRIDE);
		g.setColor(ctrl.COL_TEXTE_1);
		g.setFont(LARGE_FONT);
		g.drawString("Mots trouvés", LARGE_INSET, offset += TEXT_STRIDE);
		g.setColor(ctrl.COL_TEXTE_2);
		g.setFont(SMALL_FONT);
		g.drawString("" + ctrl.getMotsTrouves(), LARGE_INSET, offset += TEXT_STRIDE);
		g.setColor(ctrl.COL_TEXTE_1);
		g.setFont(LARGE_FONT);
		g.drawString("Nombre de lettres", LARGE_INSET, offset += TEXT_STRIDE);
		g.setColor(ctrl.COL_TEXTE_2);
		g.setFont(SMALL_FONT);
		g.drawString("" + ctrl.getNbreLettres(), LARGE_INSET, offset += TEXT_STRIDE);
 
		/*
		 * Draw the "Score" category.
		 */
		g.setColor(ctrl.COL_TEXTE_1);
		g.setFont(LARGE_FONT);
		g.drawString("Score", SMALL_INSET, offset = SCORE_INSET);
 
		g.setColor(ctrl.COL_TEXTE_2);
		g.setFont(SMALL_FONT);
		g.drawString("" + ctrl.getScore(), LARGE_INSET, offset += TEXT_STRIDE);
	}
}

PanelAffichage :

Code:

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
package com.francky.lettres.vues.panneaux;
 
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
 
import javax.swing.JPanel;
 
import com.francky.lettres.ctrl.Controleur;
 
public class PanelAffichage extends JPanel {
 
	/**
         * 
         */
	private static final long serialVersionUID = 8624942466374820397L;
 
	//***********************************************************DECLARATIONS
	private Controleur ctrl;
	int x = 0;
	/*
	 * Taille du panneau affichage
	 */
	private static final int PANEL_WIDTH = PanelKeyboard.KEYBOARD_WIDTH + PanelScore.SCORE_WIDTH;
	private static final int PANEL_HEIGHT = 150;
 
	/*
	 * Taille et position de la zone d'affichage du texte
	 */
	private static final int TEXT_ZONE_WIDTH = PanelKeyboard.KEYBOARD_WIDTH + PanelScore.SCORE_WIDTH - 20;
	private static final int TEXT_ZONE_HEIGHT = 100;
	private static final int TEXT_ZONE_X = 10;
	private static final int TEXT_ZONE_Y = 25;
 
	/*
	 * Taille et position du mot à chercher
	 */
	private static final int MOT_TAILLE = 50;
	private static final Font MOT_FONT = new Font("Tahoma", Font.BOLD, MOT_TAILLE);
	private static final int MOT_Y = TEXT_ZONE_HEIGHT / 2 + TEXT_ZONE_Y + 20;
	private static final int MOT_X = TEXT_ZONE_X + 15;
 
	//***********************************************************CONSTRUCTEUR
	public PanelAffichage(Controleur ctrl) {
		this.ctrl = ctrl;
 
		setPreferredSize(new Dimension(PANEL_WIDTH, PANEL_HEIGHT));
		setBackground(ctrl.COL_FOND);
	}
	//***********************************************************GETTERS & SETTERS
 
 
	//***********************************************************METHODES
	//modifier le background du panel
	public void modifieBackgroundColor() {
		setBackground(ctrl.COL_FOND);
	}
 
 
	@Override
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
 
		g.setColor(ctrl.COL_FOND);
 
		g.setColor(ctrl.COL_GRAPH);
		g.drawRect(TEXT_ZONE_X, TEXT_ZONE_Y, TEXT_ZONE_WIDTH, TEXT_ZONE_HEIGHT);
 
		//affichage du mot caché
		g.setColor(ctrl.COL_MOT);
		g.setFont(MOT_FONT);
		int decal = 0;
 
 
		for(int caractere = 0; caractere < ctrl.getListeLettres().size(); caractere++){
			g.drawString("" + ctrl.getListeLettres().get(caractere), MOT_X + decal, MOT_Y);
			decal += (g.getFontMetrics().stringWidth("" + ctrl.getListeLettres().get(caractere)) + 15);
		}
	}
}

la classe Menu :

Code:

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
package com.francky.lettres.vues;
 
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
 
import com.francky.lettres.ctrl.Controleur;
import com.francky.lettres.ctrl.Ecouteur;
 
public class Menu extends JMenuBar{
 
	/**
         * 
         */
	private static final long serialVersionUID = -4451367752330474585L;
 
	JMenu menuAffichage, ssmenuThemCoul;
	JMenuItem itemTheme1, itemTheme2, itemTheme3, itemTheme4, itemTheme5;
	Ecouteur menuListener;
 
	public Menu(FenetrePrincipale fenetreprincipale, Controleur ctrl) {
		menuListener = new Ecouteur(ctrl);
		menuAffichage = new JMenu("Affichage");
 
		this.add(menuAffichage);
 
		ssmenuThemCoul = new JMenu("Themes couleurs");
		menuAffichage.add(ssmenuThemCoul);
 
		itemTheme1 = new JMenuItem("thème1");
		itemTheme2 = new JMenuItem("thème2");
		itemTheme3 = new JMenuItem("thème3");
		itemTheme4 = new JMenuItem("thème4");
		itemTheme5 = new JMenuItem("thème5");
 
		ssmenuThemCoul.add(itemTheme1);
		ssmenuThemCoul.add(itemTheme2);
		ssmenuThemCoul.add(itemTheme3);
		ssmenuThemCoul.add(itemTheme4);
		ssmenuThemCoul.add(itemTheme5);
 
		itemTheme1.addActionListener(menuListener);
		itemTheme1.setActionCommand("THEME1");
		itemTheme2.addActionListener(menuListener);
		itemTheme2.setActionCommand("THEME2");
		itemTheme3.addActionListener(menuListener);
		itemTheme3.setActionCommand("THEME3");
		itemTheme4.addActionListener(menuListener);
		itemTheme4.setActionCommand("THEME4");
		itemTheme5.addActionListener(menuListener);
		itemTheme5.setActionCommand("THEME5");
 
		fenetreprincipale.setJMenuBar(this);
	}
 
}

la classe Game qui contient le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.francky.lettres.principal;
 
import com.francky.lettres.ctrl.Controleur;
import com.francky.lettres.vues.FenetrePrincipale;
 
public class Game {
 
	/**
         * 
         */
	private static final long serialVersionUID = 4564883110279195429L;
 
	//METHODES
	public static void main(String[] arg){
		Controleur ctrl = new Controleur();
	}
}

la classe MotDAO :

Code:

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
package com.francky.lettres.modele;
 
import java.io.File;
import java.io.IOException;
import java.util.Vector;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
 
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
 
public class MotDAO {
 
	//DECLARATIONS
	File motsXML;
	public MotDAO(String filename) {
		super();
		motsXML = new File(filename);
	}
 
	public Vector<Mot> chargerMots(){
		Vector<Mot> mots = new Vector<Mot>();
 
		try {
			System.out.println("chargerMots");
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			DocumentBuilder db = dbf.newDocumentBuilder();
			Document doc = db.parse(motsXML);
			NodeList nl = doc.getElementsByTagName("mot");
 
			for(int i = 0; i < nl.getLength(); i++){
				Element el = (Element)nl.item(i);
				mots.add(new Mot(el.getTextContent(), Boolean.parseBoolean(el.getAttribute("genre")), Boolean.parseBoolean(el.getAttribute("composed"))));
			}
 
		} catch (SAXException | IOException | ParserConfigurationException e) {e.printStackTrace();}
 
		return mots;
	}
}

la classe Mot :

Code:

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
package com.francky.lettres.modele;
 
public class Mot {
 
	//***************************************DECLARATIONS
	private boolean genre;		//true = masculin ou false = féminin
	private String chaine;		//le mot
	private boolean composed;	//Est-ce un mot composé (exemple : garde-boue)
 
	//CONSTRUCTEURS
	public Mot() {this("mot", true, false);}
	public Mot(String chaine, boolean genre, boolean composed) {
		setChaine(chaine);
		setGenre(genre);
		setComposed(composed);
	}
 
	//GETTERS & SETTERS
	public boolean isGenre() {return genre;}
	public void setGenre(boolean genre) {this.genre = genre;}
	public String getChaine() {return chaine;}
	public void setChaine(String chaine) {this.chaine = chaine;}
 
	public boolean isComposed() {return composed;}
	public void setComposed(boolean composed) {this.composed = composed;}
}

la classe CouleurThemes :

Code:

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package com.francky.lettres.modele;
 
import java.awt.Color;
 
public class CouleurThemes {
 
	/*
	 * 
	 * Choix des couleurs sur http://paletton.com/
	 * 
	 * 
	 */
 
 
			private static Color ColPrimaire_1, ColPrimaire_2, ColPrimaire_3, ColPrimaire_4, ColPrimaire_5;
			private static Color ColComplementaire_1, ColComplementaire_2, ColComplementaire_3, ColComplementaire_4, ColComplementaire_5;
 
	public CouleurThemes(String theme) {
 
		if (theme.equals("THEME1")){
			//THEME 1
			ColPrimaire_1 = new Color(0xD7ECD7);
			ColPrimaire_2 = new Color(0xAED9AE);
			ColPrimaire_3 = new Color(0x80C080);
			ColPrimaire_4 = new Color(0x53A153);
			ColPrimaire_5 = new Color(0x2F812F);
 
			ColComplementaire_1 = new Color(0xFFE8E8);
			ColComplementaire_2 = new Color(0xFFCCCC);
			ColComplementaire_3 = new Color(0xF0A0A0);
			ColComplementaire_4 = new Color(0xC96767);
			ColComplementaire_5 = new Color(0xA23B3B);
		} else if (theme.equals("THEME2")) {
			//THEME 2
			ColPrimaire_1 = new Color(0xE0FAE0);
			ColPrimaire_2 = new Color(0xB5EFB5);
			ColPrimaire_3 = new Color(0x8ADF8A);
			ColPrimaire_4 = new Color(0x61CB61);
			ColPrimaire_5 = new Color(0x3CAD3C);
 
			ColComplementaire_1 = new Color(0xFFE5E5);
			ColComplementaire_2 = new Color(0xFFC2C2);
			ColComplementaire_3 = new Color(0xFF9D9D);
			ColComplementaire_4 = new Color(0xFE7979);
			ColComplementaire_5 = new Color(0xD84B4B);
		} else if (theme.equals("THEME3")) {
			//THEME 3
			ColPrimaire_1 = new Color(0xFFFFBA);
			ColPrimaire_2 = new Color(0xFFFF8F);
			ColPrimaire_3 = new Color(0xFFFF6B);
			ColPrimaire_4 = new Color(0xFFFF4C);
			ColPrimaire_5 = new Color(0xE9E925);
 
			ColComplementaire_1 = new Color(0xDAB2F0);
			ColComplementaire_2 = new Color(0xBC80DC);
			ColComplementaire_3 = new Color(0x9F59C6);
			ColComplementaire_4 = new Color(0x843AAD);
			ColComplementaire_5 = new Color(0x70209C);
		} else if (theme.equals("THEME4")) {
			//THEME 4
			ColPrimaire_1 = new Color(0xA9DFFF);
			ColPrimaire_2 = new Color(0x78CDFF);
			ColPrimaire_3 = new Color(0x0EA5FF);
			ColPrimaire_4 = new Color(0x00578A);
			ColPrimaire_5 = new Color(0x00436A);
 
			ColComplementaire_1 = new Color(0xFFD6A4);
			ColComplementaire_2 = new Color(0xFFBF70);
			ColComplementaire_3 = new Color(0xFF8C00);
			ColComplementaire_4 = new Color(0xD97700);
			ColComplementaire_5 = new Color(0xA75C00);
		} else if (theme.equals("THEME5")) {
			//THEME 5
			ColPrimaire_1 = new Color(0xFFD6A4);
			ColPrimaire_2 = new Color(0xFFBF70);
			ColPrimaire_3 = new Color(0xFF8C00);
			ColPrimaire_4 = new Color(0xD97700);
			ColPrimaire_5 = new Color(0xA75C00);
 
			ColComplementaire_1 = new Color(0xA9DFFF);
			ColComplementaire_2 = new Color(0x78CDFF);
			ColComplementaire_3 = new Color(0x0EA5FF);
			ColComplementaire_4 = new Color(0x00578A);
			ColComplementaire_5 = new Color(0x00436A);
		} else {
			//THEME 1
			ColPrimaire_1 = new Color(0xD7ECD7);
			ColPrimaire_2 = new Color(0xAED9AE);
			ColPrimaire_3 = new Color(0x80C080);
			ColPrimaire_4 = new Color(0x53A153);
			ColPrimaire_5 = new Color(0x2F812F);
 
			ColComplementaire_1 = new Color(0xFFE8E8);
			ColComplementaire_2 = new Color(0xFFCCCC);
			ColComplementaire_3 = new Color(0xF0A0A0);
			ColComplementaire_4 = new Color(0xC96767);
			ColComplementaire_5 = new Color(0xA23B3B);
		}
	}
 
	public static void setColPrimaire_1(Color colPrimaire_1) {ColPrimaire_1 = colPrimaire_1;}
	public static void setColPrimaire_2(Color colPrimaire_2) {ColPrimaire_2 = colPrimaire_2;}
	public static void setColPrimaire_3(Color colPrimaire_3) {ColPrimaire_3 = colPrimaire_3;}
	public static void setColPrimaire_4(Color colPrimaire_4) {ColPrimaire_4 = colPrimaire_4;}
	public static void setColPrimaire_5(Color colPrimaire_5) {ColPrimaire_5 = colPrimaire_5;}
	public  Color getColPrimaire_1() {return ColPrimaire_1;}
	public  Color getColPrimaire_2() {return ColPrimaire_2;}
	public  Color getColPrimaire_3() {return ColPrimaire_3;}
	public  Color getColPrimaire_4() {return ColPrimaire_4;}
	public  Color getColPrimaire_5() {return ColPrimaire_5;}
 
	public static void setColComplementaire_1(Color colComplementaire_1) {ColComplementaire_1 = colComplementaire_1;}
	public static void setColComplementaire_2(Color colComplementaire_2) {ColComplementaire_2 = colComplementaire_2;}
	public static void setColComplementaire_3(Color colComplementaire_3) {ColComplementaire_3 = colComplementaire_3;}
	public static void setColComplementaire_4(Color colComplementaire_4) {ColComplementaire_4 = colComplementaire_4;}
	public static void setColComplementaire_5(Color colComplementaire_5) {ColComplementaire_5 = colComplementaire_5;}
	public  Color getColComplementaire_1() {return ColComplementaire_1;}
	public  Color getColComplementaire_2() {return ColComplementaire_2;}
	public  Color getColComplementaire_3() {return ColComplementaire_3;}
	public  Color getColComplementaire_4() {return ColComplementaire_4;}
	public  Color getColComplementaire_5() {return ColComplementaire_5;}
}

la classe ListenerClavier :

Code:

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
package com.francky.lettres.ctrl;
 
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
 
public class ListenerClavier implements KeyListener {
 
	Controleur ctrl;
 
	public ListenerClavier(Controleur ctrl) {
		this.ctrl = ctrl;
	}
 
	@Override
	public void keyPressed(KeyEvent e) {
		System.out.println("key pressed : " + e.getKeyChar());
		switch(e.getKeyChar()){
		case 'A':
			//griser les boutons lorsqu'ils ont été cliqués
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
			System.out.println(e.getKeyChar() + " key pressed");
			ctrl.btnGriseur("" + e.getKeyChar());
			ctrl.searchLetter(e.getKeyChar());
			break;
 
		}
	}
 
	@Override
	public void keyReleased(KeyEvent e) {
		System.out.println("key pressed : " + e.getKeyChar());
 
	}
 
	@Override
	public void keyTyped(KeyEvent e) {
 
		System.out.println("key typed : " + e.getKeyChar());
	}
 
}

le fichier mot.xml qu'il faut placer à la racin du projet :

Code:

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<mots>
	<listemots lang="fr">
		<mot genre="true" composed="false" pluriel="chapeaux" lang="fr">CHAPEAU</mot>
		<mot genre="false" composed="false" pluriel="chaises" lang="fr">CHAISE</mot>
		<mot genre="true" composed="false" pluriel="bateaux" lang="fr">BATEAU</mot>
		<mot genre="true" composed="false" pluriel="bureaux" lang="fr">BUREAU</mot>
		<mot genre="false" composed="false" pluriel="animations" lang="fr">ANIMATION</mot>
	</listemots>
</mots>

Voilà, je pense n'avoir rien oublié, mais dans tous les cas, tout le code est sur mon github :
https://github.com/franckyy/jeux/tree/master/testZjeu

Je vous remercie de prêter de l'attention à ma demande !

:)