JPanel "verschmelzen" GridLayout

[FranzFerdinand]

Hallöle Leutis,

ich habe da ein kleines Problem:
Ich habe ein 11 mal 11 GridLayout mit 121 JPanels. Ich möchte nun, dass die letzte Reihe, die 11. (Javatechnisch #10) ein einziges JPanel und nicht 11 verschiedene ist. Ich würde da gerne Text drauf schreiben, in die gesamte letzte Zeile.

Dazu habe ich mal gegooglet, ob man die 11 JPanels nicht zu einem Panel machen kann. So übergreifend. Dazu habe ich nichts gefunden, ich habs stattdessen so probiert:

public class Spielfeld extends JPanel {

	private Spielzelle spielfeldzelle[][] = new Spielzelle[11][11];

	public Spielfeld() {
		setLayout(new GridLayout(11,11));
		for(int i=0;i<11;i++) {
			for(int n=0;n<11;n++) {
				spielfeldzelle[n][i] = new Spielzelle(Spielzelle.Typ.Leer);
				spielfeldzelle[n][i].setBackground(new Color(0,255,255));
				spielfeldzelle[n][i].setOpaque(true);
				add(spielfeldzelle[n][i]);
			}
		}
		for(int i=1;i<11;i++) {
			spielfeldzelle[i][10].setOpaque(false);
		}
		spielfeldzelle[0][10].setSize(spielfeldzelle[5][5].getWidth()*11, spielfeldzelle[5][5].getHeight());
		spielfeldzelle[0][10].setBackground(new Color(255,0,255));
		spielfeldzelle[0][10].setOpaque(true);

Also mit einfach 11 mal 10 und dann unten ein ganz großes ran ging schon mal gar nicht.
Nun hatte ich das so probiert, dass ich die letzte Reihe versuche auszublenden und dann von dem allerersten ganz unten die Breite verelffache, ausgehend vom Wert einer beliebigen anderen Zelle 5,5, weil die ja alle gleich groß sind.

Aber das klappt so nicht. Ich lasse mich mit der Backgroundzeile da die Zelle Pink machen, um das besser zu sehen und leider ist da weiterhin nur die aller erste von 11 Plätzen Pink.


Kurze Frage: GridLayout heißt ja auch gleiche Größe...

Ist das, was ich da mache überhaupt sinnvoll und möglich?
Wie funktioniert das??

Schöne Grüße
Lukas

 

[strußi]

und wenn du ein gitter 11X10 und unten ein jLabel bzw. jTextfield hinzufügst?

 

[FranzFerdinand]

und wenn du ein gitter 11X10 und unten ein jLabel bzw. jTextfield hinzufügst?

Hallöle und danke für Dene Antwort,

gerade probiert. Die Art des Elementes scheint im Prinzip Wumpe.
JLabel, JTextField, JPanel. Am Ende kommt immer heraus, dass er den setSizeBefehl ignoriert. Da es sich ja um ein Dynamisches Layout handelt, kann ich das ja eigentlich auch nachvollziehen... Durch pack(); am Ende wird das ja alles am Ende trotzdem umgewürfelt.

 

[strußi]

schau dir noch mal diese Seite an. vorallem den punkt mit weightx, das sehe ich in deinem codbeispiel nicht und dein GridBagConstraints vermisse ich auch.

Grüße

 

[X5-599]

Es wird ein GridLayout benutzt; kein GridBagLayout. Aber ich denke schon, dass das GridBagLayout hier eher geeignet ist.

Kleines Beispiel wie man es machen könnte (Gibt natürlich noch mehrere Möglichkeiten; Das GridBagLayout ist einer der vielseitigsten und anspruchsvollsten LayoutManager)

public static void main(String[] args)
{
	SwingUtilities.invokeLater(new Runnable() {
		
		@Override
		public void run()
		{
			final JFrame frame = new JFrame("Test Frame");
			frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			frame.setSize(400, 400);
			frame.setLocationRelativeTo(null);
			
			JPanel panel = new JPanel(new GridBagLayout());
			
			GridBagConstraints gbc;
			for(int y = 0; y < 11; y++)
			{
				for(int x = 0; x < 11; x++)
				{
					gbc = new GridBagConstraints();
					gbc.gridx = x;
					gbc.gridy = y;
					
					JPanel pane = new JPanel();
					if(y % 2 == 0)
					{
						pane.setBackground(x % 2 == 0 ? Color.BLUE : Color.GREEN);
					}
					else
					{
						pane.setBackground(x % 2 == 0 ? Color.GREEN : Color.BLUE);
					}
					pane.setOpaque(true);
					
					if(y == 10)
					{
						gbc.gridwidth = 11;
						gbc.fill = GridBagConstraints.HORIZONTAL;
						panel.add(pane, gbc);
						break;
					}
					
					panel.add(pane, gbc);
				}
			}
			
			
			frame.add(panel, BorderLayout.CENTER);
			frame.setVisible(true);
		}
		
	});
}

Sieht so aus:

 

[FranzFerdinand]

Wunderschönen Guten Tag,

vielen dank für eure Antworten,

ich sehe schon ,ich muss das GridLayout tatsächlich durch ein GridBagLayout ersetzen.
Habe schon etwas Erfahrung damit. Folgendes: Mein Spiel setzt sich schon es mehreren dieser Layouts zusammen. Dieser eine Teil den ich gepostet habe ist nur das Mittelstück.

Die Klasse dafür sieht nun so aus:

public class Spielfeld extends JPanel {

	private Spielzelle spielfeldzelle[][] = new Spielzelle[11][11];

	public Spielfeld() {
		setLayout(new GridBagLayout());
		GridBagConstraints gbc;
		for(int y=0;y<11;y++) {
			for(int x=0;x<11;x++) {
				gbc = new GridBagConstraints();
				gbc.gridx = x;
				gbc.gridy = y;

				if(y<10) {
					spielfeldzelle[x][y] = new Spielzelle(Spielzelle.Typ.Leer);
					spielfeldzelle[x][y].setBackground(new Color(0,255,255));
					spielfeldzelle[x][y].setOpaque(true);
					add(spielfeldzelle[x][y], gbc);
				} else if(y==10) {
					gbc.gridwidth = 11;
					gbc.fill = GridBagConstraints.HORIZONTAL;
					spielfeldzelle[x][y] = new Spielzelle(Spielzelle.Typ.Leer);
					spielfeldzelle[x][y].setOpaque(true);
					spielfeldzelle[x][y].setBackground(new Color(255,0,255));
					add(spielfeldzelle[x][y], gbc);
					/*JLabel meldungsbox = new JLabel();
					meldungsbox.setBackground(new Color(255,0,255));
					meldungsbox.setOpaque(true);
					add(meldungsbox, gbc);*/
					break;
				}
			}
		}
	}
}

Also es ist nun ein BagLayout. Ich zähle, in Anlehnung an den letzten Vorschlag von X5-599 weiter mein 11 mal 11 Feld durch und mache bei y=10 eine Sonderregelung, bei der die Breite Elffach ist und nach dem ersten Feld mit Break abgebrochen wird.

So weit so gut.

Nun funktioniert es auch mit 11 mal 11 und die letzte Zeile wird komplett Pink.

Aber nun machen mich zwei Sachen noch ganz jeck:
1. Wie in dem Auskommentierten Textabschnitt zu sehen habe ich es auch mit einem JLabel anstatt einer "Spielzelle" (eine für euch unbedeutende Klasse, die ich von JPanel ableite) versucht. Wenn ich also in die if(y==10) Bedingung das hier reinschreibe, dann passiert nichts. Dann wird ab Zeile 10 einfach aufgehört:

gbc.gridwidth = 11;
					gbc.fill = GridBagConstraints.HORIZONTAL;
					JLabel meldungsbox = new JLabel();
					meldungsbox.setBackground(new Color(255,0,255));
					meldungsbox.setOpaque(true);
					add(meldungsbox, gbc);
					break;

Kann sich jemand erklären, wieso das so ist? Ist doch beides der gleiche Quelltext, nur dass das eine ein JPanel und das andere ein JLabel ist...

Und zweitens: Das mit den Relationen passt wohl irgendwie noch nicht so.


Einfach in der Mitte und nicht Formatfüllend. Mit dem GridLayout weiter oben war das noch das ganze Format ausfüllend. Hab ich da etwas vergessen? Habe nichts außer dem oben angegebenen Code verändert.

Schöne Grüße
Lukas

 

[X5-599]

JLabel sind häufig (immer?) nur so gross wie der Text, den sie anzeigen sollen. Zumindest, wenn nicht anders angegeben. Wie auch immer, du kannst die "Bags" des GridBagLayouts sich dynamisch vergrössern lassen (Dann müssten auch die JLabels angezeigt werden). Dazu kannst du weights vergeben. Wie strußi schon sagte geht das mit weightx/y. Zusammen mit gbc.fill passen sich die "Bags" dem verfügbaren Platz an. Was das weightx/y genau bewirkt kann ich dir nicht sagen. Es ist wohl sowas wie eine Wichtigkeit des "Bags". Für die für die Platzverteilung. Sie wirkt sich aus, wenn grösser 0.0. Ich nehme an wenn du drei "Bags" definiert hast mit weightx: 0.2, 0.4 und 0.5; bekommt die letze den meisten Platz etc. Das ist aber nur eine Vermutung. Hab schon länger nichts mehr mit GridBagLayout gemacht und immer wenn es mal wieder soweit ist erreiche ich meistens nur durch rumprobieren mein Ziel...

Lange Rede kurzer Sinn: Kannst das hier mal probieren (Wie gesagt, keine garantierte optimale Lösung)

gbc.weightx = 1.0;
gbc.weighty = 1.0;
gbc.fill = GridBagConstraints.BOTH;

Das

gbc.fill = GridBagConstraints.HORIZONTAL;

für y==10 müsste dann raus.

 

[FranzFerdinand]

Hallöle,

vielen dank!
Läuft sehr gut.

public Spielfeld() {
		setLayout(new GridBagLayout());
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.weightx = 1.0;
		gbc.weighty = 1.0;
		gbc.fill = GridBagConstraints.BOTH;
		
		for(int y=0;y<11;y++) {
			for(int x=0;x<11;x++) {
				gbc.gridx = x;
				gbc.gridy = y;

				if(y<10) {
					spielfeldzelle[x][y] = new Spielzelle(Spielzelle.Typ.Leer);
					spielfeldzelle[x][y].setBackground(new Color(0,255,255));
					spielfeldzelle[x][y].setOpaque(true);
					add(spielfeldzelle[x][y], gbc);
				} else if(y==10) {
					gbc.gridwidth = 11;
					meldungsbox.setBackground(new Color(0,255,255));
					meldungsbox.setOpaque(true);
					meldungsbox.setHorizontalAlignment(SwingConstants.CENTER);
					add(meldungsbox, gbc);
					break;
				}
			}
		}
		feldmalen();
	}
}

Ich muss ehrlich gesagt auch sagen, dass mich das weightx usw. etwas verwirrt.
Die Eigenschaften die ich, ich entnehme das mal einem anderen Projekt zumeist für GridBagLayout benütze sind diese:

public GridBagFelder(int x, int y, int width, int height, int weightX, int weightY) {
		this.fill = GridBagConstraints.BOTH;
	    this.gridx = x;
	    this.gridy = y;
	    this.gridwidth = width;
	    this.gridheight = height;
	    this.weightx = weightX;
	    this.weighty = weightY;
	}

Manchmal frage ich mich aber doch, was die letzten beiden bedeuten. Die ersten Fünf hab ich verstanden.


Gruß
Lukas

 

[X5-599]

Wie gesagt, es hat anscheinend mit der Größenberechnung zu tun. Am besten zu sehen, wenn man gbc.fill = GridBagConstraints.BOTH hat. (evtl gehts auch nur mit HORIZONTAL wenn man irgendwie die Höhe festgelegt hat... keine Ahnung). Ich sehe zumindest gewisse Konsistenz bei gbc.fill = GridBagConstraints.BOTH und Komponenten ungewisser Grösse (zB JLabels ohne Text). Der double für weightx/y kommt bei meinen Versuchen einer Prozentangabe gleich. 0.3 == 30%.

Folgender Code führt zu sowas:

gbc = new GridBagConstraints();
gbc.gridx = 0;
gbc.gridy = 0;
gbc.weightx = 0.2;
gbc.weighty = 0.3;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.BLUE);
panel.add(label, gbc);

gbc = new GridBagConstraints();
gbc.gridx = 1;
gbc.gridy = 0;
gbc.weightx = 0.5;
gbc.weighty = 0.3;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.GREEN);
panel.add(label, gbc);

