ActionListener andere JFrames auslesen

[virtuellesNugat]

Hi!
Ich hab eine GUI, darin wird ein Unterfenster geöffnet. Dieses Unterfenster soll dazu da sein, sich anzumelden. Also zum Beispiel den Namen in das JTextField jtName eintragen.

Die Klasse Runde implements ActionListener und in ActionPerformed würde ich gerne die Felder aus dem AnmeldeFenster auslesen.

		jtName = new JTextField();
		jtName.addActionListener(this);
		jtName.addActionListener(new Runde());
		
		button = new JButton("Anmelden");
		button.setName("Anmelden");
		button.addActionListener(this);
		button.addActionListener(new Runde());

new Runde() ist wohl nicht optimal bei ActionListener Wenn ich in Runde eine Instanz von Anmeldung erstelle, dann kommt natürlich Stack Overflow

Was ich aber sehr cool fand, war, dass ich nicht das explizite Objekt von Runde sondern nur die Klasse ansprechen brauchte. Mit nem JSlider und dem StateChangedListener ging das super event.getSource().getValue() und man hatte direkten Zugriff auf die Daten des Sliders, auch in dem expliziten Objekt (also der Hauptklasse) - trotz addActionListener(new Runde()).

Bei dem Button ist das natürlich eine andere Geschichte, denn der Button selber hat keine Informationen, er sagt nur, dass die Daten abgeschickt werden sollen und klassenintern kann man die Daten ja auch leicht verarbeiten. Aber wie schaffe ich es jetzt die drei Textfelder auszulesen, obwohl ich nur auf den Button drücke?
Ich weiß, dass es bei Buttons mit einem ActionListener die Funktion doClick() gibt, was einfach so tut als wäre der Button geschickt worden. Wenn ich dem Textfeld also einen ActionListener mitgeben würde und den dann sein Event feuern lassen könnte, dann hätte ich die Daten ja in meiner Runde.
Geht das? Muss das noch ganz anders gemacht werden?
Wäre für jede Idee dankbar, denn es ist SEHR dringend!

 

[javimka]

Zu einem StackOverflow kommt es ja nur, wenn du den oben genannten Code im Konstruktor der Klasse Runde hast.

Am besten wäre wohl, wenn die actionPerformed des ActionListeners, den der Button erhält, die Strings aus den Textfeldern auslesen würde. Diese actionPerformed ruft sicher irgendeine weitere methode auf. Dieser Methode könnten auch gleich die Strings als Argumente übergeben werden.

 

[virtuellesNugat]

Ja, das weiß ich und es ist auch genau so wie du gesagt hast.
Aber wie bekomme ich jetzt die Infos aus der GUI in die Runde rein? Am besten ohne der Anmeldung ein Rundenobjekt mitgeben zu müssen.

 

[00101001]

Ich habe ein änliches Problem und wäre sehr erfreut wenn einer diese Sache ein bißchen mehr LICHT ins Dunkle bringen würde.

 

[javimka]

Ein bisschen mehr Code wäre hilfreich. z.B. die Klasse Runde. Wenn du den obigen Code im Konstruktor der Klasse Runde hast, wäre vielleicht die Lösung [c]button.addActionListener(this);[/c] zu schreiben, statt "new Runde()".

Dieses "Unterfenster", ist das ein JFrame oder ein JInternalFrame?

Der Button, der gedrückt wird und der die Strings aus den Textfeldern irgendwo hinbringen soll, ist doch sicher in derselben Klasse, wie die Textfelder selber oder? Dann sollte es ja auch kein Problem sein, dem Button einen ActionListener anzuhängen, der diese Strings aus den Textfeldern ausliesst. Bleibt noch das Problem, dass diese Strings irgendwohin müssen (wohin eigentlich?).
Welche Methode auch immer diese Strings benötigt, kann die als Argumente übernehmen. Der ActionListener müsste dann also diese Methode mit den Strings als Argumente aufrufen.

 

[virtuellesNugat]

Klasse Runde:
Öffnet nur eine Instanz von Anmeldung und implementiert den ActionListener, hat also auch die ActionPerformed.

Klasse Anmeldung:

