# Einfache Frage zu GridLayout



## ernst (23. Mrz 2008)

Hallo allerseits,
Ich verstehe folgendes nicht:
Wenn ich folgendes GridLayout setze:
mycont.setLayout(myGL62);
also 6 Zeilen und zwei Spalten.
Und dann montiere ich zwei Panels in das Fenster:

mycont.add(myp1);
mycont.add(myp2);

dann wird myp2 nicht _neben_ myp1 in der ersten Zeile dargestellt,
sondern myp1 wird gar nicht dargestellt.
Aber beim GridLayout müsste doch zuerst die 1. Zeile komplett gefüllt, dann die 2.
Zeile komplett gefüllt werden, usw.

Warum ist das so ?

Hier das ganze Programm:
//----------------------------------------------------------

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

public class MainZeichnenUndButtons2 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
	}
}

class MyFenster extends JFrame{
	private Container mycont;
	private JButton myb1, myb2;
	private JTextField myt1, myt2;
	private JLabel myl1, myl2;
	private JPanel myp1, myp2;
	
	private GridLayout myGL62, myGL23;

	public MyFenster(){
		mycont = getContentPane();
		myb1=new JButton("Go");
		myb2=new JButton("Ok");
		myt1=new JTextField("hier eingeben",30);
		myt2=new JTextField("hier eingeben",30);
		myl1=new JLabel("Haarfarbe eingeben");
		myl2=new JLabel("Geschlecht");
		myp1 = new JPanel();
		myp2 = new JPanel();
		
		myGL62  = new GridLayout(6,2);
		myGL23  = new GridLayout(2,3);
		mycont.setLayout(myGL62);
		myp1.setLayout(myGL23);
		myp2.setLayout(myGL23);
		
		myp1.add(myl1);
		myp1.add(myt1);
		myp1.add(myb1);
		myp1.add(myl2);
		myp1.add(myt2);
		myp1.add(myb2);
		
		myp2.add(myl1);
		myp2.add(myt1);
		myp2.add(myb1);
		myp2.add(myl2);
		myp2.add(myt2);
		myp2.add(myb2);
		
		mycont.add(myp1);
		mycont.add(myp2);		
		setTitle("Meine Zeichnung");
		setLocation(30,60);
		setSize(600,400);
		setVisible(true);
	}
}
```
 
mfg
Ernst


----------



## Janus (23. Mrz 2008)

du verwendest dieselben objekte. intern werden diese irgendwann ganz unten in der layout schicht schlicht auf pixelkoordinaten gesetzt. und da es nunmal dieselben objekte sind, erscheinen deine widgets schlussendlich nicht an zwei stellen, sondern an einer.


----------



## André Uhres (23. Mrz 2008)

Eine Swing Komponente kann nur einen Parent haben, also nicht myp1 *und* myp2, sondern nur myp1 *oder* myp2.


----------



## Janus (23. Mrz 2008)

hm, bessere aussage


----------



## ernst (23. Mrz 2008)

>Eine Swing Komponente kann nur einen Parent haben, also nicht myp1 *und* myp2, 
>sondern nur myp1 *oder* myp2.[/quote]
>
Warum funktioniert dann folgendes Programm?


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

public class MainFenster4 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
	}
}

class MyFenster extends JFrame{
	private Container mycont;
	private JButton myb1, myb2;
	private JTextField myt1, myt2;
	private JLabel myl1, myl2;
	private JPanel myp1, myp2;
	private GridLayout myGL21;

	public MyFenster(){
		mycont = getContentPane();
		myb1=new JButton("Go");
		myb2=new JButton("Ok");
		myt1=new JTextField("hier eingeben",30);
		myt2=new JTextField("hier eingeben",30);
		myl1=new JLabel("Euro-->Dollar");
		myl2=new JLabel("Dollar-->Euro");
		myp1=new JPanel();
		myp2=new JPanel();
		myGL21=new GridLayout(2,1);
		mycont.setLayout(myGL21);
		myp1.add(myl1);
		myp1.add(myt1);
		myp1.add(myb1);
		myp2.add(myl2);
		myp2.add(myt2);
		myp2.add(myb2);
		mycont.add(myp1);
		mycont.add(myp2);
		setTitle("Meine Zeichnung");
		setLocation(30,60);
		setSize(600,400);
		setVisible(true);
	}
}
```



mfg
Ernst


----------



## André Uhres (23. Mrz 2008)

ernst hat gesagt.:
			
		

> ..Warum funktioniert dann folgendes Programm?..


In der ersten Version hast du 6 Komponenten in ein Panel gepackt und *dieselben* 6 Komponenten nochmal an ein anderes Panel. 
Die 6 können aber nur zu *einem* Panel gehören, deswegen wurden keine 12, sondern nur  6 angezeigt.

In der zweiten Version packst du 3 Komponenten in ein Panel und 3 *andere* Komponenten in ein anderes Panel. 
Da jetzt keine Komponente zwei Parents hat, funktioniert es wie gewollt.


----------



## ernst (24. Mrz 2008)

>In der zweiten Version packst du 3 Komponenten in ein Panel und 3 
>Komponenten in ein anderes Panel. 
>Da jetzt keine Komponente zwei Parents hat, 
>funktioniert es wie gewollt.[/quote]
>
Du hast recht. Ich habe das Programm deshalb abgeändert (siehe unten).
Aber eines ist mir noch unklar:

Wenn ich folgendes Layout setze:
mycont.setLayout(myGL62);
also 6 Zeilen und zwei Spalten.
Und dann montiere ich zwei Panels in das Fenster:
mycont.add(myp1);
mycont.add(myp2);
dann wird myp2 nicht _neben_ myp1 in der ersten Zeile dargestellt,
sondern _unter_ myp1 in der 2. Zeile.
Es wird also nicht zuerst die 1. Zeile komplett gefüllt, dann die 2.
Zeile, usw. wie es GridLayout eigentlich machen müsste.
Warum???



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

public class MainZeichnenUndButtons2 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
	}
}

class MyFenster extends JFrame{
	private Container mycont;
	private JButton myb1, myb2;
	private JButton myb3, myb4;	
	private JTextField myt1, myt2;
	private JTextField myt3, myt4;	
	private JLabel myl1, myl2;
	private JLabel myl3, myl4;	
	private JPanel myp1, myp2;
	
	private GridLayout myGL62, myGL23;

	public MyFenster(){
		mycont = getContentPane();
		myb1=new JButton("Go");
		myb2=new JButton("Ok");
		myt1=new JTextField("hier eingeben",30);
		myt2=new JTextField("hier eingeben",30);
		myl1=new JLabel("Haarfarbe eingeben");
		myl2=new JLabel("Geschlecht");
		
		myb3=new JButton("Go");
		myb4=new JButton("Ok");
		myt3=new JTextField("hier eingeben",30);
		myt4=new JTextField("hier eingeben",30);
		myl3=new JLabel("Haarfarbe eingeben");
		myl4=new JLabel("Geschlecht");
		
		myp1 = new JPanel();
		myp2 = new JPanel();
		
		myGL62  = new GridLayout(6,2);
		myGL23  = new GridLayout(2,3);
		mycont.setLayout(myGL62);
		myp1.setLayout(myGL23);
		myp2.setLayout(myGL23);
		
		myp1.add(myl1);
		myp1.add(myt1);
		myp1.add(myb1);
		myp1.add(myl2);
		myp1.add(myt2);
		myp1.add(myb2);
		
		myp2.add(myl3);
		myp2.add(myt4);
		myp2.add(myb3);
		myp2.add(myl4);
		myp2.add(myt3);
		myp2.add(myb4);
		
		mycont.add(myp1);
		mycont.add(myp2);		
		setTitle("Meine Zeichnung");
		setLocation(30,60);
		setSize(600,400);
		setVisible(true);
	}

}
```


mfg
Ernst


----------



## SlaterB (24. Mrz 2008)

erstaunlich aber scheint so zu sein,
wenn die anderen Felder nicht gefüllt werden dann wird das Layout mal selber aktiv und gruppiert fröhlich um 

mit
 mycont.add(new JLabel("")); 
	      mycont.add(new JLabel("")); 
	      mycont.add(new JLabel(""));  
	      mycont.add(new JLabel("")); 
	      mycont.add(new JLabel(""));  
	      mycont.add(new JLabel("")); 
	      mycont.add(new JLabel(""));  
	      mycont.add(new JLabel(""));   
wirds besser, gibt vielleicht auch vorgefertigte Platzhalter,

das Tutorial
http://java.sun.com/docs/books/tutorial/uiswing/layout/grid.html
verwendet 
new GridLayout(0,2); 

damit gehts auch, dann wird allerdings die ganze Fläche ausgefüllt

-------

allgemein rate ich dir dringend, pro JPanel ein eigenes Layout zu verwenden,
scheint hier mit 
myp1.setLayout(myGL23); 
myp2.setLayout(myGL23); 
normal zu klappen, Layouts haben vielleicht keinen inneren Zustand,
aber irgendwann mal in ähnlicher Situation..


----------



## André Uhres (24. Mrz 2008)

Wenn man sowohl die Anzahl der Zeilen als auch dei Anzahl der Spalten mit "nicht Null" angibt, 
dann wird die Anzahl der Spalten ignoriert. Statt dessen wird die Spaltenanzahl festgelegt durch die angegebene Zeilenanzahl und die Gesamtanzahl der Komponenten im Layout. Zum Beispiel, wenn drei Zeilen und zwei Spalten angegeben wurden und neun Komponenten werden dem Layout hinzugefügt,  dann werden sie in drei Zeilen und drei Spalten angezeigt. Die Angabe einer Spaltenanzahl berührt das Layout nur, wenn die Anzahl der Zeilen mit "Null" angegeben wird.


----------



## ernst (24. Mrz 2008)

>das Tutorial
>http://java.sun.com/docs/books/tutorial/uiswing/layout/grid.html
>verwendet 
>new GridLayout(0,2); 
>
Was ist der Unterschied zwischen  
new GridLayout(0,2); 
und
new GridLayout(1,2); 

>allgemein rate ich dir dringend, pro JPanel ein eigenes Layout zu verwenden,
>scheint hier mit 
>myp1.setLayout(myGL23); 
>myp2.setLayout(myGL23); 
>normal zu klappen, Layouts haben vielleicht keinen inneren Zustand,
>aber irgendwann mal in ähnlicher Situation..
>
Es wurde gesagt:
"Eine Swing Komponente kann nur einen Parent haben, 
also nicht myp1 und myp2, sondern nur myp1 oder myp2".

Wo steht diese Info in der Dokumentation?


mfg
Ernst


----------



## André Uhres (24. Mrz 2008)

> Was ist der Unterschied zwischen  
> new GridLayout(0,2); 
> und
> new GridLayout(1,2); 

1. Zwei Spalten, unbegrenzte Zeilen
2. Eine Zeile, unbegrenzte Spalten

> Es wurde gesagt:
> "Eine Swing Komponente kann nur einen Parent haben, 
> also nicht myp1 und myp2, sondern nur myp1 oder myp2".
> Wo steht diese Info in der Dokumentation?

http://java.sun.com/j2se/1.4.2/docs/api/java/awt/Component.html#getParent()

*Bemerkung:* Der JDK Quellcode für das Hinzufügen einer Komponente zu einem Container enthält die folgenden Zeilen:

```
if (comp.parent != null) {
	comp.parent.remove(comp);
```


----------



## ernst (25. Mrz 2008)

>> Was ist der Unterschied zwischen  
>> new GridLayout(0,2); 
>> und
>> new GridLayout(1,2); 
>
>1. Zwei Spalten, unbegrenzte Zeilen
>2. Eine Zeile, unbegrenzte Spalten
>
Hast du dich verschrieben?
new GridLayout(1,2); 
bedeutet doch  1 Zeile und 2 Spalten,
_nicht_ unbegrenzte Spalten!

>>
>> Es wurde gesagt:
>> "Eine Swing Komponente kann nur einen Parent haben, 
>> also nicht myp1 und myp2, sondern nur myp1 oder myp2".
>> Wo steht diese Info in der Dokumentation?
>
>http://java.sun.com/j2se/1.4.2/docs/api/java/awt/Component.html#getParent()
>
Dort steht nicht, dass es nur einen parent geben darf:

-----------------------------------------------------
public Container getParent()
  Gets the parent of this component.
  Returns:
    the parent container of this component
  Since:
  JDK1.0
-----------------------------------------------------


mfg
Ernst


----------



## ernst (25. Mrz 2008)

André Uhres hat gesagt.:
			
		

> Wenn man sowohl die Anzahl der Zeilen als auch dei Anzahl der Spalten mit "nicht Null" angibt,
> dann wird die Anzahl der Spalten ignoriert. Statt dessen wird die Spaltenanzahl festgelegt durch die angegebene Zeilenanzahl und die Gesamtanzahl der Komponenten im Layout. Zum Beispiel, wenn drei Zeilen und zwei Spalten angegeben wurden und neun Komponenten werden dem Layout hinzugefügt,  dann werden sie in drei Zeilen und drei Spalten angezeigt. Die Angabe einer Spaltenanzahl berührt das Layout nur, wenn die Anzahl der Zeilen mit "Null" angegeben wird.



Entschuldigung, habe diesen Beitrag überlesen.
Deshalb entfällt meine Frage dazu in meinem neusten Beitrag.

mfg
Ernst


----------



## ernst (25. Mrz 2008)

Hallo allerseits,
1)
Im Program unten, soll neben den Buttons auch eine Zeichnung dargestellt werden.
Da ich die Buttons klein machen will, mus ich eine hohe Zeilenanzahl wählen:
myGL62  = new GridLayout(6,2);
Allerdings wird deshalb auch die Zeichnung nicht mehr ganz dargestellt.
Kann man dies mit Hilfe von GridLayout noch hinbekommen, oder _muss _man 
dazu ein anderes Layout wählen. Wenn ja, welches? 

2)
Im Programm unten habe ich die Methode 
public Dimension getPreferredSize(){
  return (new Dimension(100,100));
}
nicht implementiert.
Trotzdem funktioniert das Programm.
Warum?


mfg
Ernst




```
import java.awt.*;

import javax.swing.*;

public class MainZeichnenUndButtons1 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
	}
}


class MyFenster extends JFrame{
	private Container mycont;
	private JButton myb1, myb2;
	private JTextField myt1, myt2;
	private JLabel myl1, myl2;
	private JPanel myp1;
	private MyZeichenflaeche myz;
	
	private GridLayout myGL62, myGL23;

	public MyFenster(){
		mycont = getContentPane();
		myb1=new JButton("Go");
		myb2=new JButton("Ok");
		myt1=new JTextField("hier eingeben",30);
		myt2=new JTextField("hier eingeben",30);
		myl1=new JLabel("Haarfarbe eingeben");
		myl2=new JLabel("Geschlecht");
		myp1 = new JPanel();
		myz = new MyZeichenflaeche();
		
		myGL62  = new GridLayout(6,2);
		myGL23  = new GridLayout(2,3);
		mycont.setLayout(myGL62);
		myp1.setLayout(myGL23);
		
		myp1.add(myl1);
		myp1.add(myt1);
		myp1.add(myb1);
		myp1.add(myl2);
		myp1.add(myt2);
		myp1.add(myb2);
		
		mycont.add(myp1);
		mycont.add(myz);		
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		mycont.add(new JLabel(""));
		
		

		setTitle("Meine Zeichnung");
		setLocation(30,60);
		setSize(600,400);
		setVisible(true);
	}
	
}