gbc = new GridBagConstraints();
gbc.gridx = 2;
gbc.gridy = 0;
gbc.weightx = 0.3;
gbc.weighty = 0.3;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.BLUE);
panel.add(label, gbc);

gbc = new GridBagConstraints();
gbc.gridx = 0;
gbc.gridy = 1;
gbc.weightx = 0.2;
gbc.weighty = 0.2;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.GREEN);
panel.add(label, gbc);

gbc = new GridBagConstraints();
gbc.gridx = 1;
gbc.gridy = 1;
gbc.weightx = 0.5;
gbc.weighty = 0.2;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.BLUE);
panel.add(label, gbc);

gbc = new GridBagConstraints();
gbc.gridx = 2;
gbc.gridy = 1;
gbc.weightx = 0.3;
gbc.weighty = 0.2;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.GREEN);
panel.add(label, gbc);

gbc = new GridBagConstraints();
gbc.gridx = 0;
gbc.gridy = 2;
gbc.weightx = 0.2;
gbc.weighty = 0.5;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.BLUE);
panel.add(label, gbc);

gbc = new GridBagConstraints();
gbc.gridx = 1;
gbc.gridy = 2;
gbc.weightx = 0.5;
gbc.weighty = 0.5;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.GREEN);
panel.add(label, gbc);