public class Anmeldung extends JFrame implements ActionListener {

	/**
	 * 
	 */
	private static final long serialVersionUID = -7480858305089010560L;
	private final int x = 300, y = 150;
	public JTextField jtName, jtIP, jtPort;
	public JLabel meldung;
	public JButton button;

	public Anmeldung(){
		draw();
	}

	private void draw() {
		// TODO Auto-generated method stub
		
		//Gesamtaufteilung
		JPanel oben = new JPanel();
		oben.setPreferredSize(new Dimension(x - this.getInsets().left - this.getInsets().right, 45));
		JPanel unten = new JPanel();
		unten.setPreferredSize(new Dimension(x - this.getInsets().left - this.getInsets().right, y - oben.getPreferredSize().height));
				
		//obere Teil
		JPanel o_links = new JPanel();
		o_links.setPreferredSize(new Dimension(100, oben.getPreferredSize().height));
		JPanel o_rechts = new JPanel();
		o_rechts.setPreferredSize(new Dimension(40, oben.getPreferredSize().height));
//		o_rechts.setBackground(new Color(255, 255, 0));
		
		//oben links
		JLabel ip = new JLabel(" Server IP:");
		jtIP = new JTextField("192.168.2.118", 1);
		jtIP.setToolTipText( getToolTipText("Eingabe der IP", "Gib hier die IP Adresse des Servers ein.<br />Achte darauf, dass der Server bereits existiert.") );
		o_links.setLayout(new GridLayout(2, 1, 0, 0));
		o_links.add(ip);
		o_links.add(jtIP);
		
		//oben rechts
		JLabel port = new JLabel(" Port:");
		jtPort = new JTextField("5000", 1);
		jtPort.setToolTipText( getToolTipText("Eingabe des Ports", "Gib hier den Port des Servers ein.<br />Achte darauf, dass der Server bereits existiert.") );
		o_rechts.setLayout(new GridLayout(2, 1, 0, 0));
		o_rechts.add(port);
		o_rechts.add(jtPort);
		
		oben.setLayout(new FlowLayout(FlowLayout.LEADING, 2, 0));
		oben.add(o_links);
		oben.add(o_rechts);
		
		
		//untere Teil
		JPanel off_oben = new JPanel();
		JPanel mitte = new JPanel();
		JPanel u_unten = new JPanel();
		JLabel name = new JLabel(" Trage deinen Namen ein (maximal 12 Zeichen):");
		meldung = new JLabel();
		meldung.setForeground(new Color(240, 0, 0));
		jtName = new JTextField();
		jtName.setPreferredSize(new Dimension(x-100, 27));
		jtName.addActionListener(this);
		jtName.addActionListener(new Runde());
		jtName.setToolTipText( getToolTipText("Namensfeld", "Gib hier deinen Namen ein.<br />Achte darauf, dass die L&auml;nge zw&ouml;lf Zeichen nicht &uuml;berschreitet.") );
		
		button = new JButton("Anmelden");
		button.setName("Anmelden");
		button.addActionListener(this);
		button.addActionListener(new Runde());
		button.setToolTipText( getToolTipText("Anmeldeknopf", "Best&auml;tige deine Eingaben und verbinde dich mit dem Server.") );
		
		off_oben.setPreferredSize(new Dimension(x - this.getInsets().left - this.getInsets().right, 8));
		off_oben.setOpaque(true);

		
		mitte.setPreferredSize(new Dimension(x, 27));
		mitte.setLayout(new FlowLayout(FlowLayout.LEADING, 0, 0));
		mitte.setOpaque(false);
		mitte.add(jtName);
		mitte.add(button);
		
		u_unten.setPreferredSize(new Dimension(x, 25));
		u_unten.setOpaque(false);
		u_unten.add(meldung);		
				
		unten.setLayout(new FlowLayout(FlowLayout.LEADING, 0, 0));
		
		unten.add(off_oben);
		unten.add(name);
		unten.add(mitte);
		unten.add(u_unten);
		
		this.setLayout(new FlowLayout(FlowLayout.LEADING, 0, 0));
		this.add(oben);
		this.add(unten);
		
		this.setTitle("Anmeldung");
		this.setSize(x, y);
		this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		this.setVisible(true);
		this.setLocationRelativeTo(null);
	}
	
