Zugreifen auf JPanel

[ttmgot]

Hi,

ich bin neu in diesem Forum und kenne mich mit Swing-Programmierung noch nicht so gut aus:

Ich brauche ein JFrame innerhalb von dem ich mehrere Rechtecke zeichne und die Anzahl der Rechtecke soll sich verändern wenn sich die Fenstergröße ändert.Dazu habe ich eine Kindklasse von JPanel erstellt und die paintComponent Methode überschrieben. Die überschriebene paintComponent Methode macht das mit einen zweidimensionalen Arrays:

Sieht so aus:

[JAVA=53]
@Override
public void paintComponent(Graphics g){
super.paintComponent(g);
// boolean[][] Kopie = new boolean[this.getSize().height][this.getSize().width];
//
// for(int x=0; x<feld.length; x++){
// for(int y=0; x<feld[x].length; y++){
//
// while(x < Kopie.length && y < Kopie[x].length){
// Kopie[x][y]= feld[x][y];
// }
//
// }
// }

// feld = Kopie;
for(int x = 0; x < feld.length; x++){
for(int y = 0; y < feld[0].length; y++){
if(feld[x][y]){
g.setColor(Color.RED);
}else{
g.setColor(Color.BLACK);
}
g.fillRect(x*10, y*10, 9, 9);

}

}
}
[/code]
Dass mit dem Fenstergröße ändern, habe ich in der paintComponent Methode versucht, aber dabei hat sich das Programm immer aufgehängt.

Also habe ich versucht, diese Methode in in einem HierarchyBoundsListener innerhalb vom Konstruktor zu setzen, sodass er die Arraylänge nach jeder Größenänderung neu berechnet.

Dass sieht dann so aus:
[JAVA=18]
public Rechteck(boolean[][] feld){
this.feld = feld;
this.addHierarchyBoundsListener(new HierarchyBoundsListener(){

@Override
public void ancestorMoved(HierarchyEvent e) {
System.out.println("moved");

}

@Override
public void ancestorResized(HierarchyEvent e) {

boolean[][] Kopie = new boolean[this.getSize().height][this.getSize().width];

for(int x=0; x<feld.length; x++){
for(int y=0; x<feld[x].length; y++){

while(x < Kopie.length && y < Kopie[x].length){
Kopie[x][y]= feld[x][y];
}

}
}

feld = Kopie;
}

});
}
[/code]

Blöderweise greift dass Programm jetzt bei this natürlich nicht auf dass Panel (also hier die Klasse Rechteck) zu sondern auf den Listener.

Gibt es irgendeine möglichkeit auf das Panel innerhalb vom Listener wieder auf das Panel zuzugreifen???:L

 

[Marco13]

Schreib' dir erstmal eine utility-Methode

public static boolean[][] createCopy(boolean input[][], int newSizeX, int newSizeY)

oder so.

Und dann... poste mal mehr code. Vermutlich könnte man einen ComponentListener verwenden....

 

[ttmgot]

Erstmal danke für die schnelle Antwort.
Hier ist die komplette Kind-klasse von JPanel (ich hoffe, sie ist verständlich genug kommentiert):

public class Rechteck extends JPanel{
	
	static private boolean[][] feld;
	
	public Rechteck(boolean[][] feld){
		this.feld = feld;
		// Der Listener bemerkt ob das JFrame vergroeßert oder verkleinert wurde
		this.addHierarchyBoundsListener(new HierarchyBoundsListener(){

				@Override
				public void ancestorMoved(HierarchyEvent e) {
					System.out.println("moved");
					
				}

				@Override
				public void ancestorResized(HierarchyEvent e) {
					/* Diese Methode soll die Menge der Zellen anpassen
					 * wenn das JFrame veraendert wurde, wie in
					 * feld = createCopy(feld, Rechteck.getSize().height, Rechteck.getSize().width);
					*/
				}
		    	
		    });
	}
	
	//vorgeschlagene utility-Methode
	public static boolean[][] createCopy(boolean[][] input,int newSizeX, int newSizeY){
		boolean Copy[][] = new boolean[newSizeX][newSizeY];
		
		for(int x = 0; x < input.length; x++){
			for(int y = 0; y < input[x].length; y++){
				while(x < Copy.length && y < Copy[x].length){
					Copy[x][y]=input[x][y];
				}
			}
		}
		
		return Copy;
	}
	
	
	
	
	@Override
	public void paintComponent(Graphics g){
		//paintComponent-methode überschrieben
		super.paintComponent(g);

		for(int x = 0; x < feld.length; x++){
			for(int y = 0; y < feld[0].length; y++){
				if(feld[x][y]){
					g.setColor(Color.RED);
				}else{
					g.setColor(Color.BLACK);
				}
				g.fillRect(x*10, y*10, 9, 9);
			//zeichnet Zellen ein
			}
			
		}
	}

Dass Problem ist jetzt, dass ich vom Listener aus, nicht mehr auf das JPanel zugreifen kann.

Außerdem bin ich mir nicht sicher, ob es intelligenter ist, den Listener in den Konstruktor zu setzen, oder erst in das JFrame.

Das JFrame-Klasse sieht so aus:

public class GUITest extends JFrame{
	
