[JAVA] Swing, conoscere quale tasto e' stato premuto

[Poker1]

Ciao a tutti,
sto facendo un esercizio che mi chiede di mettere 2 pulsanti e di scrivere "Hai premuto A" oppure "Hai premuto B" a seconda di quale pulsante e' stato premuto.

Mi dice di utilizzare una sola classe ricevitore di eventi, del tipo:

class ClickerListener implements ActionListener
{
	public void actionPerformed( ActionEvent e )
	{
		System.out.println("Premuto X");
	}
}

Se devo usare una sola classe presumo che per capire quale tasto e' stato premuto lo posso conoscere sfruttando la variabile e di tipo ActionEvent, sbaglio?

Volevo fare un altra domanda, in genere per un programma del genere, e' meglio usare una sola classe che riceve tutti gli eventi e distinguere nei vari casi, oppure fare piu classi ricevitori di eventi? Del tipo una per i pulsanti, una per i combo box ecc ecc ?

Grazie infinite!!!

[Andrea1979]

Fondamentalmente hai 2 sistemi: getSource (se sai che sono JButton, fai il cast a JButton e poi prendi il label del bottone) oppure con getActionCommand. Comunque basta leggere le api

[Poker1]

Eh, l'avevo letta e non ci sono riuscito

per l'altra domanda?

[Andrea1979]

per l'altra domanda... sono scelte dettate dal gusto personale e dalla gestibilità del codice... se ho tanti bottoni con molte azioni diverse mi trovo meglio con un gestore (classe interna anonima) per ogni bottone piuttosto che un actionEvent unico con mille sottocasi diversi.

[Poker1]

Capito, quindi non c'e' un metodo di programmazione specifica per questo

[Ed_Bunker]

Dipende dalle situazioni.
Personalmente perferisco disaccoppiare l'implementazione dei listener "separati" da quella delle sorgenti che generano gli eventi (Frame, Scrollbar, etc.)

Molti, pero', creano i listener come classi interne in modo da permettere loro l'accesso a variabili private altrimenti "difficili" da modificare.
E generalmente credo che questo sia il comportamento piu' adottato.

Per quanto riguarda il numero di listener...
Se e' possibile "fattorizzare" (Ovvero riutilizzare lo stesso listener per piu' sorgenti) ben venga.
Altrimenti si fa in modo che ogni controllo abbia i "propri" listener.

Almeno credo sia cosi'...

[Poker1]

Per fare un semplice programma con 3 pulsanti con etichette Red, Green, Blue che alla loro pressione cambiano colore ad un pannello centrale ho scritto cosi':

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;

class ColorChanger extends JFrame
{
	public ColorChanger()
	{
		this.setTitle( "Color Changer Application" );
		this.setSize( 400, 400 );
		
		createControlPanel();
		createAction();
	}
	
	public void createControlPanel()
	{
		JPanel buttonPanel = createButton();
		JPanel centerPanel = createCenterPanel();
		
		this.add( buttonPanel, BorderLayout.NORTH  );
		this.add( centerPanel, BorderLayout.CENTER );
	}
	
	public JPanel createButton()
	{
		redButton = new JButton( "Red" );
		greenButton = new JButton( "Green" );
		blueButton = new JButton( "Blue" );
		
		JPanel panel = new JPanel();
		
		panel.add( redButton );
		panel.add( greenButton );
		panel.add( blueButton );
		
		return panel;
	}
	
	public JPanel createCenterPanel()
	{
		centerPanel = new JPanel();
		
		return centerPanel;
	}
	
	public void changeColor( Color c )
	{
		centerPanel.setBackground( c );
	}
	
	public void createAction()
	{
		redButtonListener =  new ColorChangerListener( Color.RED );
		greenButtonListener = new ColorChangerListener( Color.GREEN );
		blueButtonListener = new ColorChangerListener( Color.BLUE );
		
		redButton.addActionListener( redButtonListener );
		greenButton.addActionListener( greenButtonListener );
		blueButton.addActionListener( blueButtonListener );
	}
	
	private class ColorChangerListener implements ActionListener
	{
		public ColorChangerListener( Color c )
		{
			colore = c;
		}
		public void actionPerformed( ActionEvent event )
		{
			changeColor( colore );
		}
		
		private Color colore;
	}
	
	private JButton redButton;
	private JButton greenButton;
	private JButton blueButton;
	private JPanel centerPanel;
	
	private ActionListener redButtonListener;
	private ActionListener greenButtonListener;
	private ActionListener blueButtonListener;
}
public class ColorChangerTest 
{
	public static void main( String args[] )
	{
		JFrame frame = new ColorChanger();
		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		frame.setVisible( true );
	}

}

[LeleFT]

Io, quando ho a che fare con tanti pulsanti preferisco approcciare il problema in modo diverso:
creo una classe che estende JButton aggiungendo, generalmente, un campo (lo chiamo index) di tipo intero;
fatto questo utilizzo lo stesso Listener per tutti i pulsanti;
a questo punto, nel metodo actionPerformed() dell'ActionListener posso utilizzare un comodo switch() per distinguere i pulsanti.

Da notare che questo approccio mi snellisce di molto la stesura del codice nel caso dei Menu: generalmente quando si ha a che fare con i Menu si ha a che fare con un'ampia gamma di Listener (uno per ciascun Menu).

Esempietto pratico con i menu:

private class VoceMenu extends JMenuItem {

   private int indice;

   public VoceMenu(String nome, String immagine, int indice, ActionListener al) {
      super(nome, immagine.equals("") ? null : new ImageIcon("immagini/" + immagine + ".gif"));
      this.indice = indice;
      addActionListener( al );
   }

   public int getIndice() { return indice; }
}

In questo caso, il costruttore del Menu richiede tutti i parametri (non è necessario, ovviamente): il nome visualizzato, l'eventuale immagine da visualizzare, l'indice che mi servirà poi per distinguere i menu e l'ActionListener da associargli.
Costruisco così i menu:

// Suppongo che la classe dove c'è il menu implementi ActionListener
JMenu mnuFile = new JMenu("File");
VoceMenu mnuFileNuovo = new VoceMenu("Nuovo", "", 0, this);
...
mnuFile.add( mnuFileNuovo );
...
add( mnuFile );

L'ActionListener ora è semplicissimo:

public void actionPerformed(ActionEvent ae) {
   VoceMenu vm = (VoceMenu) ae.getSource();
   switch ( vm.getIndice() ) {
      case 0:   // Il menu File->Nuovo
         azioneFileNuovo();   // Richiamo il metodo che fa partire l'azione del menu File->Nuovo
         break;

      case 1:   // Il menu File->Apri
         ...
   }
}

Ciao.

[Ed_Bunker]

Beh... a 'sto punto preferirei fare in modo che il listener abbia un riferimento a ciascuno dei controlli peri quali e' delegato alla gestione degli eventi.
In tal modo gli bastera' fare un confronto tra e.getSource() e tali riferimenti per capire quale e' la sorgente dell'evento...

[Poker1]

ghghghg...io sono veramente agli inizi con questo tipo di programmazione ( interfacce intendo ) quindi mi trovo un attimino in confusione...