class MyZeichenflaeche extends JPanel{
	public void paintComponent(Graphics myg){
		Color myfarbe = new Color(100, 250, 200);
		myg.setColor(myfarbe);
		myg.drawOval(100, 50, 250, 300);
		myg.fillOval(100, 50, 250, 300);
		
		myg.setColor(Color.red);
		myg.drawString("Das bin ich",200,20);
		myg.drawLine(150,160,180,160);
		myg.drawLine(270,160,300,160);		
		myg.drawLine(230,200,230,230);
		myg.drawRect(200,280,50,30);		
	}

/*	
	public Dimension getPreferredSize(){
		  return (new Dimension(100,100));
	}
*/	
}
```


----------



## SlaterB (25. Mrz 2008)

ernst hat gesagt.:
			
		

> Dort steht nicht, dass es nur einen parent geben darf:
> 
> -----------------------------------------------------
> public Container getParent()
> Gets the parent of this component.



nun ja, je nach Interpretation, 

es gibt keine Operation 
public List getParentList()
sondern es wird nur ein einzelner Container zurückgegeben,
landläufig versteht man darunter, dass maximal ein Parent erlaubt/ möglich ist 


-----------

> Allerdings wird deshalb auch die Zeichnung nicht mehr ganz dargestellt. 


im GridLayout sind alle Zellen gleich groß, 
das kannst du nicht modifizieren, soweit ich weiß,

GridBagLayout bringt etwas mehr Möglichkeiten (z.B. dein ZeichenPanel mehrere Zeilen belegen lassen),
aber auch jede Menge anderer Probleme..

> Im Programm unten habe ich die Methode [..] nicht implementiert.  Trotzdem funktioniert das Programm.

wie gesagt sind alle Zellen gleich groß, PreferredSize usw. haben hier nicht viel zu sagen


----------



## ernst (25. Mrz 2008)

>im GridLayout sind alle Zellen gleich groß, 
>das kannst du nicht modifizieren, soweit ich weiß,
>
>GridBagLayout bringt etwas mehr Möglichkeiten (z.B. dein ZeichenPanel mehrere 
>Zeilen belegen lassen),
>aber auch jede Menge anderer Probleme..
>
oh Jammer...
was soll ich dann nehmen, bzw. was sind das für Probleme, bzw. sind die leicht zu beheben?

Bemerkung:
Das was ich wil, nämlich die Buttons nicht allzu groß darzustellen, ist doch keine exotische, 
luxeriöse Forderung, sondern etwas ganz Normales...
Da muss es doch sicher eine Möglichkeit geben. 


mfg
Ernst


----------



## SlaterB (25. Mrz 2008)

mal doch dein Layout auf, was willst du ungefähr haben?
du könntest z.B. nur die linke Seite für sich in ein Layout stecken
und am Ende nur zwei Objekte ins Gesamtlayout: 
linke Seite mit mehreren Zeilen, rechte Seite mit einem Bild,

so wie du ja in deinem bisherigen Beispielen auch UnterPanels verwendest,


----------



## ernst (25. Mrz 2008)

>mal doch dein Layout auf, was willst du ungefähr haben?
>
Im Prinzip soll die Zeichnung das ganze Fenster benutzen.
Und zusätzlich sollen sich noch ein paar Buttons, Labels und Textfelder im Fenster befinden,
mit denen man z.B. die Zeichnung beeinflussen kann:
Beispiel:
Mit einem Button kann man die Augenfarbe festlegen, 
mit einem Textfeld die Größe der Nase bestimmen, usw.

mfg
Ernst

Bemerkung:
Wenn ich ein Layout verschachtle z.B. verschachteltes Gridlayout, 
werden im günstigsten Fall - wenn man das Fenster in zwei gleich große 
Teile zerlegt - für meine Zeichnung nur die Hälfte des Fensters reserviert.
Das ist zu wenig.
Für die Buttosn, usw. wird auch nur die Hälfte des Fensters reserviert.
Das ist zu viel.


----------



## SlaterB (25. Mrz 2008)

auch da hilft wieder das GridBagLayout mit ProzentWerten pro Spalte
(aber auch Problemen, die ich immer noch nicht nenne  )

einfach mal Tutorial anschauen/ ausprobieren


----------



## André Uhres (25. Mrz 2008)

> Dort steht nicht, dass es nur einen parent geben darf:
Ja, aber wenn es mehr als einen geben darf, kann man nicht *den* parent zurückgeben!

> Kann man dies mit Hilfe von GridLayout noch hinbekommen, oder _muss _man
> dazu ein anderes Layout wählen. Wenn ja, welches?
Man ist nicht gezwungen, nur ein einziges Layout zu verwenden!
Z.B. BorderLayout mit GridLayout links und das Bild in der Mitte und ...

> Trotzdem funktioniert das Programm. Warum? 
Wegen des GridLayouts, wie SlaterB auch sagte.


----------



## ernst (25. Mrz 2008)

>auch da hilft wieder das GridBagLayout mit ProzentWerten pro Spalte
>(aber auch Problemen, die ich immer noch nicht nenne  )
>einfach mal Tutorial anschauen/ ausprobieren
>
Habe etwas recherchiert und folgendes Programm (siehe unten) gemacht.
Leider sind die 3 Buttons alle gleich groß.
Was muss ich zum Beispiel abändern, damit etwas "Struktur" reinkommt.
Insbesondere ist mir die Bedeutung von
------
gridx 
gridy
gridwidth
gridheight
weightx
weighty
------
nicht klar.

mfg
Ernst 



```
import java.awt.*;

import javax.swing.*;

public class MainGridBagLayout1 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
	}
}


class MyFenster extends JFrame{
	private Container mycont;
	private JButton myb1, myb2, myb3;
	private JTextField myt1, myt2;
	private JLabel myl1, myl2;
	private JPanel myp1;
	
	private GridLayout myGL62, myGL23;
	private GridBagLayout gbl;
	private GridBagConstraints gbc;	
	
