Ablauf der paint-Methoden von JComponents

[butterbemme]

Hiho,
ich versuch grade ein simples TicTacToe mittels swing-Komponenten zu porgrammieren. Hab bisher nur Erfahrung mit awt und kenne mich da auch einigermaßen aus.

Bei awt-Komponenten läuft das Zeichnen im Prinzip ja nur über: repaint()->update()->paint()
Doch bei swing scheint das ja etwas anders zu laufen.
Kann mir da jemand die genaue Abfolge der Methoden erklären bzw. sagen welche Methoden es hierzu gibt?

Gruß
butterbemme

 

[butterbemme]

Durch das Tutorial bezüglich Zeichnen in swing (das mir vorher garnich aufgefallen is ) ist mir die ganze Sache schon klarer geworden.

Dadurch ist mir klar geworden, dass mein Problem folgendes ist:
Ich habe mehrere JPanel in JPanel in JFrame.
Und ich will in den "mehreren JPanel" jetzt meine Zeichen (Kreis und X) zeichnen. Obwohl die Methodenaufrufe funktionieren, wird irgendwie nicht gezeichnet.
Ist so eine Verschachtelung (und dabei auch noch zeichnen) überhaupt möglich??

 

[SlaterB]

grundsätzlich ja, Code posten wäre angebracht

 

[vanny]

Soweit ich weiß, sollte das Neuzeichnen der JPanel durch repaint(); angeschubst werden.
Wo führst du denn das repaint() aus?
Kann sein, dass du das in der untersten ebene zBsp. im Frame anstoßen musst. (is aber nur ein Verdacht)

Gruß Vanny

 

[butterbemme]

Also hier mein Code für das Fenster in dem sich alles abspielt:

public class Window extends JFrame implements ActionListener, MouseListener, MouseMotionListener{
	private JTextField statusanzeige;
	private Feld feld;
	private ArrayList<Feld> felder;
	private boolean start;

	public Window(){
		super("Tic Tac Toe");
		
		felder=new ArrayList<Feld>();
		statusanzeige=new JTextField();
		statusanzeige.setEditable(false);
		addMouseMotionListener(this);
		
		setLayout(new BorderLayout());
		
		JPanel north=new JPanel();
		north.setBackground(Color.lightGray);
		JButton start=new JButton("Start");
		start.addActionListener(this);
		JButton stop=new JButton("Stopp");
		start.addActionListener(this);
		north.add(start);
		north.add(stop);
		add("North",north);
		
		
		JPanel center=new JPanel(new GridLayout(3,3,1,1));
		for(int i=0;i<9;i++){
			felder.add(new Feld());
			felder.get(i).addMouseListener(this);
			center.add(felder.get(i));
		}
		add("Center",center);
		add("South",statusanzeige);
		
		setSize(300,300);
		setVisible(true);
	}
	
	public void paint(Graphics g){
		if(start){
			g.drawLine(101,64,101,270);
			g.drawLine(196,64,196,270);
			g.drawLine(0,132,291,132);
			g.drawLine(0,202,291,202);
		}
	}
	public void actionPerformed(ActionEvent e){
		if(e.getActionCommand().equals("Start")){
			statusanzeige.setText("Spieler 1 beginnt");
			start=true;
		}
		else if(e.getActionCommand().equals("Stopp")){}
	}
	public void mouseClicked(MouseEvent e){
		for(Feld f: felder){
			if(e.getSource().equals(f)){
				f.setKreuz();
				f.repaint();
			}
			
		}
		
	}
}

Und hier der Code für die einzelnen Felder, in denen das jeweilige Symbol (Kreis, X) gezeichnet werden soll

public class Feld extends JPanel{
	
	private boolean kreuz=false;
	private boolean kreis=false;
	
	public Feld(){
		super();
	}
	protected void paintComponent(Graphics g){
		super.paintComponent(g);
		if(kreuz){
			System.out.println("feld-<paint");
			g.drawLine(0,0,10,10);
			g.drawLine(0,10,10,0);
		}
		else if(kreis)
			g.drawOval(0,0,20,20);
	}
	public void setKreuz(){
		kreuz=true;
	}
	public void setKreis(){
		kreis=true;
	}

}