    boolean[][] myColorField;
	private Rechteck rechteck;
	int frameWidth;
	int frameHeight;
	
	public GUITest(Rechteck rechteck, int frameWidth, int frameHeight){
		this.frameHeight =frameHeight;
		this.frameWidth = frameWidth;
		this.rechteck = rechteck;
		this.setTitle("Test");
	    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

	    setSize(frameWidth, frameHeight);
	    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
	    int x = (d.width - getSize().width) / 2;
	    int y = (d.height - getSize().height) / 2;
	    setLocation(x, y);
	    
	    
	    Container cp = getContentPane();
	    cp.setLayout(new BorderLayout());

	    
	    rechteck.setBackground(Color.WHITE);
	    cp.add(rechteck);
	
	setResizable(true);
	setVisible(true);

	}
	
}

Ich hab mir auch in der Java-Api Component-Listener durchgelesen, versteh aber noch nicht ganz, wie der das Problem umgehen kann?

 

[Marco13]

Dass Problem ist jetzt, dass ich vom Listener aus, nicht mehr auf das JPanel zugreifen kann.

Ahso... sorry, erst war nicht klar, was du meintest mit dem "Zugriff" - in dem Fall gab's zwei Probleme: Erstens war das 'feld' static (das war nicht ursächlich für das Problem, sollte aber nicht so sein), und wichtiger: Innerhalb des Listeners wußte er nicht mehr, ob der Parameter 'feld' gemeint war, oder die Variable 'feld' aus der Rechteck-Klasse, und hat deswegen gesagt ~'can not refer to non-final variable' oder so (In Zukunft immer gleich eventuelle Fehlermeldungen mit angeben, das macht das Antworten leichter).

Man könnte ihm an dieser Stelle sagen, welches 'feld' gemeint ist: Wenn man das 'feld' aus Rechteck meint, kann man statt 'feld' schreiben: [c]Rechteck.this.feld[/c]. Einfacher ist es aber, wenn man den Parameter 'feld' im Konstruktor anders nennt...


Hier das ganze nochmal als KSKB, auch mit einem ComponentListener:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class Rechteck extends JPanel {

	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {
				JFrame f = new JFrame("Test");
				f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
				boolean initial[][] = new boolean[50][50];
				for (int i = 0; i < 50; i++) {
					for (int j = 0; j < 50; j++) {
						initial[i][j] = Math.random() < 0.5;
					}
				}
				Rechteck rechteck = new Rechteck(initial);
				f.getContentPane().add(rechteck);
				f.setSize(500, 500);
				f.setVisible(true);
			}
		});
	}

	private boolean[][] feld;

	public Rechteck(boolean[][] feldEingabe) {
		this.feld = feldEingabe;

		// Der Listener bemerkt ob das Rechteck vergroeßert oder verkleinert wurde
		this.addComponentListener(new ComponentAdapter() {

			@Override
			public void componentResized(ComponentEvent e) {
				int sx = getWidth() / 10;
				int sy = getHeight() / 10;
				System.out.println("Resizing to " + sx + " " + sy);
				feld = createCopy(feld, sx, sy);
			}
		});
	}

	// vorgeschlagene utility-Methode
	private static boolean[][] createCopy(boolean input[][], int newSizeX, int newSizeY) {
		boolean result[][] = new boolean[newSizeX][newSizeY];
		int sx = Math.min(input.length, newSizeX);
		for (int i = 0; i < sx; i++) {
			int sy = Math.min(newSizeY, input[i].length);
			System.arraycopy(input[i], 0, result[i], 0, sy);
		}
		return result;
	}

	@Override
	public void paintComponent(Graphics g) {
		// paintComponent-methode überschrieben
		super.paintComponent(g);

		for (int x = 0; x < feld.length; x++) {
			for (int y = 0; y < feld[0].length; y++) {
				if (feld[x][y]) {
					g.setColor(Color.RED);
				} else {
					g.setColor(Color.BLACK);
				}
				g.fillRect(x * 10, y * 10, 9, 9);
				// zeichnet Zellen ein
			}

		}
	}
}

Aaaaaber: Du solltest mal genauer beschreiben, was du vorhast ... meine Kristallkugel sagt was vom "Spiel des Lebens", aber die irrt sich manchmal Trotzdem ist das in dieser Form mit ziemlicher Sicherheit nicht das, was du willst.... Dass das Erstellen der größeren Array-Kopie von der Componentengröße abhängt ist sehr seltsam und suspekt ... :noe:

 

[ttmgot]

Erstmal nochmal ein dickes Dankeschoen:applaus:
Find ich toll, dass es Leute gibt die sich die Zeit nehmen, um sich mit den Problemen von anderen zu beschaeftigen.
Zweitens, entschuldige bitte, dass ich mein Problem nicht genau genug beschrieben hab. Deine Kristallkugel hat recht, und es haengt wirklich mit dem Game of Life zusammen, und außerdem ist es wirklich bloed, dass die Zellenanzahl von der Fenstergroeße abhaengt, aber das ist nun mal leider die Aufgabenstellung,

Weiss auch nicht wer sich sowas ausdenkt:noe:

Also danke nochmal fuer die Loesung des Problems und ausserdem habe ich so viele neue Programmiertricks gelernt.:toll: