Discussion :

[Tora21]

Bonjour à tous,

J'ai créé un tableau de x boutons qui prennent pour noms, des Strings d'un fichier .txt.
Je souhaiterais maintenant leurs attribuer des actions. Le souci est que je ne sais pas comment faire.

Voici le code de la classe où sont créés les boutons:

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
 
public class PanelPrincipale extends JPanel
{
    private JButton[] bouton = new JButton[10];
    private JButton boutExit = new JButton("Quitter");
 
        // Une classe contenant une list de String extraites d'un fichier texte
    private NomDeBouton unNom = new NomDeBouton ();
 
    public PanelPrincipale(NomDeBouton aNom)
    {
        this.unNom = aNom;
    }
 
 
    public PanelPrincipale()
    {
        this.setLayout (new GridLayout (0,3));
 
        int x = 0;
        x = this.unNom.getListNom().size () -1;
 
        for (int i =0; i<=x; i++)
        {
            bouton[i] = new JButton(String.valueOf (this.unNom.getListNom().get (i)));
            this.add (bouton[i]);
            bouton[i].addActionListener (new GestionnaireAction ());
        }
 
        this.add (this.boutExit);
        this.boutExit.addActionListener (new GestionnaireAction ());
 
        this.setVisible (true);
    }
 
 
    public JButton [] getBouton ()
    {
        return bouton;
    }
 
    public void setBouton (JButton [] bouton)
    {
        this.bouton = bouton;
    }
 
    public JButton getBoutExit ()
    {
        return this.boutExit;
    }
}

voici le code du gestionnaire:

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 class GestionnaireAction implements ActionListener
{
    private PanelPrincipale unPanel;
 
    public GestionnaireAction ()
    {
    }
 
    public GestionnaireAction ( PanelPrincipale aPanel)
    {
        this.unPanel = aPanel;
    }
 
    public void actionPerformed (ActionEvent aAE)
    {
        if (aAE.getSource () == unPanel.getBouton ())
        {
            System.out.println ("test 1");
        }
 
        if (aAE.getSource () == unPanel.getBoutExit ())
        {
            System.exit (-1);
        }
 
    }
}

l'erreur que je génère lorsque je clique sur les boutons est un nullPointeur posé sur la ligne

Code :

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

if (aAE.getSource () == unPanel.getBouton ())

Quelqu'un saurait-il m'expliquer comment faire ?

Merci d'avance pour votre aide.

[rtg57]

Bonjour,

d'après ce que je crois comprendre, vous créez autant de gestionnaires d'action qu'il y a de boutons:

Code :

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

1
2
3
bouton[i].addActionListener (new GestionnaireAction ());
/.../
boutExit.addActionListener (new GestionnaireAction ());

Pourquoi ne pas créer un gestionnaire, affecté à chaque boutons:

Code :

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

1
2
3
4
5
GestionnaireAction gestionActionBoutons = new GestionnaireAction();
/.../
bouton[i].addActionListener( gestionActionBoutons );
/.../
boutExit.addActionListener( gestionActionBoutons );

Ensuite, mettez un point d'arrêt à l'entrée du gestionnaire d'action, et en mode débogage, vérifiez qu'à chaque appuie sur un bouton, vous passez par le gestionnaire.
Ou ajoutez simplement pour commencer à l'entrée de gestionnaire:

Code :

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

System.out.println("Evénement de Bouton");

Ainsi vous voyez un message dans la console à chaque fois qu'un évènement est traité...

[Tora21]

Ça fait un peu de temps déjà, je n'avais pas eu le temps nécessaire pour continuer mon application.
Je m'y suis remis, alors j'ai modifié un peu le code, j'ai maintenant un seul gestionnaire pour tous mes bouton, j'ai aussi accomplies quelques test.

Dans mon gestionnaire je souhaite réalisé les action de boutons situé dans un Arraylist, ça ne change pas, par contre j'ai effectué un test sur le bouton quitter que je n'ai pas crée avec le ArrayList. Ce test consiste à appelé l'action du bouton d'une autre manière, et cela fonctionne sans problèmes, mais je ne sais pas trop comment l'appliquer au autres boutons.

La méthode tel quel, lorsque je clic sur un bouton, elle m'affiche le sysout et ensuite une erreur NullPointerException.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public void actionPerformed (ActionEvent aAE)
	{
		System.out.println("Evénement de Bouton");
		if (aAE.getSource () == unPanel.getBouton ())
		{
			System.out.println ("zobi");
		}
 
		if (aAE.getSource () == unPanel.getBoutExit ())
		{
			System.exit (-1);
		}
	}

La méthode qui marche, mais que je ne sais pas appliquer aux bouton de l'ArrayList:

Code :

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

1
2
3
4
5
 
String cause = aAE.getActionCommand();
        if (cause.equals("Quitter")) {
            System.exit(-1);
        }

[rtg57]

Bonjour,

la NullPointerException doit provenir du fait que unPanel n'est pas défini dans le gestionnaire d'évènement.
Si vous avez besoin d'une référence à unPanel, vous devez déclarer cet élément comme membre de la classe qui englobe le gestionnaire d'évènement.

Pour commencer, voyez du côté de ce tutoriel: http://baptiste-wicht.developpez.com...e=boutons#L5.1

On y voit comment connaitre le bouton qui a provoqué l'entrée dans le gestionnaire d'évènements, commun à plusieurs boutons.

[Tora21]

Merci pour le lien vers le tuto, mais je ne trouve pas dedans ce qu'il me faut.
En ce qui concerne unPanel, je l'ai défini et je l'ai valorisé avec un objet instance de la classe PanelPrincipale, je vous donne la classe du gestionnaire.

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
 
public class GestionnaireAction implements ActionListener
{
	private CheminDeBouton unChemin = new CheminDeBouton ();
	private PanelPrincipale unPanel;
 
	public GestionnaireAction ()
	{
	}
 
	public GestionnaireAction (CheminDeBouton aChemin, PanelPrincipale aPanel)
	{
		this.unChemin = aChemin;
		this.unPanel = aPanel;
	}
 
 
	public void actionPerformed (ActionEvent aAE)
	{
		System.out.println("Evénement de Bouton");
		if (aAE.getSource () == unPanel.getBouton ())
		{
			System.out.println ("zobi");
		}
 
		if (aAE.getSource () == unPanel.getBoutExit ())
		{
			System.exit (-1);
		}
	}
 
}

[rtg57]

Bonjour,

j'ai l'impression que c'est compliqué tout cela
Je vous propose l'architecture suivante, en espérant qu'elle s'insère dans votre projet:

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
public class PanelPrincipale extends JPanel implements ActionListener
{
  private JButton[] bouton;
  private JButton boutExit;
  private NomDeBouton unNom; // Une classe contenant une list de String extraites d'un fichier texte
 
  // Constructeur:
  public PanelPrincipale()
  {
    AbstractAction gestionAction;
    int x;
 
    this.setLayout (new GridLayout (0,3));
 
    gestionAction = new AbstractAction(); // Gèrera les évènement du groupe de boutons
 
    unNom = new NomDeBouton ();
    x = unNom.getListNom().size () - 1;
 
    // Création du tableau de boutons:
    for( int i = 0; i <= x; i++ )
    {
      bouton[ i ] = new JButton( String.valueOf( this.unNom.getListNom().get (i)));
      bouton[ i ].addActionListener( gestionAction ); // Un gestionnaire uniquement
      this.add( bouton[ i ]);
    }
 
    boutExit = new JButton( "Quitter" );
    boutExit.addActionListener( new actionExit()); // Affecte un gestionnaire spécial pour ce bouton
    this.add (this.boutExit);
 
    this.setVisible (true);
  }
 
/.../

Enfin toujours dans la classe panelPrincipal:

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
private class gestionAction extends AbstractAction
{
  gestionAction()
  {
    super();
  }
 
  @Override
  public void actionPerformed( ActionEvent aE )
  {
    /.../
  }
}
 
/.../
 
private class actionExit extends AbstractAction
{
  actionExit()
  {
    super();
  }
 
  @Override
  public void actionPerformed( ActionEvent aE ) // Gestion du bouton de sortie
  {
    /.../
  }
}

Ce code est à tester, je ne garantis pas que ça marche vu que je débute un peu en JAVA, mais je pense que l'idée est là.