# Beim Schließen eines fensters, schließen sich alle



## Cathamenia (9. Nov 2007)

Hallo,

Ich habe ein ziemlich simples Programm. Dieses öffnet beim starten n Fenster. Nun möchte ich einzelne Fenster schließen, ohne dass sich alle schließen.

Hier ein paar code schnipsel zu meinem Programm:

Klasse für die einzelnen Fenster:

```
public class GuiCounter extends JFrame implements Runnable{
	private int counter = 0;
	private int msec = 0;
	private String name = "";
	
	private JLabel countLabel;
	
	public GuiCounter(int msec, String name, int location){
		super(name);
		this.msec = msec;
		this.name = name;
		...
```

und der Aufruf der Fenster, jedes ist ein eigener Thread:


```
public class GuiZaehler{
	private static void startCounter(int msec, String name, int location){
		GuiCounter c = new GuiCounter(msec, name, location);
		Thread counterThread = new Thread(c);
		counterThread.start();
	}
	
	public static void main(String[] args) {
		int number = Integer.valueOf(args[0]);
		String name = null;
		int msec = 0;
		for (int i = 1; i <= number; i++){
			name = "Counter " + String.valueOf(i);
			msec = Integer.valueOf(args[i]);
			startCounter(msec, name, i * 60);
		}
	}
}
```


Gruß Cathamenia


----------



## SlaterB (9. Nov 2007)

wann wo wie wird denn in deinem Programm ein Fenster geschlossen?

und weißt du, warum dann alle Fenster geschlossen werden?
hast du irgendwas Richtung WindowClosingListener/setDefaultCloseOperation?

normalerweise bleiben die Fenster eher offen:

```
public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        JFrame a = new JFrame();
        a.setSize(400,300);
        a.setVisible(true);
        
        JFrame b = new JFrame();
        b.setSize(200,150);
        b.setVisible(true);
    }
}
```
a und b kann man einzeln zu-klicken, Programm läuft selbst dann noch unsichtbar weiter


----------



## Cathamenia (9. Nov 2007)

ok, hier nochmal der Gesamte Konstruktor:


```
public GuiCounter(int msec, String name, int location){
		super(name);
		this.msec = msec;
		this.name = name;
		
		this.setSize(220, 60);
		this.setLocation(location, location);
		this.setLayout(new BorderLayout());
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		countLabel = new JLabel("");
		this.getContentPane().add(countLabel, BorderLayout.CENTER);
		this.setVisible(true);
		
	}
```

direkt ein Frame öffnen, so wie du es gemacht hast, kann ich nicht, da ich Instanzen meiner gesamten Klasse benötige, welche von JFrame geerbt ist, wie man oben sieht


----------



## SlaterB (9. Nov 2007)

du hast also
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
was bedeutet 'bei x gesamtes Programm beenden'

lasse das also weg bzw. rufe explizit den Default-Wert
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
auf

dann wird aber nicht automatisch der zugehörige Thread beendet,
und das Programm läuft auch dann noch weiter wenn alle Fenster zu sind 
(mindestens der AWT-Event-Thread läuft weiter)


----------



## Cathamenia (9. Nov 2007)

Genau dort ist leider mein Problem, ich hatte es auch schon weggelassen, und dann schlossen sich die fenster auch einzeln. Aber die Threads laufen weiter und wenn ich das letzte Fenster schließe, dann ist das Programm ja immer noch nicht beendet, sondern läuft im Hintergrund "unendlich" lange weiter...


----------



## SlaterB (9. Nov 2007)

schön, das wußtest du alles schon, wolltest es aber nicht erwähnen 



dann also ein WindowListener,
dann kannst du beim Schließen noch beliebige Aktionen anstoßen:


```
public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        JFrame a = new JFrame();
        a.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        a.addWindowListener(new WindowListener()
            {
                public void windowActivated(WindowEvent e)
                {
                }

                public void windowClosed(WindowEvent e)
                {
                    System.out.println("nu ist disposed");
                }

                public void windowClosing(WindowEvent e)
                {
                    System.out.println("gleich disposed");
                }

                public void windowDeactivated(WindowEvent e)
                {
                }

                public void windowDeiconified(WindowEvent e)
                {
                }

                public void windowIconified(WindowEvent e)
                {
                }

                public void windowOpened(WindowEvent e)
                {
                }
            });
        a.setSize(400, 300);
        a.setVisible(true);

    }
}
```
der Standard ist übrigends nicht DISPOSE sondern wohl DO_NOTHINT, also 
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
aufrufen wenn Dispose gewünscht ist

-------

das Beeenden des eigenen Thread dürfte damit klar sein, falls dir das allgemein bekannt ist
(wenn nicht, dann hat das nix mit Fenstern zu tun!)

wenn es um das Ende des Gesamtprogramms geht, dann kann ein Fenster alleine erstmal wenig tun,
idealerweise hast du ein einzelnes Kontroll-Objekt, dass alle Threads/ Fenster kennen,
dort kann sich jedes Fenster abmelden, wenn es geschlossen wird,
das Kontroll-Objekt merkt dann, wenn gar keine Fenster mehr da sind und beendet das Programm


----------