Die paint-Methode in Window ist warhscheinlich falsch. Da hab ich versucht mit meinem awt-Wissen in swing-Komponenten zu arbeiten.
Ich dachte mir das so: Sobald man den Startbutton betätigt, wird das Gitternetz in den JFrame eingezeichnet. Und immer wenn ich dann in eins der Felder klicke wird dann abwechselnd ein Kreis und ein X eingezeichnet (Die Routine zum abwechselnd Zeichnen fehlt hier auch noch)

 

[SlaterB]

> Die paint-Methode in Window ist warhscheinlich falsch.
muss weg, dann wirds schon besser

 

[Michael...]

Die paint() von JFrame würde ich schon mal gar nicht überschreiben und wenn dann

super.paint(g)

darin aufrufen, sonst siehst Du logischerweise Deine Felder nicht.
Besser ist es dem JFrame ein JPanel hinzuzufügen und eventuell dessen

paintComponent(...)

zu überschreiben. Hier kann man auch die Felder adden - allerdings super.paintComponent(...) nicht vergessen.
Ist vom Prinzip her nicht anders als mit AWT nur, dass es in Swing die paintComponent(...) gibt

 

[bERt0r]

Du willst ein TicTacToe (Idiotenschach) Spiel programmieren, ja? Dein code sieht - abgesehen davon dass es die Klasse Window schon gibt (in awt) und du dir darum einen anderen Namen dafür aussuchen solltest - ganz vernünftig aus.
Du hast nur ein Problem im Ansatz. Bei dir ist das Spielfeld aus Objekten zusammengesetzt. Um die Spiellogik umzusetzen hast du mit einem Feld aber nichts angefangen, auf was es ankommt ist die gesamte Matrix. Ob jetzt ein Kreuz, ein Kreis oder nichts in einem Feld steht, weis nur das Feld selber. Du hast nicht mal get Funktionen, wie willst du herausfinden ob 3 Kreuze in einer Reihe sind.
Normalerweise trennt man Daten, Logik und Anzeige. Du versuchst auf Anzeigeebene dein Programm zu gliedern und willst dann die Logik und die Daten da reinpacken.
Wie es einfacher geht:
Daten:
Alles was du brauchst ist ein 3x3 Array vom Typ int. Dann bestimmst du einfach 1=Kreuz, 2=Kreis, 0 = leer.
Logik:
Eine Funktion die überprüft, ob 3 gleiche 1er/2er in einer Reihe sind.
Eine Funktion, die ausrechnet, welchem Feld ein bestimmter Mausklick zugeordnet werden kann.
Anzeige:
Benötigst du wirklich für jedes Feld einen eigenen Component? Ein einzelnes, leeres JPanel reicht aus. Da kannst du die paintComponent Methode überschreiben, deine Linien und abhängig von deinem Array Kreuze, Kreise oder eben nichts zeichnen. So ein JPanel braucht und soll auch gar kein Layout haben, es sollen auch gar keine Components daraufgeaddet werden. Es wird nur als Zeichenfläche für deine Anzeige benötigt.

 

[hdi]

Alles was du brauchst ist ein 3x3 Array vom Typ int. Dann bestimmst du einfach 1=Kreuz, 2=Kreis, 0 = leer.

Besser noch als ein int-Array ist ein Array von enum-Werten. Lässt sich genauso einfach vergleichen, ist aber weniger anfällig gegen Logik-Bugs, das ist erstens bis zu einem gewissen Grad durch den Compiler gesichert und zweitens auch dadurch, dass man den Code einfach intuitiver lesen/schreiben kann.

Benötigst du wirklich für jedes Feld einen eigenen Component? Ein einzelnes, leeres JPanel reicht aus. Da kannst du die paintComponent Methode überschreiben, deine Linien und abhängig von deinem Array Kreuze, Kreise oder eben nichts zeichnen. So ein JPanel braucht und soll auch gar kein Layout haben, es sollen auch gar keine Components daraufgeaddet werden. Es wird nur als Zeichenfläche für deine Anzeige benötigt.