	public MyFenster(){
		mycont = getContentPane();
		myp1=new JPanel();
		myb1=new JButton("B1");
		myb2=new JButton("B2");
		myb3=new JButton("B3");		
		
		gbl = new GridBagLayout();		

		mycont.setLayout(gbl);

		gbc = new GridBagConstraints();
		
		
		gbc.gridx = 0; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 2; 
		gbc.gridheight = 2;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myb1, gbc );
		
		gbc.gridx = 2; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 0; 
		gbc.weighty = 1.0;
		gbl.setConstraints(myb2, gbc );
		

		gbc.gridx = 2; 
		gbc.gridy = 1;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 0; 
		gbc.weighty = 0;
		gbl.setConstraints(myb3, gbc );
		
		myp1.add(myb1);
		myp1.add(myb2);
		myp1.add(myb3);		

				
		mycont.add(myp1);

		setTitle("Meine Zeichnung");
		setLocation(30,60);
		setSize(600,400);
		setVisible(true);
	}
	
}
```


----------



## SlaterB (25. Mrz 2008)

myp1 hat das StandardLayout FlowLayout, wenn du kein anderes setzt

> Insbesondere ist mir die Bedeutung von [..] nicht klar. 

tage- bis wochenlanges Bücher-lernen bleibt dir bei Java natürlich nie erspart


----------



## ernst (25. Mrz 2008)

>myp1 hat das StandardLayout FlowLayout, wenn du kein anderes setzt
>
Stimmt. Habe mein Programm abgeändert:


```
import java.awt.*;

import javax.swing.*;

public class MainGridBagLayout1 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
	}
}

class MyFenster extends JFrame{
	private Container mycont;
	private JButton myb1, myb2, myb3, myb4, myb5, myb6, myb7;
	private JTextField myt1, myt2;
	private JLabel myl1, myl2;
	private JPanel myp1;
	
	private GridLayout myGL62, myGL23;
	private GridBagLayout gbl;
	private GridBagConstraints gbc;	
	
	public MyFenster(){
		mycont = getContentPane();
		myp1=new JPanel();
		myb1=new JButton("B1");
		myb2=new JButton("B2");
		myb3=new JButton("B3");		
		myb4=new JButton("B4");		
		myb5=new JButton("B5");
		myb6=new JButton("B6");		
		myb7=new JButton("B7");		
		
		gbl = new GridBagLayout();		

		myp1.setLayout(gbl);
		gbc = new GridBagConstraints();
		
		gbc.fill = gbc.BOTH;
		
		gbc.gridx = 0; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 2; 
		gbc.gridheight = 2;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myb1, gbc );
		
		gbc.gridx = 2; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 0; 
		gbc.weighty = 1.0;
		gbl.setConstraints(myb2, gbc );
		

		gbc.gridx = 2; 
		gbc.gridy = 1;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 0; 
		gbc.weighty = 0;
		gbl.setConstraints(myb3, gbc );


		gbc.gridx = 0; 
		gbc.gridy = 2;
		
		gbc.gridwidth = 3; 
		gbc.gridheight = 1;
		
		gbc.weightx = 0; 
		gbc.weighty = 1.0;
		gbl.setConstraints(myb4, gbc );
		
		
		gbc.gridx = 0; 
		gbc.gridy = 3;
		
		gbc.gridwidth = 2; 
		gbc.gridheight = 1;
		
		gbc.weightx = 0; 
		gbc.weighty = 0;
		gbl.setConstraints(myb5, gbc );
		

		gbc.gridx = 0; 
		gbc.gridy = 4;
		
		gbc.gridwidth = 2; 
		gbc.gridheight = 1;
		
		gbc.weightx = 0; 
		gbc.weighty = 0;
		gbl.setConstraints(myb6, gbc );
		
		gbc.gridx = 2; 
		gbc.gridy = 3;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 2;
		
		gbc.weightx = 0; 
		gbc.weighty = 0;
		gbl.setConstraints(myb7, gbc );
		
		
		myp1.add(myb1);
		myp1.add(myb2);
		myp1.add(myb3);		
		myp1.add(myb4);
		myp1.add(myb5);
		myp1.add(myb6);		
		myp1.add(myb7);
				
		mycont.add(myp1);