gbc = new GridBagConstraints();
gbc.gridx = 2;
gbc.gridy = 2;
gbc.weightx = 0.3;
gbc.weighty = 0.5;
gbc.fill = GridBagConstraints.BOTH;
label = new JLabel();
label.setOpaque(true);
label.setBackground(Color.BLUE);
panel.add(label, gbc);

Du siehst die weight Angaben entsprechen ungefähr der Prozentualen Verteilung der Grössen. Auch interessant ist, dass das Grid sich immer nach dem Grössten "Bag" richtet. Will heißen, Das Panel in der Mitte bei x=1, y=1 (Blau) bräuchte selber keine weights definieren, weil bereits die höhe(weighty) vom "Bag" links daneben festgelegt wurde und die Breite (weightx) vom "Bag" darüber. Kleinere Werte würden also ignoriert. Grössere würden auch die Höhe und Breite der anderen "Bags" in der Zeile bzw Spalte ändern.
Das alles hab ich mir durch rumprobieren zusammengereimt. Meistens macht es Sinn. Trotzdem treffe ich hin und wieder auf Situationen, die mich stutzig machen...

Ich hab auch mal was zu anchors und insets geschrieben. Hier

Da benutze ich zum Beispiel keine weights. Ich erkläre das damit, dass sich die Größe eines "Bags" nach der Größe der Komponente richtet. Wieder: Die größte Komponente bestimmt die Höhe/Breite einer ganzen Zeile/Spalte.