Das wiederum ist finde ich Geschmackssache. Gerade bei so einem Spiel würd ich auch dazu raten einzelne Components zu nehmen. Ein GridLayout bietet sich wunderbar an, ist auch von der Fenster-Größe her dynamisch ohne dass man in irgendeiner paint-Methode irgendwelche Koordinaten und Dimensionen berechnen muss. Und die Sache mit dem Mausklick auf ein Feld geht damit auch wesentlicher einfacher.

abgesehen davon dass es die Klasse Window schon gibt (in awt) und du dir darum einen anderen Namen dafür aussuchen solltest - ganz vernünftig aus.

+1, ist ungewohnt sauberer Code. Lediglich das add("Center") und add("South") gefällt mir nicht so gut.. Du solltest dafür lieber die Konstanten nehmen: BorderLayout.CENTER, BorderLayout.PAGE_END (oder .SOUTH). Ich weiß nicht ob du dich darauf verlassen kannst dass sich die Werte für diese Konstanten nicht vllt mal ändern. Vermutlich nicht.. Aber trotzdem würd ich lieber bei den Konstanten bleiben.

 

[SlaterB]

wenn dann allerdings die Linien dazwischen pixelgenau gezeichnet werden, siehe
g.drawLine(101,64,101,270);
g.drawLine(196,64,196,270);
g.drawLine(0,132,291,132);
g.drawLine(0,202,291,202);
dann ist das ne ganz üble Kombination,
entweder nur Komponenten mit Rahmen, höchstens deren paintComponent, oder lieber nur ein großes JPanel bemalen

 

[bERt0r]

Wenn du Enums üben willst ok, bei 3 unterschiedlichen Werten würd ich mir die Sache allerdings nicht antun. Da reichen auch 3 int Konstanten a la static final int KREUZ=1

 

[hdi]

Naja das feine an Enums ist dass man sie noch anreichern kann. zB auf Konsolen-Basis könnte man darin auch gleich das eigentliche Zeichen ablegen ('X' oder 'O'), oder halt in diesem Fall evtl ne Farbe in der die Felder gefüllt werden o.ä. Klar, Konstanten tun's im Moment auch, da hast du natürlich Recht. Wobei ich nicht verstehe was du dir mit enums "antun" willst, die Definition eines Enums mit 3 Werten ist weniger Code als 3 public static final xxx Zeilen.

 

[butterbemme]

Erstmal Danke für eure Antworten.
Ich habs jetzt hinbekommen und zwar mit meinem Ansatz den ich verfolgt habe, also 9 JPanel (die einzelnen TicTacToe-Felder) in einem großen JPanel Spielfeld (extra Klasse dafür erstellt) und das wiederum im Hauptfenster.

Zu euren Anregungen:
Wenn ich die einzelnen JPanel für die Felder weglasse und stattdessen nur ein JPanel fürs eigentliche Spielfeld verwende, dann müsste ich doch für jedes "Feld" in dem ein Zeichen gemacht werden kann einen eigenen If-case über den MouseListener erstellen, oder? Das stell ich mir grad sehr aufwendig vor.

Mit Enums kann ich mir die ganze Sache nicht wirklich vorstellen, das würde doch dann auch auf die If-cases mit MouseListener rauslaufen. Aber mit Enums kenn ich mich auch nicht so gut aus.

@bErt0r:
Mein obiger Code war auch noch nicht fertig. Mir gings einzig um das Zeichnen in meinen verschachtelten swing-Komponenten

Das wiederum ist finde ich Geschmackssache. Gerade bei so einem Spiel würd ich auch dazu raten einzelne Components zu nehmen. Ein GridLayout bietet sich wunderbar an, ist auch von der Fenster-Größe her dynamisch ohne dass man in irgendeiner paint-Methode irgendwelche Koordinaten und Dimensionen berechnen muss. Und die Sache mit dem Mausklick auf ein Feld geht damit auch wesentlicher einfacher.

So hab ich mir das auch gedacht

@SlaterB:
Genau so hab ichs aber durchgezogen und es funktioniert. Mein Spielfeld-JPanel malt die Matrix und die einzelnen Felder-JPanel kümmern sich nur um das jeweilige Zeichen.