		setTitle("Meine Zeichnung");
		setLocation(30,60);
		setSize(600,400);
		setVisible(true);
	}
}
```


>> Insbesondere ist mir die Bedeutung von [..] nicht klar. 
>tage- bis wochenlanges Bücher-lernen bleibt dir bei Java natürlich nie erspart
>
Habe mir mal die folgende Beschreibung (unten) angeschaut.
-----------------------------------------
gridx - gibt die Spaltennummer an.
gridy - gibt die Zeilennummer an.
gridwidth - gibt die Ausdehnung der Zelle über die Spalten an. Entspricht dem colspan-Attribut in HTML Tabellen.
gridheight - gibt die Ausdehnung der Zelle über die Zeilen an. Entspricht dem rowspan-Attribut in HTML Tabellen.
weightx - gibt die Gewichtung an. Das bedeutet, dass wenn man einer Zelle A die Gewichtung 1.0 gibt und einer Zelle B 4.0 dann wird Zelle B 4 mal so breit wie Zelle A dargestellt.
weighty - gibt die Gewichtung in der Höhe an.
---------------------------------------
1)
Konkret angewendet auf:
gbc.gridx = 0; 
gbc.gridy = 0;
gbc.gridwidth = 2; 
gbc.gridheight = 2;
gbc.weightx = 1.0; 
gbc.weighty = 1.0;

geht also über 2 Zeilen und 2 Spalten.

Aber (im nächsten Button)
gbc.gridwidth = 1; 
gbc.gridheight = 1;
geht also über 1 Zeile und 1 Spalte.

Das macht sich optisch aber nicht bemerkbar!

2)
Mit 
weightx
weighty
kann ich nicht viel anfangen.
Die Ausdehnung wird doch schon mit gridwidth, gridheight geregelt.



mfg
Ernst


----------



## SlaterB (25. Mrz 2008)

> Das macht sich optisch aber nicht bemerkbar! 

wieso? Button1 ist doch höher als Button2, eben weil er zwei Zeilen belegt

> Mit weightx  weighty kann ich nicht viel anfangen. 
> Die Ausdehnung wird doch schon mit gridwidth, gridheight geregelt. 

das ist nur die Anzahl der Zeilen, Spalten,
die Zeilen und Spalten können aber unterschiedlich groß sein,
wie dein Programm eindrucksvoll beweist (falls es bei dir genauso aussieht wie bei mir)

Zeile 1 ist ~150 Pixel hoch, Zeile 2 nur 20


----------



## André Uhres (25. Mrz 2008)

ernst hat gesagt.:
			
		

> ..keine exotische, luxeriöse Forderung, sondern etwas ganz Normales..




```
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class NewJFrame7 extends JFrame implements ActionListener {
    private JButton btHairColor;
    private JButton btSex;
    private JToolBar toolbar;
    private String haarfarber;
    private String sex;
    public NewJFrame7() {
        toolbar = new JToolBar();
        btHairColor = new JButton("Haarfarbe");
        btSex = new JButton("Geschlecht");
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        btHairColor.addActionListener(this);
        toolbar.add(btHairColor);
        btSex.addActionListener(this);
        toolbar.add(btSex);
        getContentPane().add(toolbar, BorderLayout.PAGE_START);
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setBounds((screenSize.width - 500) / 2, (screenSize.height - 600) / 2, 500, 600);
        add(new DrawingPanel());
    }
    public void actionPerformed(ActionEvent evt) {
        if (evt.getSource() == btHairColor) {
            NewJFrame7.this.btHairColorActionPerformed(evt);
        } else if (evt.getSource() == btSex) {
            NewJFrame7.this.btSexActionPerformed(evt);
        }
    }
    private void btHairColorActionPerformed(ActionEvent evt) {
        haarfarber = JOptionPane.showInputDialog("Haarfarbe");
    }
    private void btSexActionPerformed(ActionEvent evt) {
        sex = JOptionPane.showInputDialog("Geschlecht");
    }
    public static void main(String args[]) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                new NewJFrame7().setVisible(true);
            }
        });
    }
}
class DrawingPanel extends JPanel {
    @Override
    protected void paintComponent(Graphics myg) {
        super.paintComponent(myg);
        Color myfarbe = new Color(100, 250, 200);
        myg.setColor(myfarbe);
        myg.drawOval(100, 50, 250, 300);
        myg.fillOval(100, 50, 250, 300);
        myg.setColor(Color.red);
        myg.drawString("Das bin ich", 200, 20);
        myg.drawLine(150, 160, 180, 160);
        myg.drawLine(270, 160, 300, 160);
        myg.drawLine(230, 200, 230, 230);
        myg.drawRect(200, 280, 50, 30);
    }
}
```


----------



## ernst (25. Mrz 2008)

>> Mit weightx  weighty kann ich nicht viel anfangen. 
>> Die Ausdehnung wird doch schon mit gridwidth, gridheight geregelt. 
>>
>das ist nur die Anzahl der Zeilen, Spalten,
>die Zeilen und Spalten können aber unterschiedlich groß sein,
>wie dein Programm eindrucksvoll beweist (falls es bei dir genauso aussieht wie bei mir)
>Zeile 1 ist ~150 Pixel hoch, Zeile 2 nur 20[/quote]
>
Was bedeutet dann aber die 0 in:
gbc.weightx = 0; oder
gbc.weighty = 0; 



mfg Ernst


----------



## SlaterB (25. Mrz 2008)

wenn alle 0 haben dann ist das Verhältnis gleich,
wenn einer 1 hat und alle andern 0, dann wird einer so groß wie möglich, die anderen so klein wie möglich

hier spielt PreferredSize & Co. wieder eine Rolle, vielleicht auch in speziell diesen Fall MinimumSize,
alles zu testen wenn man es genau wissen will 
(oder Andre oder sonstwer erklärts genau)


----------



## ernst (25. Mrz 2008)

>wenn alle 0 haben dann ist das Verhältnis gleich,
>wenn einer 1 hat und alle andern 0, dann wird einer so groß wie möglich, 
>die anderen so klein wie möglich
>
ok

Warum kann ich aber bei 
--------------------
gbc.gridx = 0; 
gbc.gridy = 2;

gbc.gridwidth = 3; 
gbc.gridheight = 1;
----------------------
bei
gbc.gridwidth = 3; 

auch irgendeine andere Zahl wie z.B. 78 eintragen, ohne dass sich optisch was ändert?

mfg
Ernst


----------



## SlaterB (25. Mrz 2008)

weil es völlig egal ist, ob du 3 Spalten hast, die je 100 Pixel breit sind oder 78 Spalten, die je 3.5 Pixel breit sind,
solange deine Komponenten alle Spalten überdecken

setze doch mal Buttons in Spalte 1-3 oder 1-78, die nur eine Zelle breit sind,
dann wirst du die einzelnen Zellen deutlicher sehen..


----------



## ernst (25. Mrz 2008)

Habe jetzt mal eine Zeichnung, ein paar Buttons, usw. in ein Fenster gebracht.
Leider werden die Buttons noch zu groß und die Zeichnung zu klein.
Warum?
Was muss ich am Programm ändern?

mfg
Ernst




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

public class MainZeichnenUndButtons3 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
	}
}


class MyFenster extends JFrame{
	private Container mycont;
	private JButton myb1, myb2, myb3, myb4, myb5, myb6, myb7;
	private JTextField myt1, myt2;
	private JLabel myl1, myl2;
	private JPanel myp1;
	private MyZeichenflaeche myz;
	private GridBagLayout gbl;
	private GridBagConstraints gbc;	
	
	public MyFenster(){
		mycont = getContentPane();
		myb1=new JButton("Go");
		myb2=new JButton("Ok");
		myt1=new JTextField("hier eingeben",30);
		myt2=new JTextField("hier eingeben",30);
		myl1=new JLabel("Haarfarbe eingeben");
		myl2=new JLabel("Geschlecht");
		
		myz = new MyZeichenflaeche();		
		myp1=new JPanel();

		gbl = new GridBagLayout();		

		myp1.setLayout(gbl);
		gbc = new GridBagConstraints();
		
		gbc.fill = gbc.BOTH;
		
		gbc.gridx = 0; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myl1, gbc );
		
		gbc.gridx = 10; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0;		
		gbc.weighty = 1.0;
		gbl.setConstraints(myt1, gbc );
		

		gbc.gridx = 20; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myb1, gbc );

		gbc.gridx = 0; 
		gbc.gridy = 1;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0;		
		gbc.weighty = 1.0;
		gbl.setConstraints(myl2, gbc );
		
		gbc.gridx = 10; 
		gbc.gridy = 1;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;

		gbl.setConstraints(myt2, gbc );
		

		gbc.gridx = 20; 
		gbc.gridy = 1;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myb2, gbc );
		
		gbc.gridx = 0; 
		gbc.gridy = 2;
		
		gbc.gridwidth = 200; 
		gbc.gridheight = 200;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myz, gbc );
	
		
		myp1.add(myl1);
		myp1.add(myt1);
		myp1.add(myb1);
		myp1.add(myl2);
		myp1.add(myt2);
		myp1.add(myb2);
		myp1.add(myz);
				
		mycont.add(myp1);

		setTitle("Meine Zeichnung");
		setLocation(30,60);
		setSize(800,600);
		setVisible(true);
	}
}

class MyZeichenflaeche extends JPanel{
	public void paintComponent(Graphics myg){
		Color myfarbe = new Color(100, 250, 200);
		myg.setColor(myfarbe);
		myg.drawOval(100, 50, 250, 300);
		myg.fillOval(100, 50, 250, 300);
		
		myg.setColor(Color.red);
		myg.drawString("Das bin ich",200,20);
		myg.drawLine(150,160,180,160);
		myg.drawLine(270,160,300,160);		
		myg.drawLine(230,200,230,230);
		myg.drawRect(200,280,50,30);		
	}
}
```


