LayoutManager Einige Fragen zum GridBagLayout

[Mahok]

Hallo zusammen,

ich bin gerade dabei, JAVA zu lernen und bin gerade bei den Layoutmanagern angekommen.
Am meisten interessiert mich davon der GridBagLayoutmanager, aber irgendwie scheint das
auch derjenige zu sein, der am kompliziertesten ist.
Ausserdem wird in den meisten Büchern und bei den meisten Seiten im Netz der GridBagLayoutmanager nur schlecht erklärt und deshalb beleiben bei mir einige Fragen offen.

Falls mir hier jemand weiterhelfen könnte würde ich mich sehr freuen.

Also erstmal:
Muss eine Zeile voll ausgefüllt werden?
Oder kann ich einfach einen Button o.ä. mitten in der Zeile plazieren ohne dass davor etwas anderes ist?

Wenn ein Button über mehrere Zeilen gehen soll, muss sich in einer seiner Zeilen noch ein andere Button o.ä. befinden, damit er auch wirklich mehrere Zeilen einnimmt?

Diese Frage stelle ich, weil ich ein Programm geschrieben habe, das 5 Buttons darstellt, die unterschiedlich groß sein sollen, aber auf mehrere Zeilen verteilt sind. Die buttons werden aber alle gleich groß dargestellt. Ich habe kein preferredSize verwendet, weil ich dacht, dass wenn ein Button über eine Zeile geht und ein anderer über 2 Zeilen müsste er doch eigentlich doppelt so groß sein.

Ich muss auch gestehen, dass ich mit dem Aufbau des GridBag nicht so ganz klar komme. Ich poste hier mal meinen Code, evtl. hab ich ja einen gravierenden Fehler übersehen. Wie gesagt, die Buttons werden dargestellt, aber alle sind gleich groß und gehen nur über eine Zeile.

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


class testGUI extends JFrame
{
	private JButton B1;
	private JButton B2;
	private JButton B3;
	private JButton B4;
	private JButton B5;
	
	public testGUI() 
	{	
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		Container cont = getContentPane();
		GridBagLayout gbl = new GridBagLayout();
		cont.setLayout(gbl);
		GridBagConstraints gbc = new GridBagConstraints();
		
		gbc.fill = GridBagConstraints.NONE;
		gbc.weightx = 0.0;
		gbc.weighty = 0.0;
		
		B1 = new JButton("1");
		B1.setBackground(Color.black);
		gbc.gridx = 1; 						//x grid position
		gbc.gridy = 0; 						//y grid position
		gbc.gridwidth = 4;
		gbc.gridheight = 2;
		gbl.setConstraints(B1, gbc);		//associate the label with a constraint object
		cont.add(B1); 						//add it to content pane
		
		B2 = new JButton("2");
		B2.setBackground(Color.white);
		gbc.gridx = 0; 						//x grid position
		gbc.gridy = 2; 						//y grid position
		gbc.gridwidth = 3;
		gbc.gridheight = 1;
		gbl.setConstraints(B2, gbc); 		//associate the label with a constraint object
		cont.add(B2); 						//add it to content pane
		
		B3 = new JButton("3");
		B3.setBackground(Color.white);
		gbc.gridx = 4; 						//x grid position
		gbc.gridy = 2; 						//y grid position
		gbc.gridwidth = 3;
		gbc.gridheight = 2;
		gbl.setConstraints(B3, gbc); 		//associate the label with a constraint object
		cont.add(B3); 						//add it to content pane
		
		B4 = new JButton("4");
		B4.setBackground(Color.green);
		gbc.gridx = 2; 						//x grid position
		gbc.gridy = 4; 						//y grid position
		gbc.gridwidth = 5;
		gbc.gridheight = 5;
		gbl.setConstraints(B4, gbc); 		//associate the label with a constraint object
		cont.add(B4); 						//add it to content pane
		
		B5 = new JButton("5");
		B5.setBackground(Color.white);
		gbc.gridx = 2; 						//x grid position
		gbc.gridy = 9; 						//y grid position
		gbc.gridwidth = 5;
		gbc.gridheight = 3;
		gbl.setConstraints(B5, gbc); 		//associate the label with a constraint object
		cont.add(B5); 						//add it to content pane
	}
}