Nur ein Problem hab ich noch:
Für meine Abfragefunktion ob ein Spieler gewonnen hat, hab ich jetz im Prinzip jeden einzelnen Fall für beide Zeichen betrachtet. Das ist natürlich absolut unschön und bestimmt auch nicht die effizienteste Lösung. Aber mir will da kein gescheiter Algorithmus einfallen...jemand ne Idee?

Gruß
butterbemme

 

[hdi]

Genau so hab ichs aber durchgezogen und es funktioniert. Mein Spielfeld-JPanel malt die Matrix und die einzelnen Felder-JPanel kümmern sich nur um das jeweilige Zeichen.

Es ist aber keine gute Idee, ein Panel gleichzeitig als Canvas (zum Zeichnen) und als Container (für Komponenten) zu verwenden. Kann etwas buggy werden in der Darstellung. Nimm die paint-Component raus. Die Anordnung der Widgets selbst erzeugt ja schon deine "Matrix". Wenn du an der Optik tweaken willst dann schau dir mal die Methode

Component#setBorder()

an, und die Klasse

BorderFactory

(Das wendest du auf die Felder-Panels an, nicht das große Panel)

Nur ein Problem hab ich noch:
Für meine Abfragefunktion ob ein Spieler gewonnen hat, hab ich jetz im Prinzip jeden einzelnen Fall für beide Zeichen betrachtet. Das ist natürlich absolut unschön und bestimmt auch nicht die effizienteste Lösung. Aber mir will da kein gescheiter Algorithmus einfallen...jemand ne Idee?

Ohne mir den Code jetzt angesehen zu haben: Du musst grundsätzlich nach jedem Spielzug nur die unmittelbaren Nachbarfelder checken, und nicht das gesamte Spielfeld. Denn geändert hat sich ja eh nur etwas an der Position wo der letzte Stein eingefügt wurde.

 

[butterbemme]

Okay, jetz versteh ich warum meine Lösung nicht die "sauberste" is.
Das muss ich mir noch näher anschauen mit "setBorder()" und "BorderFactory"

 

[hdi]

zB

feld.setBorder(BorderFactory.createLineBorder(Color.BLACK));

Gibt alle möglichen Borders in der Factory.

 

[butterbemme]

Hab mir das mit BorderFactory mal angeschaut. Funktioniert wunderbar. Danke nochma
Kann es sein, dass "setResizable(false)" irgend ne Auswirkung auf die Größe der Elemente in einem Container hat (also z.B. mein JFrame).
Nachdem ich das angewandt hab, waren meine selbstgezeichneten Linien verschoben/nicht mehr ganz sichtbar bzw. wurden von meinen JPanels überdeckt

 

[hdi]

Ja, in der Tat kann sowas passieren wenn du setResizable(false) zu spät aufrufst. Zu spät hast nachdem du schon angefangen hast mit dem Layout. Also vor setLayout und add-Aufrufen anwenden, dann sollte es keine Probleme geben.

 

[butterbemme]

Okay, hab das

setResizable(false)

erst kurz vor Schluss aufgerufen. Aber das hat sich ja wegen

feld.setBorder(BorderFactory.createLineBorder(Color.BLACK))

sowieso erledigt.

Aber noch was anderes: Kann ich bei einem JComponent auch nur einzelne "Kanten", z.B. rechte und obere Kante, zeichnen, oder bekomm ich die "Kanten" immer im kompletten Paket?

 

[hdi]

BorderFactory.createMatteBorder(int,int,int,int)

Damit kannst du einzelne Kanten zeichnen. Du kannst aber auch eine vollständig individuelle Border setzen. Kuck dir mal das Interface Border an. Du musst nur ein paar Methoden implementieren und kannst das gestalten wie du lustig bist. Ist recht ähnlich zum Zeichnen bei paintComponent(), nur heißt die Methode da anders.

 

[butterbemme]

Perfekt genau sowas hab ich gesucht. Wieso zum Teufel ist mir das beim API durchschauen nich aufgefallen?!
Naja egal. Nochmal Danke für deine Hilfe