Anchors kannst du auch hier einsetzen. Wie gesagt, wenn du bei x=1, y=1 die weights und das fill löschst, dann siehst du erstmal kein blaues Label mehr. Da es nicht mehr weiss, dass es sich über den vorhandenen Platz der "Bag" strecken soll. Wenn du dem Label einen Text mitgibst, erscheint es. Und zwar siehst du an der Blaufärbung, dass das Label nur so lang und hoch ist wie der Text, den es darstellen soll. Das Label wird in der Mitte des "Bags" positioniert (standard).
Um diese Position zu ändern kann mann die anchors nutzen.
gbc.anchor = GridBagConstraints.EAST setzt das Label an den rechten Rand der "Bag". Verändert aber die Grösse nicht.

Der zu ändernde Code wäre also:

gbc = new GridBagConstraints();
gbc.gridx = 1;
gbc.gridy = 1;
//gbc.weightx = 0.5;
//gbc.weighty = 0.2;
//gbc.fill = GridBagConstraints.BOTH;
label = new JLabel("Test");
gbc.anchor = GridBagConstraints.EAST;
label.setOpaque(true);
label.setBackground(Color.BLUE);
panel.add(label, gbc);

Ergebnis:


Du siehst also das Thema LayoutManager und gerade auch GridBagLayout ist schon sehr komplex. Und darum möchte ich nocheinmal darauf hinweisen: Ich sage nicht, dass das was ich hier geschrieben habe zu 100% korrekt ist. Ich sage nur, dass wenn ich mal wieder ein GridBagLayout bauen muss, ich mich auf diese Erkenntnisse stütze um auf die gewünschten Ergebnisse zu kommen. Ganz und gar verstanden habe ich es nämlich auch nicht. Denn es gibt Tage an denen will einfach gar nichts klappen.

 

[FranzFerdinand]

Hallöle,

vielen Dank für Deine Antwort. Entschuldige meine längere Abstinenz, habe mir eine kleine Javaauszeit verschafft.

Ich habe das ganze nun verstanden und korrekt anwenden können, vielen Dank für die Erklärung!

Ich habe aber noch ein kleines Problemchen, wobei ich nicht ganz weiterkomme.

Mein Spiel sieht nun so aus, wie auf dem Bild:


Der Aufbau des Designs läuft folgendermaßen ab:

spielframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        spielframe.setPreferredSize(new Dimension(1400,800));
        spielframe.setMinimumSize(new Dimension(1050,600));
        spielframe.setResizable(true);
        spielframe.setIconImage(Toolkit.getDefaultToolkit().getImage(new URL(BaseURL.getJarBase(Spielfeld.class), "./favicon.png")));
        spielframe.setVisible(false);
        
        Container contentPane = spielframe.getContentPane();
        contentPane.setLayout(new GridBagLayout());

        spielframe.add(new Barkartenecke(), new GridBagFelder(0, 0, 1, 1, 0.15, 0.5));
        spielframe.add(new Uebersichtsecke(), new GridBagFelder(0, 1, 1, 1, 0.15, 0.5));
        spielframe.add(new Spielfeld(), new GridBagFelder(1, 0, 1, 2, 0.7, 1.0));
        spielframe.add(new Spielkartenecke(), new GridBagFelder(2, 0, 1, 1, 0.15, 0.5));
        spielframe.add(new Bildecke(), new GridBagFelder(2, 1, 1, 1, 0.15, 0.5));
        
        spielframe.pack();
        spielframe.setLocationRelativeTo(null);

Wie ihr seht, sind es insgesamt fünf Spielelemente. Die 6 Parameter da hab ich passenderweise in die Klasse GridBagFelder ausgelagert, damit das nicht so chaotisch ist.

import java.awt.GridBagConstraints;

public class GridBagFelder extends GridBagConstraints {
	
	protected GridBagFelder(int x, int y, int width, int height, double weightX, double weightY) {
		this.fill = GridBagConstraints.BOTH;
	    this.gridx = x;
	    this.gridy = y;
	    this.gridwidth = width;
	    this.gridheight = height;
	    this.weightx = weightX;
	    this.weighty = weightY;
	}
}

Ich hoffe man kann in etwa erkennen, wie ich das aufgebaut habe. Oben Links ist die "Barkartenecke", unten Links die "Uebersichtsecke", in der Mitte das große Spielfeld, Oben Rechts die "Spielkartenecke" und unten Rechts einfach ein Bild auf einem JPanel.

Wie man sieht, sind alle Unterelemente in GridLayouts aufgeteilt, wie beispielsweise oben Links 7 mal 3. Sind bis auf zwei Ausnahmen alles JPanel.

Ein JLabel ist dort, wo es wie in meinem Anfangsthema sein sollte. Im Mittelpunkt. Da war ein 11 mal 11 GridLayout. Nun sind es 10 mal 11 und unten die komplette Reihe ist ein JPanel für Meldungen, wo im Spiel ungültige Spielzüge und sowas angezeigt werden.

Und da beginnt das Problem. Immer wenn ich den JLabeltext mit "JLabel.setText("Dings")" verändere, dann verschiebt sich das Layout komplett. Das JLabel wird dann gigantisch breit, sodass das Spielfeld statt der eingetragenen 0.7 auch mal 90% einnimmt.

Das ist das, was mich stört.

Ist es möglich die Veränderung der Größe auf diese Art vollständig zu unterbinden?
Immer wenn sich der Text ändert, springt das ganze Layout um.

Der Quelltext für das Spielfeld in der Mitte sieht so aus:

public class Spielfeld extends JPanel {
private Spielzelle spielfeldzelle[][] = new Spielzelle[11][11];
	private static JLabel meldungsbox = new JLabel();
protected Spielfeld() {
		setLayout(new GridBagLayout());
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.weightx = 1.0;
		gbc.weighty = 1.0;
		gbc.fill = GridBagConstraints.BOTH;
		
		for(int y=0;y<11;y++) {
			for(int x=0;x<11;x++) {
				gbc.gridx = x;
				gbc.gridy = y;

				if(y<10) {
					spielfeldzelle[x][y] = new Spielzelle(Spielzelle.Typ.Leer);
					spielfeldzelle[x][y].setBackground(new Color(0,255,255));
					spielfeldzelle[x][y].setOpaque(true);
					add(spielfeldzelle[x][y], gbc);
				} else if(y==10) {
					gbc.gridwidth = 11;
					meldungsbox.setBackground(new Color(0,255,255));
					meldungsbox.setOpaque(true);
					meldungsbox.setHorizontalAlignment(SwingConstants.CENTER);
					add(meldungsbox, gbc);
					break;
				}
			}
		}
	}
}

Kann mir jemand erklären, wie ich das verhindern kann?

Das wäre ganz toll. Vielen Lieben Dank und schönen Samstagabend.

Gruß
Lukas

 

[X5-599]

Bin ich erhlich gesagt überfragt. Hast du mal versucht die Grösse des Label mit setPreferredSize, setMaximuxSize zu beeinflussen?