Window aus anderer Klasse aufrufen

[grinquel]

Hallo zusammen,

aus einem JFrame (hier: TFrame) soll ein JWindow (hier: Screen) aufgerufen werden.
wenn ich Screen alleine bzw. mit der main-Methode starte zeigt er den Text an
rufe ich das gleiche aus TFrame baut er zwar das Window auf - zeigt aber keinen Text
das verstehe ich nicht ...
ich arbeite mit Eclipse beide Klassen sind in unterschiedlichen .java files aber in einem Package.
(Java Version 1.6 Ubuntu 10.10)

in meinen Java Büchern finde ich keinen Hinweis und auch hier hab nix passendes gefunden.
Danke für Eure Hilfe


Hier der Code von TFrame:

import javax.swing.*;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TFrame extends JFrame implements ActionListener
{
	JLabel label1, label2;
	JButton butt1, butt2, butt3;
	JPanel cont = new JPanel();
	
	public TFrame()
	{
	    super("Titelanzeige");
	    setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
	    cont.setLayout (new FlowLayout () );
	    setBounds(100, 100, 600, 300);
	    
	    label1 = new JLabel("Button --> "); cont.add(label1);
	    
	    butt1 = new JButton("Button_1"); cont.add(butt1);
	    butt1.addActionListener(this);   butt1.setActionCommand("1");
	    
	    butt2 = new JButton("Button_2"); cont.add(butt2);
	    butt2.addActionListener(this);   butt2.setActionCommand("2");
	    
	    butt3 = new JButton("Button_3"); cont.add(butt3);
	    butt3.addActionListener(this);   butt3.setActionCommand("3");
	    
	    label2 = new JLabel("Button ? "); cont.add(label2);
	    
	    add(cont);
	    setVisible( true );	
	}	

	public void actionPerformed(ActionEvent e){
		String cmd = e.getActionCommand();
		label2.setText("Button > "+cmd);
		
		Screen intro = new Screen("Button > "+cmd);
		intro.showFor(5000);
	}

	public static void main(String[] args) {
		
		new TFrame();
	}
}

und hier der Screen:

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

public class Screen extends JWindow
{

	public Screen(String text)
	{
		JPanel cp = new JPanel();
		cp.setLayout(new FlowLayout());
		cp.add(new JLabel("Dieser Text -->"));
		cp.add(new JLabel(text));
		this.setContentPane(cp);
	}
	
	public void showFor(int millis)
	{
		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		setLocation(dim.width / 3, dim.height / 4);
		setSize(dim.width / 3, dim.height / 2);
		this.setVisible(true);
		try {Thread.sleep(millis);} 
		catch (InterruptedException e) {}
		this.setVisible(false);
	}
	
	public static void main(String[] args)
	{
		Screen intro = new Screen("Aufruf aus Main");
		intro.showFor(5000);
		System.exit(0);
	}
}

 

[IMartin]

showFor

legt den ausführendenThread schlafen. Im Falle von

Screen.main(String[] args)

ist das nur der main-Thread, aber im Falle von

TFrame.main(String[] args)

ist das der EDT und dann "schläft" auch die Benutzeroberfläche.

Eine Möglichkeit:

javax.swing.Timer

zum Schließen des Screen.

 

[grinquel]

Hallo zsam,

erstmal Danke IMartin für den nächtlichen Hinweis
ich hab jetzt einiges mit diesem Timer ausprobiert, aber ich hab nich wirklich begriffen wie der funktioniert
also das hier läuft net.

	public void showFor(int millis)
	{
		showOn();
		System.out.println("showOn"); // bis hier klappt's
		
		ActionListener timact=new ActionListener() {
		      public void actionPerformed(ActionEvent evt) {
		    	//...Perform a task... z.B. //showOff(); ??
		    	  System.out.println("evt"); // da kommt er nie hin
		      }};
		System.out.println("new Timer");		      
		Timer tim = new Timer(millis, timact);
		//tim.setRepeats(false);
		tim.start();
		//showOff(); ??
	}
	
	public void showOn()
	{
		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		setLocation(dim.width / 3, dim.height / 4);
		setSize(dim.width / 3, dim.height / 2);
		this.setVisible(true);
	}
	public void showOff()
	{
		this.setVisible(false);
	}

so funktioniert's auch - aber wieder nur direkt aus main:

	public void showFor(int millis)
	{
		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		setLocation(dim.width / 3, dim.height / 4);
		setSize(dim.width / 3, dim.height / 2);
		this.setVisible(true);
		long now = System.currentTimeMillis();
		long stop = now + millis;
		while (now<=stop) now = System.currentTimeMillis();
		this.setVisible(false);
	}

selbst wenn ich den while loop direkt in TFrame verwende, bekomme ich immer nur ein leeres Window angezeigt:

		Screen intro = new Screen("Button > "+cmd);
		intro.showOn();
		long now = System.currentTimeMillis();
		long stop = now + 5000;
		while (now<=stop) now = System.currentTimeMillis();
		intro.showOff();

ich werde jetzt JOptionPane als Altenaive verwenden - dann muss der User halt OK klicken ...

trotzdem würde ich mich freuen, wenn sich noch jemand findet, der Licht in dieses DUnkel bringt ...

thx

 

[IMartin]

Obiger Versuch mit dem Timer funktioniert schon fast:

Ja,

showOff()

im

actionPerformed

aufrufen. Über

TFrame.main(String[] args)

klappt es anschließend. (Auch die Zeile mit dem

tim.setRepeats(false)

besser reinnehmen.)

Über

Screen.main(String[] args)

funktioniert es nicht, weil

showFor(int millis)

nach Starten des Timers sofort zurückkehrt und in

main

das Programm beendet wird, noch bevor 5 Sekunden verstrichen sind.

 

[grinquel]

Hallo IMartin,

vielen Dank für Deine nochmalige Intervention - hat mir geholfen das ganze zu verstehn
vor allem der 2. Satz, denn ich hab's dann gar nicht mehr aus TFrame probiert
wenn ich mit dem while loop den System.exit in Screen.main verzögere, dann tut's da auch 🙂

für alle anderen nach Erkenntnis Suchenden - hier nochmal der funktionierende Abschnitt
mit Kommentaren - ich hoff ich hab alles richtig verstanden.

frohes Neues

	public void showFor(int millis)
	{
	    Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
	    setLocation(dim.width / 3, dim.height / 4);
	    setSize(dim.width / 3, dim.height / 2);
	    showOn();
        
        ActionListener timact=new ActionListener() {           // den Aufpasser timact instanziieren
              public void actionPerformed(ActionEvent evt) {   // wenn diese ein Event empfängt
            	  showOff();  // <<<------------------------- wir diese Funktion aufgerufen
              }};             // soweit der Teil der wartet, dass was passiert
             
        Timer tim = new Timer(millis, timact); // instanziieren des Timers, der den Event erzeugt
                                              // millis = Zeitabstand zwischen den Events
                                             // timecat = der Aufpasser von oben
        tim.setRepeats(false); // legt fest, dass der Timer nur einen Event erzeugt
        tim.start();          // und hier läuft er Timer los 
	}