Evitare di aprire Finestre Uguali

[Markus85]

Ciao a tutti.

Vorrei evitare di aprire finestre che sono uguali.

Esempio :

Dispongo di un JButton a cui è associato un ascoltatore che apre una finestra.
Faccio click sul bottone e viene aperta la finestra.
Con la finestra aperta voglio che , facendo click di nuovo sul bottone , non se se apra una seconda uguale ; ossia si apra sempre la prima.

Si può fare ?

[Alex'87]

Sai usare un if?
Sai dichiarare un booleano?

Allora sì, si può fare

[Markus85]

Mi faresti un esempio ?

[LeleFT]

E' piuttosto banale (non serve nemmeno un booleano).
Un esempio completo.

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

public class NoDoppi extends JFrame {

   private JFrame altraFinestra;

   public NoDoppi() {
      Container c = getContentPane();
      c.setLayout( null );

      JButton cmd = new JButton("Apri finestra");
      cmd.setBounds(20, 20, 120, 30);
      cmd.addActionListener( new ActionListener() {
         @Override
         public void actionPerformed(ActionEvent ae) {
            apriFinestra();
         }
      });

      c.add( cmd );
      setTitle("Niente doppioni");
      setSize(800, 600);
      setLocationRelativeTo( null );
      setDefaultCloseOperation( EXIT_ON_CLOSE );
   }

   private void apriFinestra() {
      if (altraFinestra != null) {
         altraFinestra.setVisible( true );
         altraFinestra.toFront();
      } else {
         altraFinestra = new JFrame("Altra finestra");
         altraFinestra.add(new JLabel("Label"), BorderLayout.NORTH);
         altraFinestra.setSize(400, 400);
         altraFinestra.setLocationRelativeTo(this);
         altraFinestra.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
         altraFinestra.setVisible( true );
      }
   }

   public static void main(String[] args) {
      SwingUtilities.invokeLater( new Runnable() {
         @Override
         public void run() {
            NoDoppi nd = new NoDoppi();
            nd.setVisible( true );
         }
      });
   }
}

Ciao.

[Markus85]

Ho capito....bisogna utilizzare un riferimento.

Vorrei evitare di adottare una soluzione poco pulita , ossia di creare 25 riferimenti per le mie 25 finestre da controllare.

Credevo di aver trovato una soluzione migliore , ma mi sono bloccato.

Guarda cosa ho fatto io...

Ho messo un riferimento nella finestra da controllare e un metodo per controllarlo :

public class FrameAggiungiArticolo extends JFrame {
	
	static boolean faaAperta; // IL RIFERIMENTO
	
	public FrameAggiungiArticolo(){
		
		super();
		faaAperta = true;  //SETTATO A TRUE QUANDO SI INIZIALIZZA LA FINESTRA


        //ALTRO CODICE...

        }

        //ALTRO CODICE


	public static boolean IsAperta(){
		return faaAperta;
	}

       public static void Chiudi(){
		faaAperta = false;
	}

}

Nell'ascoltatore controllo se il riferimento è true :

public class ascoltatoreBottoneAggiungiArticolo implements ActionListener {
	
	private InterfacciaPrincipale clickBottoneAggiungiArticolo;
	
	public ascoltatoreBottoneAggiungiArticolo(InterfacciaPrincipale clickBottoneAggiungiArticolo){
		
		this.clickBottoneAggiungiArticolo = clickBottoneAggiungiArticolo;
	}
	
	public void actionPerformed(ActionEvent e){
		
		if(!FrameAggiungiArticolo.IsAperta())
		new FrameAggiungiArticolo();
		
	}
	


}//ASCOLTATORE BOTTONE AGGIUNGI ARTICOLO

Ed Ora la nota dolente :

Dovrei settare il riferimento a false ogni volta che chiudo una finestra

Il fatto è che ho scritto un ascoltatore generico (valido per più finestre) per la chiusura , ma non so come fare ad istanziare il riferimento a false .

package Ascoltatori;




import interfacciaGrafica.FrameVendiArticolo;
import interfacciaGrafica.InterfacciaPrincipale;
import interfacciaGrafica.NotificaSalvataggioCambiamenti;


import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;


public class ascoltatoreChiudiFinestra implements ActionListener {
	
	private JFrame RifJFrame;
	private InterfacciaPrincipale RifInterfacciaP;
	private FrameVendiArticolo RifFrameVA;
	private int tipoFinestra;
	
	public ascoltatoreChiudiFinestra(JFrame RifJFrame){
		
		this.RifJFrame = RifJFrame;		
		tipoFinestra = 0;
		
	}
	
	public ascoltatoreChiudiFinestra(NotificaSalvataggioCambiamenti RifJFrame , InterfacciaPrincipale RifInterfacciaP){
		
		this.RifJFrame = RifJFrame;
		this.RifInterfacciaP = RifInterfacciaP;
		tipoFinestra = 1;
		
	}
	
	public ascoltatoreChiudiFinestra(FrameVendiArticolo RifFrameVA){
		this.RifFrameVA = RifFrameVA;
		tipoFinestra = 2;
	}
	
	
	public void actionPerformed(ActionEvent e){
		
		switch(tipoFinestra){
		case 0 :
			RifJFrame.dispose();
			break;
		case 1 :
			RifJFrame.dispose();
			RifInterfacciaP.dispose();
			break;
		case 2 :
			RifFrameVA.dispose();
			InterfacciaPrincipale.Jtable.setRowSelectionAllowed(true);
		}		
	}


}//ASCOLTATORE PER CHIUDERE LE FINESTRE

Cioè io ricevo un JFrame generico ; come faccio ad invocare quel metodo per quel tipo di JFrame?

[LeleFT]

Visto che tutti i componenti grafici sono dotati di un comodo metodo isVisible() (che, come dice il nome, ritorna true o false a seconda se il componente è visibile o meno), perchè non usarlo?

L'unica cosa in più da controllare è che il componente sia stato effettivamente creato (e che, quindi, non sia nullo).

if (tuaFinestra != null) {
   if (tuaFinestra.isVisible()) {
      // E' già visibile
   } else {
      // va resa visibile (con setVisible(true) )
   }
} else {
   // Va creata da zero con new
}

[Markus85]

Si ma come ?

Cercherò di essere più conciso.

Ho una frame FrameAggiungiArticolo;
Viene aperta da un ascoltatore :

public class ascoltatoreBottoneAggiungiArticolo implements ActionListener {
	
	private InterfacciaPrincipale clickBottoneAggiungiArticolo;
	
	public ascoltatoreBottoneAggiungiArticolo(InterfacciaPrincipale clickBottoneAggiungiArticolo){
		
		this.clickBottoneAggiungiArticolo = clickBottoneAggiungiArticolo;
	}
	
	public void actionPerformed(ActionEvent e){
		
		new FrameAggiungiArticolo();
				
	}
	
}//ASCOLTATORE BOTTONE AGGIUNGI ARTICOLO

Viene chiusa da un ascoltatore "universale"

import interfacciaGrafica.FrameVendiArticolo;
import interfacciaGrafica.InterfacciaPrincipale;
import interfacciaGrafica.NotificaSalvataggioCambiamenti;


import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;


public class ascoltatoreChiudiFinestra implements ActionListener {
	
	private JFrame RifJFrame;
	private InterfacciaPrincipale RifInterfacciaP;
	private FrameVendiArticolo RifFrameVA;
	private int tipoFinestra;


	
	public ascoltatoreChiudiFinestra(JFrame RifJFrame){
		
		this.RifJFrame = RifJFrame;		
		tipoFinestra = 0;
        		
	}
	
       //LASCIA PERDERE IL RESTO	


}//ASCOLTATORE PER CHIUDERE LE FINESTRE

Ora ; mettiamo che io apro la finestra FrameAggiungiArticolo , quando la chiudo (Con l'ascoltatore universale) come faccio a sapere che proprio essa è stata chiusa?

[LeleFT]

Allora: una finestra X dovrebbe essere sempre aperta nello stesso punto. Non ci dovrebbero mai essere 2 punti diversi di apertura, altrimenti l'unico modo che hai per controllare una cosa del genere è avere un "gestore delle finestre". In questo modo, il riferimento è sempre lo stesso e non hai problemi.

Se non è così, devi rivedere l'architettura: non puoi pretendere che due oggetti diversi vedano la stessa istanza di un terzo oggetto se nessuno lo fa conoscere all'altro.

Ripeto anche (e l'ho già detto nelle tue due precedenti discussioni) che l'ascoltatore universale non è una buona soluzione... e qui si cominciano a vedere i primi problemi (anche se l'ascoltatore universale lavora comunque con i riferimenti... quindi, chi ha aperto la finestra ha il riferimento e lo passa all'ascoltatore universale, quindi sa anche se deve riaprirla oppure no perchè il riferimento ce l'ha fin dall'inizio).

E, per inciso, questo codice è la causa di tutti i tuoi mali:

public void actionPerformed(ActionEvent e){
       
    new FrameAggiungiArticolo();
                
}

Qui stai aprendo una finestra, senza memorizzarne il riferimento da nessuna parte: perderne il riferimento significa non poter più sapere nulla della vita di quella finestra. Quindi, primo intervento: memorizza il riferimento da qualche parte; secondo intervento, prima di fare quella "new", verifica 1) di non averla già fatta e 2) se l'hai già fatta, controlla che non sia ancora aperta.


Ciao.

[Markus85]

Ok Ho capito.
Scusa se sono stato un pò imbranato

[Markus85]

Ho risolto

Con la tua delucidazione sul riferimento ho fatto cosi :

public class ascoltatoreBottoneAggiungiArticolo implements ActionListener {
	
	private InterfacciaPrincipale RifInterfacciaP;
	
	
	public ascoltatoreBottoneAggiungiArticolo(InterfacciaPrincipale RifInterfacciaP){
		
		this.RifInterfacciaP = RifInterfacciaP;
	}
	
	public void actionPerformed(ActionEvent e){
		
		if(FrameAggiungiArticolo.faa == null)
		FrameAggiungiArticolo.faa = new FrameAggiungiArticolo();
		
			
	}


}//ASCOLTATORE BOTTONE AGGIUNGI ARTICOLO

Il riferimento l'ho messo nella classe stessa :

public class FrameAggiungiArticolo extends JFrame {
	
	public static FrameAggiungiArticolo faa;
	
	//ALTRO CODICE

Ciao