public class Gridder3b
{
	public static void main ( String[] args )
	{

		testGUI tester = new testGUI();
		
		tester.setTitle("VIEWER");
		tester.setSize(200, 200);
		//tester.pack();
        tester.setVisible(true);
		//tester.setResizable(false);
		
	}
}

 

[KrokoDiehl]

Hallo.

Zuerst einmal zu deinem Programm: So wie du die Komponenten hinzufügst, wird er nichts mit den GBContraints zutun haben? Diese setzt du direkt beim Hinzufügen in den Container, zumindest denke ich, dass er sie so richtig findet:

this.setLayout(new GridBagLayout());

GridBagContraints gbc = ...;

this.add(myComponent, gbc); // <-- so!

Vielleicht siehst du damit bereits eine Änderung in deiner Oberfläche.


Ansonsten muss weder eine Zeile, noch eine Spalte im GBL voll gefüllt sein. Das GBL richtet die Größen der Zelle stark nach den preferred sizes der Komponenten aus und diese werden in aller Regel automatisch errechnet, sofern man keine eigenen setzt. Aber das sollte nicht das Thema sein. In aller Regel muss man mit den pref.sizes nicht rummachen, und mit dem GBL anständig arbeiten zu können.
Dies bedeutet aber auch, dass die Komponente vorgibt wie groß die Zellen im GBL sind. So wie ich dein Layout auf den ersten Blick vermute, gibt es auf der Höhe von Button "1" keine weitere Komponente, die dessen Höhe beeinflussen kann. D.h. für Zeilen 0 und 1 bestimmt allein jener Button die Zeilenhöhe.
Ich habe irgendwann irgendwo mal ein Testprogramm gefunden, dass einem die Zellen vom GBL gemalt hat, da konnte man sowas gut sehen ... finde es leider nicht mehr :I

Relevanter sind hier die Angaben der GBC. Z.B. sollte die Summe aller weightx nicht 1.0 überschreiten. Analog gilt es für weighty in einer Spalte.
Die Angaben fill und anchor spielen auch oft eine Rolle beim erstellen des Layouts und natürlich darf es nicht sein, dass sich Komponenten in einer Zelle überschneiden, daher hilft oft ein Blatt Papier und ein Stift nebendran

 

[Mahok]

Also erstmal Danke für deine Antwort.
Ich hab jetz mal ein bißchen was geändert, und zwar folgendermaßen:

public testGUI() 
	{

		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		Container cont = getContentPane();
		
		this.setLayout(new GridBagLayout());
		
		/* ALT
		GridBagLayout gbl = new GridBagLayout();
		cont.setLayout(gbl);
		*/
		
		GridBagConstraints gbc = new GridBagConstraints();
		
		gbc.fill = GridBagConstraints.NONE;
		gbc.weightx = 0.0;
		gbc.weighty = 0.0;
		
		B1 = new JButton("1");
		B1.setBackground(Color.black);
		gbc.gridx = 1; 						//x grid position
		gbc.gridy = 0; 						//y grid position
		gbc.gridwidth = 4;
		gbc.gridheight = 2;
		//gbl.setConstraints(B1, gbc);		//associate the label with a constraint object
		//cont.add(B1); 						//add it to content pane
		this.add(B1, gbc);

hattest du das so gemeint?
auf was genau bezog dich deine 3. zeile?

darauf:
GridBagConstraints gbc = new GridBagConstraints();
?

Das Ergebnis ist momentan immernoch das gleiche.
Die Buttons sind immernoch gleich groß.

Vorallem hab ich das jetzt mehrmals probiert, auf leicht verschiedene Arten (weil wie gesagt überall steht es ein wenig anders)m aber ich bekam immer das gleiche Ergebniss.

Noch ein kleiner Nachtrag:

setze ich mit setPreferredSize die Größe eines Buttons, so funktioniert das auch. Sobald ich aber bei einem weiteren oder allen setPreferredSize setzte, werden wieder alle Buttons gleich groß. Auch wenn ich unterschiedliche Größen verwende. So sieht das bei mir im Code aus:

B4 = new JButton("4");
		B4.setBackground(Color.green);
		B4.setPreferredSize(new Dimension(600,300));
		gbc.gridx = 2; 						//x grid position
		gbc.gridy = 4; 						//y grid position
		gbc.gridwidth = 5;
		gbc.gridheight = 5;
		//gbl.setConstraints(B4, gbc); 		//associate the label with a constraint object
		//cont.add(B4); 						//add it to content pane
		this.add(B4, gbc);

 

[L-ectron-X]

Kannst du mal eine Abbildung/Grafik/Screenshot zeigen, wie es aussehen soll? Dann kann man mal ein Beispiel schreiben.

 

[Mahok]

Das Aussehen ist nicht ganz so wichtig. Es geht mir ja mehr um das Verständins.

Ich beschreib mal kurz, wie ich es mir ungefähr vorgestellt hatte, später kann ich noch ne kleine skizze dazu machen, falls die dann noch benötigt wird.

Also:

Ich hätte gerne 5 Knöpfe

Knopf 1 soll in Zeile 0, aber nicht ganz am (linken) Rand sein und 4 Einheiten lang und 2 Einheiten hoch.
Knopf 2 soll in Zeile 2 sein, ganz am linken Rand, 3 Einheiten lang und 1 Einheit hoch.
Knopf 3 soll in Zeile 2 an Knopf 2 anschließen, aber 2 einheiten hoch sein.
Knopf 4 soll in Zeile 4 an Stelle 2 beginnen und 5 Zeilen hoch und 5 Einhgeiten lang sein
Knopf 5 soll in Zeile 9 an Stelle 2 beginnen und 3 Zeilen hoch und 5 Zeilen lang sein.

Zusammenfassung:
Knopf PosX/PosY Breite/Höhe
1 1/0 4/2
2 0/2 3/1
3 3/2 3/2
4 2/4 5/5
5 2/9 5/3

Wie gesagt, ich hab mir die Werte einfach so mal überlegt ohne was spezielles im Sinn zu haben.
Wichtig war mir eben, dass nicht alle Zeilen voll ausgefüllt sind (alle Beispiele die ich gefunden hab waren so aufgebaut, dass die Zeilen immer komplett gefüllt wurden).
Außerdem war es mir wichtig, dass der Frame mit dem GridBagLayout in einer Klasse Platz findet, wegen der Übersicht und damit ich wirklich nachvollziehen kann, wie der LayOutManager funktioniert.
Und Main sollte eine eigene Klasse sein, also nicht im Frame integriert.

Das waren die anforderungen die ich an mich selbst gestellt hatte, aber wie gesagt, es funktioniert nicht richtig, die Knöpfe sind alle gleich groß.

 

[L-ectron-X]

Nach deiner Beschreibung kann keine GUI mit GridBagLayout erstellt werden, weil für jede Zelle auch Elemente definiert sein müssen. Leere Zellen werden ignoriert.

Wenn sich ein Element über 5 Zellen erstrecken soll, müssen in deinem Layout andere 5 Zellen des Gitters Elemente haben. Hast du aber in deinem Layout nicht.
Das heißt, es wird nicht so aussehen wie gewünscht. Was aber nicht heißt, dass man die GUI die du im Kopf hast, nicht mit GridBagLayout schreiben kann.
Sie muss nur anders formuliert werden.

Das was du formuliert hast, würde so ungefähr aussehen:

Mach mal ne Skizze, dann kann man den Code dazu schreiben.

 

[Mahok]

Ungefähr so wie in der Skizze hatte ich es mir vorgestellt (den 5 Knopf hab ich jetzt wegelassen, der ist nicht wichtig).

Wenn sich ein Element über 5 Zellen erstrecken soll, müssen in deinem Layout andere 5 Zellen des Gitters Elemente haben. Hast du aber in deinem Layout nicht.

Das hat mir schonmal sehr viel geholfen. Wie gesagt, das war so eine der Fragen die ich hatte, die aber in keinem Buch oder Tutorial angesprochen wurde.

Kann man sich in so einem Fall mit 'unsichtbaren' Komponenten helfen?

Vielen Dank jedenfalls schonmal für deine Hilfe.

 

[L-ectron-X]

Kann man sich in so einem Fall mit 'unsichtbaren' Komponenten helfen?

Ja, entweder so, und/oder den Komponenten mit setPreferredSize() die gewünschte Größe vorgeben.
Ein dafür besser geeigneter LayoutManager wäre das TableLayout.

 

[Mahok]

Wie gesagt geht es mir ja primär gar nicht um das Layout selbst sondern darum, den Layoutmanager zu verstehen.

Das TableLayout werd ich mir als nächstes ansehen, das interessiert mich nämlich auch brennend.

Und was SetPreferredSize anbelangt:
Das hab ich ja versucht und es hat auch funktioniert, wenn ich das nur bei einer Komponente gemacht hab. Sobald ich das bei 2 oder mehr angegeben hab sahs wieder aus wie davor.

Nochmal ein Nachtrag:

Ich hab jetzt das ganze Programm gekürzt und nur einen Button verwendet, den ich über die ganze Zeile gehen lassen wollte. Dafür habe ich setPreferredSize verwendet.
Hab das Programm ausgeführt und es war wieder nur ein winziger Button.

Dann habe ich in main die Zeile

//tester.pack();
in
tester.pack();

umgeändert mit dem Ergebnis, dass der Button jetzt die richtige Größe hatte, aber scheinbar
tester.setSize(800, 600);
ignoriert wurde. Ich beziehe mich auf meinen ersten Post und den dort angegebenen Code.

Deshalb meine Fragen:
Brauche ich pack() für den GridBagManager?
Ich habe einige Beispiele ohne Pack gesehen, deswegen wundert es mich ein wenig.

Wenn ich pack() verwendet wird dann mein setSize für das Hauptframe ignoriert?
Wäre nicht so schlimm, damit könnte ich leben.

 

[Mahok]

So, ich hab's geschafft!

Danke erstmal für die Hilfe bisher. Ganz fertig bin ich nämlich noch nicht, zumindest mit meinen Fragen.

Erstmal möchte ich kurz beschreiben, was ich gemacht hab. Evtl. ist das nämlich nicht die Ideallösung (und davon geh ich mal aus). Ausserdem hab ich immer noch ein paar Fragen, die kommen dann am Ende.

Erstmal mein Lösungsansatz

Ich habe eine Zeile erstellt, die Komponenten erhält, die 1 Pixel hoch sind.
Die Länge der Komponenten hab ich so gewählt, dass sie immer eine dort beginnt, wo später auch in einer anderen Zeile eine Komponente auf der x-Achse platziert werden soll. Ich kann nun also nicht noch eine Komponente irgendwo auf der x-Achse platzieren, dazu müsste ich erst die entsprechende Zeile ändern.

Wenn ich nun diese Zeile entferne, rutschen alle Komponenten die sich in der Mitte einer Zeile befinden an den linken Rand. Aber diese Zeile wird einfach nicht entfernt.

Wie gesagt, ideal erscheint mir dieser Ansatz nicht, aber ich weiß nicht, wie ich ansonsten eine Komponente mitten in einer Zeile platzieren könnte.

Jetzt aber noch eine Frage:
Alle meine Komponenten befinden sich in einem JFrame. In diesem hab ich eben ein GridBagLayout.
Einige meiner Komponenten befinden sich ja mitten in einer Zeile. Links und rechts davon ist die Hintergrundfarbe hellgrau.
Mit setBackground kann ich dies leider nicht ändern. Gibt es da eine Möglichkeit?

 

[L-ectron-X]

Ohne Füll-Komponenten wirst du das Layout wahrscheinlich nicht hinbekommen.
Sobald es leere Zellen im Gitter gibt, werden die Anweisungen für die Anordnung nicht korrekt umgesetzt werden.

Brauche ich pack() für den GridBagManager?

Nein, das ist nicht zwingend.

Wenn ich pack() verwendet wird dann mein setSize für das Hauptframe ignoriert?

Ja, das ist richtig. Die Komponenten werden dann entsprechend ihrer PreferredSize angeordnet und das Fenster auf die minimale Größe, die dadurch zu Stande kommt, gebracht.
Bei setSize() werden die Komponenten entsprechend ihrer GridBagConstraints so im Fenster verteilt, dass sie den durch setSize() gesetzten gesamten Raum füllen, bzw. entsprechend aufteilen.

Alle meine Komponenten befinden sich in einem JFrame. In diesem hab ich eben ein GridBagLayout.
[...]
Mit setBackground kann ich dies leider nicht ändern. Gibt es da eine Möglichkeit?

Das geht nur direkt auf dem Container, der im JFrame liegt:

getContentPane().setBackground(Color.WHITE);

 

[Mahok]

So, immer wenn ich denke ich hab alles verstanden kommt wieder ein Teil, den ich nicht verstehe.

Wie gesagt hab ich das eigentliche Prblem gelöst, mein Layout sieht so aus wie ich gerne hätte. Jetzt wollte ich einen Schritt weiter gehen und innerhalb eines JPanels ein GridBagLyout anlegen.

Dazu habe ich einen der Knöpfe durch ein JPanel ersetzt und wollte darin wiederum andere Panels und Label mit einem GridBagLayout anordnen.

Allerdings habe ich da schon zu beginn Probleme, denn

    Container cont = getContentPane();

funktioniert in einem JPanel nicht.

Was muss ich denn beachten, wenn ich ein GridBagLayout in einem JPanel nutzen möchte?

 

[L-ectron-X]

Nichts. Einfach mit den GridBagConstraints das Layout für die jeweilige Komponente einstellen und dem Panel hinzufügen. (add())
Das JPanel selbst ist bereits ein Container, dem du weitere Komponenten hinzufügen kannst.
Ein JFrame ist auch ein Container, nur dass dieser einen weiteren Container enthält, den du mit getContentPane() zurück geben kannst.

 

[Mahok]

Irgendwie dreh ich mich im Kreis.
Sorry für die tausend Fragen die ich hab.

Im Prinzip ist es jetzt fast wieder das gleiche Problem wie zu Beginn.
Meine Komponente innerhalb des Panels sind zu klein.

Und pack() kann ich innerhalb des Panels nicht verwenden.

So, hier mal der Code.

Es geht eigentlich hauptsächlich um die Zeile 5 bis 117.
Das ist ein JPanel, welches Teil eines GridBags in einem Frame ist.
Drum herum sind ein paar Buttons. Die werden korrekt im Frame dargestellt,
das Panel wird im Frame auch korrekt dargestellt, nur die Buttons IM Panel sehen halt nicht richtig aus.

Beim Frame verwende ich pack(), dadurch erhalten die Komponenten eben die preferredSize, aber das geht ja eben im Panel nicht.

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

class ButtonPanel extends JPanel
{
	private JPanel Zeile1;
	private JPanel Zeile2;
	private JPanel Zeile3;
	private JPanel Zeile4;
	private JPanel Zeile5;

	private JButton BB1;
	private JButton BB2;
	private JButton BB3;
	
	private JPanel PanelL1;

	public ButtonPanel()
	{
		/*
		**		Die Maße sind 
		**			600x200
		**
		**		Imaginäres Raster
		**		hat die Maße
		**			1 zu 10
		**		(1 Feld entspr. 10 Pixel)
		*/
		
		GridBagConstraints contBP = new GridBagConstraints();

		this.setLayout(new GridBagLayout());
		GridBagConstraints gbcBP = new GridBagConstraints();
		
		gbcBP.fill = GridBagConstraints.NONE;
		gbcBP.anchor = GridBagConstraints.CENTER;
		gbcBP.weightx = 0.0;
		gbcBP.weighty = 0.0;
		gbcBP.ipadx = 0;
		gbcBP.ipady = 0;
		gbcBP.insets = new Insets( 1, 1, 1, 1);
	
		Zeile1 = new JPanel();
		Zeile1.setBackground(Color.white);
		Zeile1.setPreferredSize(new Dimension(120,10));
		gbcBP.gridx = 0; 						//x grid position
		gbcBP.gridy = 0; 						//y grid position
		gbcBP.gridwidth = 12;
		gbcBP.gridheight = 1;
		this.add(Zeile1, gbcBP);

		Zeile2 = new JPanel();
		Zeile2.setBackground(Color.white);
		Zeile2.setPreferredSize(new Dimension(120,10));
		gbcBP.gridx = 12; 						//x grid position
		gbcBP.gridy = 0; 						//y grid position
		gbcBP.gridwidth = 12;
		gbcBP.gridheight = 1;
		this.add(Zeile2, gbcBP);

		Zeile3 = new JPanel();
		Zeile3.setBackground(Color.white);
		Zeile3.setPreferredSize(new Dimension(120,10));
		gbcBP.gridx = 24; 						//x grid position
		gbcBP.gridy = 0; 						//y grid position
		gbcBP.gridwidth = 12;
		gbcBP.gridheight = 1;
		this.add(Zeile3, gbcBP);

		Zeile4 = new JPanel();
		Zeile4.setBackground(Color.white);
		Zeile4.setPreferredSize(new Dimension(120,10));
		gbcBP.gridx = 36; 						//x grid position
		gbcBP.gridy = 0; 						//y grid position
		gbcBP.gridwidth = 12;
		gbcBP.gridheight = 1;
		this.add(Zeile4, gbcBP);

		Zeile5 = new JPanel();
		Zeile5.setBackground(Color.white);
		Zeile5.setPreferredSize(new Dimension(120,10));
		gbcBP.gridx = 48; 						//x grid position
		gbcBP.gridy = 0; 						//y grid position
		gbcBP.gridwidth = 12;
		gbcBP.gridheight = 1;
		this.add(Zeile5, gbcBP);
		
		BB1 = new JButton();
		BB1.setBackground(Color.white);
		BB1.setPreferredSize(new Dimension(120,100));
		gbcBP.gridx = 0; 						//x grid position
		gbcBP.gridy = 10; 						//y grid position
		gbcBP.gridwidth = 12;
		gbcBP.gridheight = 10;
		this.add(BB1, gbcBP);
		
		BB2 = new JButton();
		BB2.setBackground(Color.white);
		BB2.setPreferredSize(new Dimension(120,100));
		gbcBP.gridx = 12; 						//x grid position
		gbcBP.gridy = 10; 						//y grid position
		gbcBP.gridwidth = 12;
		gbcBP.gridheight = 10;
		this.add(BB2, gbcBP);
		
		PanelL1 = new JPanel();
		PanelL1.setBackground(Color.white);
		PanelL1.setPreferredSize(new Dimension(360,200));
		gbcBP.gridx = 12; 						//x grid position
		gbcBP.gridy = 20; 						//y grid position
		gbcBP.gridwidth = 36;
		gbcBP.gridheight = 20;
		this.add(PanelL1, gbcBP);

	}
}

class GUIFrame extends JFrame
{
	private JPanel LeisteOben1;
	private JPanel LeisteOben2;
	private JPanel LeisteOben3;
	private JPanel LeisteOben4;
	private JPanel LeisteOben5;
	private JButton B1;
	private JButton B2;
	private JButton B3;
	private ButtonPanel bp1;

	public GUIFrame() 
	{
		/*	
		**		Imaginäres Raster
		**		hat die Maße
		**			1 zu 25
		**		(1 Feld entspr. 25 Pixel)
		*/
		
		Container cont = getContentPane();
		getContentPane().setBackground(Color.WHITE);
		
		this.setLayout(new GridBagLayout());
		GridBagConstraints gbc = new GridBagConstraints();
		
		gbc.fill = GridBagConstraints.NONE;
		gbc.anchor = GridBagConstraints.CENTER;
		gbc.weightx = 0.0;
		gbc.weighty = 0.0;
		gbc.ipadx = 0;
		gbc.ipady = 0;
		gbc.insets = new Insets( 1, 1, 1, 1);
		
		LeisteOben1 = new JPanel();
		LeisteOben1.setBackground(Color.gray);
		LeisteOben1.setPreferredSize(new Dimension(100,25));
		gbc.gridx = 0; 					//x grid position
		gbc.gridy = 0; 					//y grid position
		gbc.gridwidth = 4;
		gbc.gridheight = 1;
		this.add(LeisteOben1, gbc);
		
		LeisteOben2 = new JPanel();
		LeisteOben2.setBackground(Color.gray);
		LeisteOben2.setPreferredSize(new Dimension(150,25));
		gbc.gridx = 4; 					//x grid position
		gbc.gridy = 0; 					//y grid position
		gbc.gridwidth = 6;
		gbc.gridheight = 1;
		this.add(LeisteOben2, gbc);
		
		LeisteOben3 = new JPanel();
		LeisteOben3.setBackground(Color.gray);
		LeisteOben3.setPreferredSize(new Dimension(300,25));
		gbc.gridx = 10; 				//x grid position
		gbc.gridy = 0; 					//y grid position
		gbc.gridwidth = 12;
		gbc.gridheight = 1;
		this.add(LeisteOben3, gbc);
		
		LeisteOben4 = new JPanel();
		LeisteOben4.setBackground(Color.gray);
		LeisteOben4.setPreferredSize(new Dimension(150,25));
		gbc.gridx = 22; 				//x grid position
		gbc.gridy = 0; 					//y grid position
		gbc.gridwidth = 6;
		gbc.gridheight = 1;
		this.add(LeisteOben4, gbc);
		
		LeisteOben5 = new JPanel();
		LeisteOben5.setBackground(Color.gray);
		LeisteOben5.setPreferredSize(new Dimension(100,25));
		gbc.gridx = 28; 				//x grid position
		gbc.gridy = 0; 					//y grid position
		gbc.gridwidth = 4;
		gbc.gridheight = 1;
		this.add(LeisteOben5, gbc);
	
		B1 = new JButton("BUTTON 1");
		B1.setPreferredSize(new Dimension(300,200));
		gbc.gridx = 10; 				//x grid position
		gbc.gridy = 1; 					//y grid position
		gbc.gridwidth = 12;
		gbc.gridheight = 8;
		this.add(B1, gbc);
		
		B2 = new JButton("BUTTON 2");
		B2.setPreferredSize(new Dimension(700,100));
		gbc.gridx = 0; 					//x grid position
		gbc.gridy = 9; 					//y grid position
		gbc.gridwidth = 28;
		gbc.gridheight = 4;
		this.add(B2, gbc);
		
		B3 = new JButton("BUTTON 3");
		B3.setPreferredSize(new Dimension(100,300));
		gbc.gridx = 28; 				//x grid position
		gbc.gridy = 1; 					//y grid position
		gbc.gridwidth = 4;
		gbc.gridheight = 12;
		this.add(B3, gbc);
		
		bp1 = new ButtonPanel();
		bp1.setPreferredSize(new Dimension(600,200));
		gbc.gridx = 4; 					//x grid position
		gbc.gridy = 13; 				//y grid position
		gbc.gridwidth = 24;
		gbc.gridheight = 8;
		this.add(bp1, gbc);
	
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setTitle("GRID TESTER");
		this.pack();
		this.setVisible(true);
	}
}

public class GridTester
{
	public static void main ( String[] args )
	{
		GUIFrame GUI = new GUIFrame();
	}
	
}