	private String getToolTipText(String title, String text){
		String temp = new String("<html><body text=\"#333300\" bgcolor=\"#FFFFDD\">");
		temp = temp + "<b>" + title + "</b><br />" + text + "</body></html>";
		return temp;
	}
	
	public void actionPerformed(ActionEvent ae) {
		if(ae.getSource() instanceof AnmeldeButton){
			button.setPlayerName(jtName.getText());
			button.setIp(jtIP.getText());
			button.setPort(Integer.parseInt(jtPort.getText()));
		}
		if(jtName.getText().length() <= 12){
			if(jtName.getText().equals("")){
				meldung.setText("Du hast keinen Namen eingegeben!");
			}
			else{
				//Serververbindung
//				runde.verbinden(jtIP.getText(), Integer.parseInt(jtPort.getText()), jtName.getText());
//noch nicht implementiert, soll auch nicht so geschehen, sondern die Daten nur RUnde übergeben und dann soll darin die Verbindung erstellt werden.
			}
		}
		else{
			try{
				jtName.setText(jtName.getText().substring(0, 12));
				meldung.setText("Es sind maximal 12 Zeichen zugelassen!");
			} catch(StringIndexOutOfBoundsException e){
				e.printStackTrace();
			}
		}
		if(jtIP.getText().length() == 0 || jtIP.getText().equals("192.168.x.x")){
			meldung.setText("Du hast keine IP eingegeben!");
		}
		else if(jtPort.getText().length() == 0){
			meldung.setText("Du hast keinen Port eingegeben!");
		}
	}

}

So sieht es derzeit aus..
Ich würde jetzt gerne Runde benachrichtigen und der Klasse die Inhalte der Felder zugänglich machen. Wenn ich in Runde eine Instanz schaffe von Anmeldung ist es ja recht einfach, aber toll ist es nicht gerade. Ich würde am liebsten keine solcher Tricks anwenden müssen.. Wenn dann eine Verbindung erstellt wird, dann hätte ich vermutlich wieder Probleme mit dem Anmeldefenster. Weil ich da noch weitere Möglichkeiten drin haben will.
Zum Beispiel:

//str kommt als Objekt vom Server
else if(str.equals("Warten auf weitere Spieler")){
			anm.meldung.setText(str + " - Bitte nicht schließen");
			anm.jtIP.setEditable(false);
			anm.jtPort.setEditable(false);
			anm.jtName.setEditable(false);
			anm.button.setEnabled(false);
			
			//Hier erwarte ich ein neues Objekt vom Server um mich dann entgültig reinzulassen
			str = (String) client.getObject();
			if(str.equals("OK")){
				anm.dispose();
				sperre = false;
			}

An sich ist das nicht so verkehrt denke ich, aber ich erwarte danach noch ein Objekt vom Server und Java macht dann leider keinerlei Anstalten, die Meldung (meldung.setText()) zu zeichnen. Es hängt einfach und der Button blockiert.
Wieso ist das so? Selbst wenn ich einen Timer zuvor runterlaufen lasse oder einen Thread.sleep mache, wird nichts gezeichnet. Es sei denn der Server resettet die Verbindung, dann klappts wieder.

Client sieht so aus:

public class Client implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 001L;
	static private Socket s;
	private Object o;
	
	public Client(String ip, int port) {
		try {
			s = new Socket(ip, port);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	

	public void sendObject(Object o) {
		try {
			ObjectOutputStream ostream = new ObjectOutputStream(s.getOutputStream());
		    ostream.writeObject(o);
		} catch (IOException e) {
			e.printStackTrace();
		}		
	}
	
	public Object getObject(){
	    GetObjThread gobj = new GetObjThread(this);
	    (new Thread(gobj)).start();
	    while(gobj.getObject() == null){
	    	
	    }
	    Object obj = gobj.getObject();
	    
	    if(obj == null){
	    	obj = new String ("Achtung null");
	    }
	    return obj;
	}	

	public Socket getS() {
		return s;
	}


	public void setS(Socket s) {
		Client.s = s;
	}
	
	public void closeConnection(){
		try {
			s.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		s = null;
	}
	
	public boolean isAvailable(){
		boolean available = false;
		try {
			if(s.getInputStream().available() > 0){
				available = true;
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return available;
	}
	
}

Wegen dem getObject:

public class GetObjThread implements Runnable{

	private Socket s;
	private Object o;
	
	public GetObjThread(Client client){
		s = client.getS();
		o = null;
	}
	
	public void run() {
		ObjectInputStream ois;
		try {
			ois = new ObjectInputStream(s.getInputStream());
			Object o = ois.readObject();
		    this.o = o;
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	
	public Object getObject(){
		return o;
	}

}

Ich weiß, dass wir keine Streams schließen, aber wenn wir das täten, würde der Socket geschlossen und wir könnten keine Daten mehr schicken. Aber ist das das Problem, oder liegts woanders dran?!

 

[javimka]

Du kannst der Klasse Runde einen Konstruktor bauen, der 3 Strings übernimmt. Wenn du dann in der actionPerformed der Klasse Anmeldung bist, kannst du schreiben [c]new Runde(str1, str2, str3);[/c] und diese Instanz von Runde kann dann direkt die Verbindung mit dem Server ausbauen und tun, was sie tun muss.

 

[virtuellesNugat]

Aber Runde startet doch Anmeldung. Der erste Schritt in Runde soll also sein:
- Anmeldung starten und die Daten aus Anmeldung auslesen
- Verbindung zum Server erstellen
- anschließend mit der bestehenden Verbindung Objekte zwischen Server und Client austauschen und diese dann mittels der GUI Klasse darstellen

Wir wollen auch kein Rundenobjekt in Anmeldung haben, weil sonst darin wieder eine aktive Verbindung besteht und das immer Probleme macht..

 

[javimka]

Irgendeine der beiden Klassen braucht eine Referenz auf die andere, sonst kann es ja keinen Datenaustausch geben.
Ich würde dir halt doch empfehlen, dass Runde eine Instanz von Anmeldung erstellt und sich selbst als Parameter übergibt und Anmeldung in der actionPerformed runde.connect() aufruft. Du hast dann halt eine doppelte Verkettung. Aber das ist das einfachste.

Als alternative könntest du Runde als ActionListener an den Button hängen. Wenn der Button gedrückt wird, wird die actionPerformed in Runde auszulöst und diese könnte dann anmeldung.getStrinigs() aufrufen, die dann diese 3 Strings in einem Array zurückgibt. Runde kann damit dann machen, was nötig ist. Aber auch hier musst du dem Konstruktor von Anmeldung eine Referenz auf Runde übergeben.

Wenn du wirklich keine Referenzen dazuwischen willst, könnte Runde im Konstruktor eine Instanz von Anmeldung erstellen, diese aber nicht als Membervariable speichern. Dem Konstruktor von Anmeldung würde Runde dann sich selbst mitgeben. Anmeldung speichert Runde aber auch nicht als Membervariable ab, sondern hängt es nur an den Button.
Wenn der Button gedrückt wird, wird die actionPerformed in Runde ausgelöst. Runde ruft dann getSource auf und kriegt den Button. Dann kannst du button.getParent aufrufen und kriegst das Panel, indem der Button liegt. Auf dem kannst du getComponents() aufrufen und kriegst alle Kinderkomponenten. Darunter sind auch die 3 Textfelder, die du nur noch finden musst.
Aber das ist natürlich ein hochkrimineller Hack, den ich nie und nimmer machen würde!

 

[Muli]

Hallo,

ich würd die ActionListener innerhalb deines GUI Blocks unterbringen und dann deine Eigenschaften, die Du übermitteln möchtest mit einem PropertyChangeListener übergeben.


Hier handelt die GUI die ActionEvents ab und du übergibst dann nach oben hin was du gerne möchtest mittels des firePropertyChange.

Simples Beispiel:

public class Verwaltung implements PropertyChangeListener {

public Verwaltung (){
MyJFrame frame=new MyJFrame();
frame.addMyPropertyChangeListener(this)
}
public void propertyChange(PropertyChangeEvent evt) {
    String was_ist_in_der_gui_passiert=""+evt.getNewValue();
       // hier reagierst du auf Übergabe
    }
}


[..]

public class MyJFrame  {
 private PropertyChangeSupport changes = new PropertyChangeSupport(this);

 public  MyJFrame(){
      getContentPane().setLayout(new BorderLayout());
      JButton but = new JButton();
      but.addActoinListener(){
          public void actionPerformed(ActionEvent e){
                   changes.firePropertyChange("Button", "", "gedrückt");
              }
      }
      getContentPane().add(but,BorderLayout.CENTER);
 }

 public void addMyPropertyChangeListener(PropertyChangeListener l) {
       changes.addPropertyChangeListener(l);
 }
 }

LG,
Muli

 

[virtuellesNugat]

GENAU das wollte ich haben Danke Muli!!

 

[virtuellesNugat]

Sorry für den Doppelpost, aber sonst sieht niemand, dass was Neues hier steht

Ist es ratsam eine Socketverbindung in einem Objekt zu speichern wie oben angegeben? Oder sollte man lieber jedes Mal eine neue Verbindung öffnen?

 

[javimka]

Wie oft machst du das denn? Anstatt alle 5 Sekunden eine neue Verbindung zu öffnen, würde ich eher eine einzige bestehen bleiben lassen. Aber wenn du die Verbindung nur alle 10 min brauchst, würde ich eher jedesmal eine neue erzeugen.

 

[virtuellesNugat]

Es ist eine Pokersoftware. Also müssten häufig die Daten ausgetauscht werden.

Das Problem ist zurzeit, dass wenn ein neues Info-Objekt ausgewertet werden soll in der GUI, dass danach die Client-Verbindung nicht mehr geht. Also wenn wir dann client.send(Object o) machen, dann gibts ne Nullpointer Exception.

Kennst du vllt eine zuverlässige Möglichkeit die Verbindungen zu sichern? Weil wir, wie du oben sehen kannst, zum Beispiel auch keine Streams schließen dürfen, weil sonst der Socket dicht ist.

 

[javimka]

Leider kenne ich mich da nicht genügend aus.

 

[virtuellesNugat]

hmm ok.. aber irgendjemand aus diesem Forum kennt doch sicher die Antwort

 

[Paddelpirat]

Hängt bestimmt auch alles mit deinem letzten Thread und der hängenden GUI zusammen ;-)
Irgendwo ist da der Wurm drin, behaupte ich jetzt mal ganz dreist *g*

Normalerweise kannst du eine Socketverbindung einfach offen lassen und immer weiter darüber kommunizieren. Ich würde die Verbindung auch offen lassen, da du ja wahrscheinlich nicht mit tausenden von Clients rechnest, oder?


Edit: Da du eh schon mit Objekten hantierst, hast du mal überlegt, ob du das ganze nicht über RMI lösen könntest?

Edit2: Übrigens find ich deine Methode

getObject()

in deiner

Client

-Klasse sehr verdächtig. Versuch mal die while-schleife darin in die

GetObjThread

-Klasse zu bekommen.

 

[virtuellesNugat]

Genau das habe ich heute ja rausgenommen

Das Problem hier mit den Nullpointern war so dämlich, dass mir das nicht mal aufgefallen ist
Ich mache addActionListener(new Runde()) Er reagiert darauf logischerweise richtig, aber alle darin erstellten Objekte passen dann natürlich nicht...

Wenn ich jetzt aber das tatsächliche Objekt von runde in die GUI mitgebe um den ActionListener aufzurufen, dann klappt das mit der Verbindung... nur beim Zeichnen kriege ich es wiedermal nicht korrekt hin...

An was muss ich mich halten, wenn ich ein paar neue Informationen erhalte und damit alles aktualisieren will?! Langsam krieg ich ne mittelschwere Krise

Edit:

RMI hab ich keine Zeit mehr für, bis 10. muss es fertig sein
Das mit der ausgelagerten getObject Klasse als Thread hab ich auch erst seit heute drin - aber ich habs mal so gemacht wie du vorgeschlagen hast, macht ja auch mehr Sinn.