Attendre un événement pour continuer le programme principal

**Zerifah** · 15/11/2016, 20h55

Bonjour à tous,

Je suis en train de programme le jeu d'échec. Lorsqu'un pion atteint la dernière ligne, j'aimerais que mon programme principale attende que :

une fenêtre (JFrame) demande à l'utilisateur s'il veut promouvoir son pion en dame, cavalier, fou ou tour (donc 4 boutons)
l'utilisateur clique sur un de ces boutons
suivant ce qu'il a cliqué, le pion est transformé.

Puis, le programme principal reprend son cours.

J'ai essayé de faire, dans mon programme principal un while(estEnAttente), avec estEnAttente un boolean qui deviendrait false lorsque le pion a été transformé (donc que l'utilisateur a cliqué sur le bouton...). Mais le problème est que le programme semble rester coïncé dans cette boucle, et que la fenêtre apparaît, mais reste vide, sans boutons.

J'ai lu des forums et sans doute que je pourrais m'en sortir avec des Thread, mais je ne sais pas comment faire, je suis débutant dans ce domaine.
(Une autre solution serait de faire une boîte de dialogue, mais je n'ai pas trouvé de moyen de faire 4 boutons avec des images personnalisées.)

Au bas de ce message, je vous mets mes bouts de codes pour vous aidez à m'aider. :-)
Merci beaucoup si vous arrivez à me sortir du désespoir.

Cordialement.

--------------------------------

Le programme principal, situer dans la classe nommée actionCases :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
BoiteDeDialoguePromotion prom = new BoiteDeDialoguePromotion(c);	
estEnAttenteDuChoixDePromotion = true;
while(estEnAttenteDuChoixDePromotion);
//... suite du programme principal

La classe créant la boîte de dialogue :

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
 
public class BoiteDeDialoguePromotion extends JFrame{
 
	private static final long serialVersionUID = 1L;
 
	BoiteDeDialoguePromotion(uneCase c) throws FontFormatException, IOException{
		Container cp = this.getContentPane();
		cp.setLayout(new GridLayout(1,4,0,0));
		setTitle("Promotion");
		setSize(300, 100);  
		setLocation(900,0);
		setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
 
		BoutonPromotion bouton_dame = new BoutonPromotion(partie.DAME, this, c);
		BoutonPromotion bouton_cav = new BoutonPromotion(partie.CAVALIER, this, c);
		BoutonPromotion bouton_fou = new BoutonPromotion(partie.FOU, this, c);
		BoutonPromotion bouton_tour = new BoutonPromotion (partie.TOUR, this, c);
 
		add(bouton_dame);
		add(bouton_cav);
		add(bouton_fou);
		add(bouton_tour);
 
		setVisible(true);
 
	}
}

La classe des boutons est banal, je mets juste la ligne où je crée un listener :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
actionPromotion gestion_bouton = new actionPromotion();
		addActionListener(gestion_bouton);

Et finalement la classe gérant l'action du bouton :

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
public void actionPerformed(ActionEvent arg0) {
 
		//Récupération de la provenance de l'événement.
		BoutonPromotion bouton = (BoutonPromotion) arg0.getSource();
 
		//Il faut supprimer de la liste des pièces le pion promu :
		partie.getPieces().remove(bouton.getLaCase().getPiece());
 
		//Et on le remplace par la nouvelle promotion
		if(bouton.getType().equals(partie.DAME)){
			partie.getPieces().add(new Dame(partie.getTrait(), bouton.getLaCase()));
		}
		if(bouton.getType().equals(partie.FOU)){
			partie.getPieces().add(new Fou(partie.getTrait(), bouton.getLaCase()));
		}
		if(bouton.getType().equals(partie.TOUR)){
			partie.getPieces().add(new Tour(partie.getTrait(), bouton.getLaCase()));
		}
		if(bouton.getType().equals(partie.CAVALIER)){
			partie.getPieces().add(new Cavalier(partie.getTrait(), bouton.getLaCase()));
		}
 
		//Ferme la fenêtre 
		bouton.getFenetre().setVisible(false);
		actionCases.setEstEnAttenteDuChoixDePromotion(false);
		System.out.println("Promotion choisie");
 
	}

**joel.drigo** · 15/11/2016, 23h34

Salut,

Premièrement, il ne fait pas faire de boucle dans le l'EDT (=Event Dispatch Thread, le thread de Swing, qui sert à "dessiner" et à traiter les évenements), comme tu as pu le constater, parce que ça bloque le dessin de l'UI et le traitement des évenements.

Ensuite, au lieu d'utiliser une JFrame pour faire ton dialogue, utilise un JOptionPane ou un JDialog, de type modal, qui est implémenté justement pour se mettre en attente sans pour autant bloquer l'EDT.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
String[] options= {"Reine", "Cavalier", "Fou", "Tour"};
int promotion = JOptionPane.showOptionDialog(jframe, // jframe est le composant par rapport au quel on veut être modal (ça peut être n'importe quel composant, JPanel, JFrame, etc...
				"En quel pièce voulez-vous promouvoir le pion ?",  // le message qui va s'afficher dans le dialogue
				"Promotion d'un pion",  // le titre
				JOptionPane.DEFAULT_OPTION, // le type d'option (boutons)
				JOptionPane.QUESTION_MESSAGE, // le type de dialogue 
				null, // ici tu peux mettre une icône si tu veux personnaliser ton dialogue
				options, // les choix possibles
				options[0]); // le choix par défaut(activé si l'utilisateur tape la touche entrée directement)
if ( promotion!=JOptionPane.CLOSED_OPTION ) {	// si pas annulation
    String piecePromotion = options[promotion];
    // faire la promotion vers piecePromotion...
    System.out.println("Promotion en " + piecePromotion);
}

Autre exemple avec boutons radio :

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
		JRadioButton[] options= {new JRadioButton("Reine"), new JRadioButton("Cavalier"), new JRadioButton("Fou"), new JRadioButton("Tour")};
		ButtonGroup buttonGroup = new ButtonGroup();
		for(JRadioButton button : options) {
			buttonGroup.add(button);
			button.addActionListener(e-> ((JOptionPane)((JRadioButton)e.getSource()).getParent().getParent()).setValue(e.getSource()));
		}
		int promotion = JOptionPane.showOptionDialog(jframe, 
				"En quel pièce voulez-vous promouvoir le pion ?", 
				"Promotion d'un pion", 
				JOptionPane.YES_NO_OPTION, 
				JOptionPane.QUESTION_MESSAGE, 
				null, 
				options, 
				null); 
		if ( promotion!=JOptionPane.CLOSED_OPTION ) {
			String piecePromotion = options[promotion].getText();
			// faire la promotion vers piecePromotion...
			System.out.println("Promotion en " + piecePromotion);
		}

**Zerifah** · 18/11/2016, 13h02

Bonjour,

Merci beaucoup pour cette réponse rapide et complète! Cela m'aide bien, surtout le deuxième code. J'ai ainsi compris comment on pouvait faire une boîte de dialogue avec des boutons personnalisés. Mon problème est presque résolu, mais j'ai encore un problème. En imitant le deuxième code, je me suis dis que je pouvais recycler ma classe BoutonDePromotion (qui affiche les boutons Dame, Fou, ...):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
BoutonPromotion[] options= {new BoutonPromotion(partie.DAME, c), new BoutonPromotion(partie.TOUR, c),
                                       new BoutonPromotion(partie.CAVALIER, c), new BoutonPromotion(partie.FOU, c)};

Dans la classe BoutonPromotion, j'ai crée un ActionListener pour chaque bouton, qui renvoie à ma classe actionPromotion :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
actionPromotion gestion_bouton = new actionPromotion();
addActionListener(gestion_bouton);

Mais le problème est que la boîte de dialogue ne se ferme plus automatiquement lorsque je clique sur un des 4 boutons. Y a-t-il un moyen de dire depuis la classe actionPromotion de fermer la boîte de dialogue? Ou bien dois-je renoncer à utiliser plusieurs classes perso?

Au passage, j'ai deux petites questions :

Que signifie boîte de dialogue modale ?
Que dois-je mettre sous "frame" ? J'ai mis null, ce qui semble fonctionner, mais y aurait-il mieux?

Merci encore beaucoup et bonne journée.

**joel.drigo** · 18/11/2016, 14h52

Envoyé par Zerifah

Mais le problème est que la boîte de dialogue ne se ferme plus automatiquement lorsque je clique sur un des 4 boutons. Y a-t-il un moyen de dire depuis la classe actionPromotion de fermer la boîte de dialogue?

Oui. Si tu remarques bien, il y a le même problème avec des RadioButton : c'est pour le résoudre que je fais ce truc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

button.addActionListener(e-> ((JOptionPane)((JRadioButton)e.getSource()).getParent().getParent()).setValue(e.getSource()));

J'enregistre un ActionListener qui va appeler la méthode setValue(option) de JOptionPane.
Toi, tu mets ton propre ActionListener, une instance de classe actionPromotion. Au lieu de faire ça, il faudrait encapsuler l'appel de ton listener dans un ActionListener qui fait aussi le setValue().
genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
button.addActionListener(new ActionListener() {
       private actionPromotion gestion_bouton = new actionPromotion();
       public void actionPerformed(ActionEvent e) {
               (JOptionPane)((BoutonPromotion)e.getSource()).getParent().getParent()).setValue(e.getSource())); // sélectionne le bouton comme option dans le dialogue et le ferme
               gestion_bouton .actionPerformed(e); // traite cette option
       }
}

Alors c'est un peu de la bidouille, pour faire des dialogues personnalisés, il vaut mieux parfois utiliser la classe JDialog et la customiser.

Envoyé par Zerifah

Au passage, j'ai deux petites questions :

Envoyé par Zerifah

Que signifie boîte de dialogue modale ?

C'est une fenêtre graphique qui attend avant de rendre la main : elle est modale par rapport à quelque chose (un autre composant graphique). Le code qui va l'appelle va attendre qu'une réponse soit retournée avec de continuer :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
System.out.println("dialogue");
JOptionPane.showMessageDialog(null, "Pause");
System.out.println("continuer");
```
1. On afficher "dialogue", puis un dialoge s'affiche :
3. Le message "continuer" ne s'affiche que lorsqu'on le dialogue se ferme.
Avec un dialogue non modale, on aurait :
1. On afficher "dialogue", puis un dialoge s'affiche :
2. Le message "continuer" s'affiche
En plus, tous les composants qui sont dans le contexte par rapport au quel on est modale sont inactifs : on ne peut pas cliquer sur les boutons, saisir de champs, sélectionner quelque chose, etc. On ne peut même pas fermer la fenêtre par rapport à laquelle on est modal.
Envoyé par Zerifah

Que dois-je mettre sous "frame" ? J'ai mis null, ce qui semble fonctionner, mais y aurait-il mieux?

Il s'agit juste du composant par rapport au quel on veut être modale (en réalité la fenêtre qui contient le composant). Si tu passes null, le dialogue sera modale par rapport au composant courant. Quand tu n'as qu'une seule JFrame, ça revient au même : null correspond à celle-ci.

**Zerifah** · 19/11/2016, 20h24

Bonsoir,

Merci beaucoup pour cette réponse.
J'ai donc abandonné d'utiliser une classe séparée pour l'action du bouton et j'ai utilisé ton code : ça marche parfaitement, mais je dois bien avouer que cette ligne reste pour moi très obscure.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

button.addActionListener(e-> ((JOptionPane)((JRadioButton)e.getSource()).getParent().getParent()).setValue(e.getSource()))

Tout d'abord, je ne connais pas le sens du "->". Je n'ai jamais utiliser cette syntaxe. Ce n'est pas un opérateur, n'est-ce pas? Alors qu'est-ce que c'est?
Puis, est-ce le "setValue(...) qui ferme la boîte de dialogue, ce qui voudrait dire que dès qu'une valeur est donnée, la boîte se ferme?
Finalement, je dois avouer que le cast (JOptionPane) me reste difficile à comprendre.

Tu m'as déjà consacré beaucoup de temps, donc, n'hésite pas à laisser ces dernières questions sans réponse. Mais si tu y réponds, c'est avec gratitude que je lirai les réponses.

En tout cas, merci beaucoup, car je ne pense pas que j'y serais arrivé sans ton aide.

Cordialement.

**joel.drigo** · 20/11/2016, 13h17

Envoyé par Zerifah

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

button.addActionListener(e-> ((JOptionPane)((JRadioButton)e.getSource()).getParent().getParent()).setValue(e.getSource()))

Tout d'abord, je ne connais pas le sens du "->". Je n'ai jamais utiliser cette syntaxe. Ce n'est pas un opérateur, n'est-ce pas? Alors qu'est-ce que c'est?

Il s'agit d'un opérateur unaire, mais qui ne s'applique pas à des variables ou des retours de méthodes : il marque juste ce qu'on appelle une expression lambda. Elle permet de simplifier une implémentation anonyme d'interface fonctionnelle. Une interface fonctionnelle est une interface qui a une seule méthode à implémenter. Comme par exemple ActionListener :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
@FunctionnalInterface
public interface ActionListener {
     void actionPerformed(ActionEvent event);
}

L'annotation @FunctionnalInterface n'est pas indispensable, mais garantie que l'interface n'évoluera pas en interface non fonctionnelle (on ajoutera pas de méthode non implémentée supplémentaire).

L'implémentation anonyme classique d'une tel interface est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
composant.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent e) {
            ((JOptionPane)((JRadioButton)e.getSource()).getParent().getParent()).setValue(e.getSource())
       }
}

Tu peux voir immédiatement en comparant avec l'expression lambda que j'ai utilisée la simplification que la lambda apporte par rapport à l'implémentation anonyme.

Pour en savoir plus : http://jmdoudoux.developpez.com/cour...as.php#lambdas

Envoyé par Zerifah

Puis, est-ce le "setValue(...) qui ferme la boîte de dialogue, ce qui voudrait dire que dès qu'une valeur est donnée, la boîte se ferme?

Oui, mais c'est un peu plus compliqué que ça.

la documentation indique que le clic sur un bouton sélectionne la valeur correspondante et ferme le dialogue
l'implémentation de setValue propage un évenement (PropertyChangeEvent) )dont la réception ferme le dialogue. C'est un choix particulier et la documentation de la méthode n'indique nullement que le dialogue se ferme sur appel de setValue. Pour cette raison, on pourrait imaginer d'autres implémentations qui ne fonctionnent pas comme ça.
les appels successifs de getParent() pour remonter les composants imbriqués dépendent également de l'implémentation du JOptionPane, et, là, aucune obligation que ça ne change pas. (et en particulier que ça soit implémenter comme ça dans une autre implémentation du jdk).

C'est pour ces deux raisons que j'ai dit que c'était de la bidouille. Si pour setValue, il est peu probable d'avoir une autre implémentation (elle est simple et efficace, par rapport au contrat de la doc), le problème de la hiérarchie de composant est plus problématique parce que l'implémention qui ne se baserait pas sur la hiérarchie passerait par une nouvelle classe étendant JOptionPane, ou alors une méthode de type boucle jusqu'à ce qu'on ait trouvé le JOptionPane). On pourrait faire une classe qui réalise ce process :

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
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.function.BiConsumer;
 
/**
 * Un action listener qui transfert l'invocation sur le plus proche parent de la source tel que ce parent soit d'une classe déterminée
 *
 * @param <T>
 */
public class ParentTriggerActionListener<T> implements ActionListener {
 
	private final Class<T> parentClass;
	private final BiConsumer<T,Object> actionListener;
 
	public ParentTriggerActionListener(Class<T> parentClass, BiConsumer<T,Object> actionListener) {
		this.parentClass=parentClass;
		this.actionListener=actionListener;
	}
 
	@Override
	public final void actionPerformed(ActionEvent e) {
		T parent = getParent((Component)e.getSource());
		if ( parent==null ) {
			throw new IllegalStateException("Cannot find parent of "+parentClass.getName());
		}
		else {
			actionListener.accept(parent, e.getSource());
		}
	}
 
	private T getParent(Component source) {
		for( ; source!=null && !parentClass.isInstance(source); source = source.getParent());
		return parentClass.cast(source);
	}
 
}

Et pour l'utiliser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

button.addActionListener(new ParentTriggerActionListener<>(JOptionPane.class, (parent,source)-> parent.setValue(source)));

Envoyé par Zerifah

Finalement, je dois avouer que le cast (JOptionPane) me reste difficile à comprendre.

Le cast de e.getSource() est indispensable cette méthode retourne du Object. Ici, je caste en JRadioButton parce que je sais que je traite un évenement provenant d'un JRadioButton. Il suffirait en réalité de ce contenter d'un java.awt.Component, pour pouvoir appler getParent().
Le cast du retour de getParent() en JOptionPane est lui indispensable pour passer d'un java.awt.Container (le type de retour de getParent()) à un JOptionPane pour pouvoir invoquer setValue(), qui n'existe pas dans la classe java.awt.Container.

**Zerifah** · 06/12/2016, 15h33

Merci beaucoup pour toutes ces réponses! Voilà qui est plus clair. Cordialement!

Attendre un événement pour continuer le programme principal

Java

Discussions similaires

Partager

Partager