----------



## SlaterB (25. Mrz 2008)

??

du hast bei allen weighty = 1, also wird der zur Verfügung stehende Platz gerecht auf alle 3 Zeilen gleichverteilt,
wenn die dritte Zeile mehr Platz haben soll, dann teile ihr mehr Platz zu als den anderen,

die ersten beiden Zeilen willst du bestimmt so klein wie möglich, 
wie das beim GridBagLayout geht steht auch schon in diesem Thread..


ich schimpfe ja immer mit dem GridBagLayout, aber wenn man es so benutzt..
bald antworte ich nicht mehr wenn du immer die gleichen Sachen nochmal fragst


----------



## ernst (25. Mrz 2008)

>ich schimpfe ja immer mit dem GridBagLayout, aber wenn man es so benutzt..
>bald antworte ich nicht mehr wenn du immer die gleichen Sachen nochmal fragst[/quote]
>
Du hast recht, aber das ganze ist mir noch ziemlich ungewohnt...

Ichhabe das Programm geändert:

gbc.gridx = 0; 
gbc.gridy = 2;
gbc.gridwidth = 200; 
gbc.gridheight = 200;
gbc.weightx = 100.0; 
gbc.weighty = 100.0;
gbl.setConstraints(myz, gbc );

Jetzt hat die Zeichnung genügend Platz. Wunderbar!
Jetzt will ich nur noch Button, Textfeld und Label in der _Breite_ kleiner machen,
d.h. z.B.  dass der Button in der Breite nicht mehr so viel Platz braucht.
Wie mache ich das?
Ich habe schon einiges probiert, aber der Button wurde nicht schmaler.

mfg
Ernst


----------



## SlaterB (25. Mrz 2008)

was du da wohl probiert hast..,

einfach weightx (natürlich für beide) verringern, z.B. auf 0.1, schon wirds kleiner,
am besten wie immer auf 0, dann wirds minimal klein

kleiner als die Standardgröße beim FlowLayout wirds aber nicht,
da muss man schon im Button selber tricksen

 myb1.setMargin(new Insets(0,0,0,0));
 myb2.setMargin(new Insets(0,0,0,0));

macht sie ganz schön klein (kommt erst bei gbc.weightx = 0 richtig zur Geltung)

---------

> Jetzt will ich nur noch Button, Textfeld und Label in der _Breite_ kleiner machen

alle drei kannst du kaum gleichzeitig kleiner machen, wenn sie die ganze Zeilenbreite einnehmen,

evtl. ähnlich wie beim GridLayout ein leeres JLabel vorne oder hinten anfügen um den restlichen Platz zu belegen,
und natürlich alle weightx richtig setzen


----------



## André Uhres (26. Mrz 2008)

*gelöscht*


----------



## ernst (26. Mrz 2008)

>alle drei kannst du kaum gleichzeitig kleiner machen, wenn sie die ganze Zeilenbreite einnehmen,
>evtl. ähnlich wie beim GridLayout ein leeres JLabel vorne oder hinten anfügen um den restlichen 
>Platz zu belegen, und natürlich alle weightx richtig setzen
>
Dank deiner Tipps wird mein Fenster immer besser.
Deinen Tipp befolgend habe ich in noch ein paar leere Labels (ich habe sie dummys genannt)
eingebaut, um die Buttons, usw.  kleiner zu machen.
Ich habe sie zu Testzwecken _nur_ in der 1. Zeile eingebaut.
Und alles funktioniert bestens, d.h die 2. Zeile wird genau so "formatiert", 
obwohl ich die leeren Labels _nur_ in der 1. Zeile eingebaut habe.
Warum muss ich sie nicht auch noch in der  2. Zeile einbauen?

mfg
Ernst



```
import java.awt.*;

import javax.swing.*;

public class MainZeichnenUndButtons3 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
	}
}


class MyFenster extends JFrame{
	private Container mycont;
	private JButton myb1, myb2;
	private JTextField myt1, myt2;
	private JLabel myl1, myl2;
	private JLabel dummyl1, dummyl2;
	
	private JPanel myp1;
	private MyZeichenflaeche myz;
	private GridBagLayout gbl;
	private GridBagConstraints gbc;	
	
	public MyFenster(){
		mycont = getContentPane();
		myb1=new JButton("Go");
		myb2=new JButton("Ok");
		myt1=new JTextField("hier eingeben",30);
		myt2=new JTextField("hier eingeben",30);
		myl1=new JLabel("Haarfarbe eingeben");
		myl2=new JLabel("Geschlecht");
		dummyl1=new JLabel("");
		dummyl2=new JLabel("");
		
		myz = new MyZeichenflaeche();		
		myp1=new JPanel();

		gbl = new GridBagLayout();		

		myp1.setLayout(gbl);
		gbc = new GridBagConstraints();
		
		gbc.fill = gbc.BOTH;
		
		gbc.gridx = 0; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myl1, gbc );

		gbc.gridx = 1; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(dummyl1, gbc );
		
		gbc.gridx = 2; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 2; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0;		
		gbc.weighty = 1.0;
		gbl.setConstraints(myt1, gbc );

		gbc.gridx = 4; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myb1, gbc );

		gbc.gridx = 5; 
		gbc.gridy = 0;
		
		gbc.gridwidth = 3; 
		gbc.gridheight = 1;
		
		gbc.weightx = 64.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(dummyl2, gbc );
		
		
		gbc.gridx = 0; 
		gbc.gridy = 1;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0;		
		gbc.weighty = 1.0;
		gbl.setConstraints(myl2, gbc );
		
		gbc.gridx = 2; 
		gbc.gridy = 1;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;

		gbl.setConstraints(myt2, gbc );
		

		gbc.gridx = 4; 
		gbc.gridy = 1;
		
		gbc.gridwidth = 1; 
		gbc.gridheight = 1;
		
		gbc.weightx = 1.0; 
		gbc.weighty = 1.0;
		
		gbl.setConstraints(myb2, gbc );
		
		gbc.gridx = 0; 
		gbc.gridy = 2;
		
		gbc.gridwidth = 200; 
		gbc.gridheight = 200;
		
		gbc.weightx = 100.0; 
		gbc.weighty = 100.0;
		
		gbl.setConstraints(myz, gbc );
		
		myp1.add(myl1);
		myp1.add(dummyl1);		
		myp1.add(myt1);
		myp1.add(dummyl2);		
		myp1.add(myb1);
		myp1.add(myl2);
		myp1.add(myt2);
		myp1.add(myb2);
		myp1.add(myz);
				
		mycont.add(myp1);

		setTitle("Meine Zeichnung");
		setLocation(30,60);
		setSize(800,600);
		setVisible(true);
	}
	
}

class MyZeichenflaeche extends JPanel{
	public void paintComponent(Graphics myg){
		Color myfarbe = new Color(100, 250, 200);
		myg.setColor(myfarbe);
		myg.drawOval(100, 50, 250, 300);
		myg.fillOval(100, 50, 250, 300);
		
		myg.setColor(Color.red);
		myg.drawString("Das bin ich",200,20);
		myg.drawLine(150,160,180,160);
		myg.drawLine(270,160,300,160);		
		myg.drawLine(230,200,230,230);
		myg.drawRect(200,280,50,30);		
	}
}
```


----------



## SlaterB (26. Mrz 2008)

überlege doch mal was ein Grid ist,
wenn du durch die Verteilung in der ersten Zeile festlegst, dass die letzte Spalte 50 Pixel breit ist, dann gilt das für das gesamte Grid,
die Spalte kann nicht in Zeile 2 kleiner oder weggelassen werden

am besten wäre wohl ein Einblenden der Gitternetzlinien,
keine Ahnung ob das geht,
stell dir einfach eine JTable vor


----------

