/*
P R O G R A M M B E S C H R E I B U N G
1)
Es wird das Fenster MyFenster erzeugt und auf den Bildschirm gebracht
In diesem Fenster wird eine Zeichenfläche (Panel) erstellt.
In dieser Zeichenfläche werden 2 Labels, 2 Buttons (Schalter) und 
2 Textfelder erstellt.
In das Textfeld kann Text eingegeben werden, wobei dieser noch
nicht verarbeitet wird.

2) Layout
a)
Zusätzlich wird ein Layout (2 Zeilen, 3 Spalten) für diese Zeichenfläche 
erstellt.
Ein Layout ist eine Vorgabe, wie die grafischen Komponenten innerhalb
eines Panels bzw. eines Fensters angeordnet werden (z.B. wenn sie mit
add hinzugefügt werden).

Layouts Besonderheiten:
b) 
Wenn man mit:
myGL62  = new GridLayout(6,2);
mycont.setLayout(myGL62);
6 Zeilen und 2 Spalten vorgibt,
und dann nicht alle 6*2=12 Elemente befüllt,
sondern z.B. (durch 2 add Befehle) nur 2 Elemente 
dann geschieht nicht das Gewünschte.
(offensichtlich gruppiert dann Java um. Man muss also alle Elemente befüllen).
Deshalb befüllt man den Rest mit DummyLabels.

c) 
Warum kann nicht nur ein Dummylabel verwendet werden?
(das man explizit erstellt und dem man einen Namen gibt, wie z.B:
JLabel myDummyLabel = new JLabel())
Weil beim Aufruf einer Methode (z.B. add) dieses DummyLabel 
verändert wird.
Und wenn auf dieses veränderte DummyLabel wieder die Methode
add angewendet wird, ist dies etwas anderes, wenn man für jedes
add ein anderes DummyLabel verwendet.

Wenn man Parameter in add benutzt:
new JLabel()
dann wird bei jedem Aufruf ein _neues_ (nicht mehr referenzierbares)
Jlabel erstellt.

Zitat Hubert Partl:
Jedes Komponenten-Objekt kann nur an 1 Stelle in 1 Container stehen,
d.h. der add-Befehl aendert die Eigenschaften von dummyLabel1,
und er aendert sogar die Eigenschaften von myPan26, indem er ein
remove auf das vorherige add macht.
Das steht alles in der Online-Doku von add() bzw. addImpl() 
in der Klasse Container:
"Adds the specified component to this container at the specified index. 
...
If the component is not an ancestor of this container and has a non-null
parent, it is removed from its current parent before it is added to this
container." 


3) Zeichenfläche (JPanel)
Man kann Buttons, usw. nicht nur direkt im Fenster anbringen, 
sondern diese vorher an eine sogenannte Zeichenfläche (JPanel)
anbringen und diese dann im Fenster anmontieren.


4) Zeichen
In einer Zeichenfläche wird gezeichnet
*/


import java.awt.*;

import javax.swing.*;

// Hier wird ein Objekt der selbstgebastelten Klasse MyFenster erzeugt
public class MainFensterZeichnung1 {
	public static void main(String[] args) {
		MyFenster myf = new MyFenster();
		myf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}

// Ein Frame ist ein Fenster bzw. Fenstersegment
// Es ist nach seiner Erzeugung zuerst anfänglich unsichtbar.
// Hier wird die von JFrame abgeleitete Klasse MyFenster gebastelt, die 
// damit die ganze Leistungsfähigkeit von JFrame erbt.
class MyFenster extends JFrame{
	// Buttons (Schalter) deklarieren
	private JButton myB1;
	// Textfelder deklarieren
	private JTextField myT1;
	// Labels deklarieren
	private JLabel myL1;
	// Zeichenflächen
	private JPanel myPan1;
	private MyZeichenflaeche myZf1;
	// Stelle in MyFenster deklarieren, an die montiert wird.	
	private Container myCont;
	// Für myCont ein Layout
	private GridLayout myGL21;
	// Für myPan1 ein Layout
	private GridLayout myGL13;
	// Für myZf1 muss kein Layout erstellt werden, da
	// dort keine Buttons, Labels, usw. angebracht werden.

	// Konstruktor
	public MyFenster(){
		// Erzeugt jeweils ein Button 
		myB1=new JButton("Go");
		// Erzeugt jeweils ein einzeiliges Textfeld mit dem vorgegebenen
		// Text und der vorgegebenen Spaltenzahl. Dieser Text kann 
		// (im Gegensatz zu einem Label) editiert werden
		myT1=new JTextField("hier eingeben",30);
		// Erzeugt jeweils ein Label (Beschriftung) mit dem vorgegebenen 
		// Text Dieser Text kann (im Gegensatz zu einem Textfeld) nicht 
		// editiert werden
		myL1=new JLabel("Euro --> Dollar");
		// Erzeugt  Zeichenflächen
		myPan1 = new JPanel();
		myZf1 = new MyZeichenflaeche();
		// Erzeugt Layouts
		// Liefert die Stelle in MyFenster, an die montiert wird.
		myCont = getContentPane();
		myGL21 = new GridLayout(2,1);
		myGL13 = new GridLayout(1,3);
		// Ordnet das Layout dem Container myCont zu und 
		// "formatiert" ihn damit.
		myCont.setLayout(myGL21);
		myPan1.setLayout(myGL13);

		// Montiert die grafischen Komponenten in myPan1
		myPan1.add(myL1);
		myPan1.add(myT1);
		myPan1.add(myB1);
		
		myCont.add(myPan1);
		myCont.add(myZf1);
		
		// Fensterüberschrift festlegen
		setTitle("Meine Zeichnung");
		// Koordinaten des linken, oberen Ecks des Fensters festlegen
		// Koordinate x = 30, Koordinate y = 60.		
		setLocation(30,60);
		// Die Breite des Fensters in x-Richtung = 600
		// Die Breite des Fensters in y-Richtung = 400		
		setSize(600,800);
		// Macht das Fenster sichtbar
		setVisible(true);
	}
}


//Eine Unterklasse des Containers JPanel erstellen
class MyZeichenflaeche extends JPanel{
/*
Die folgende Methode paintComponent(g) soll niemals direkt innerhalb des
selbstgeschriebenen Programms aufgerufen werden !
Java (bzw. das Betriebssystem) entscheidet selbst, wenn es 
paintComponent(g) aufruft. Dies geschieht:
-> bei der ersten Anzeige des Fensters (setVisible(true))
-> nachdem ein Fenster vergrößert (verkleinert) wurde,
-> nach dem Wegziehen überlagernder Fenster (verdeckter Elemente 
   werden aufgedeckt)
-> nach einer Größenänderung des Fensters
-> nach dem Aufruf des Befehls repaint() im Programm

Bem:
Den Parameter in paintComponent(...) kann man sich als den Teil des 
Bildspeicherbereichs vorstellen, der die zugehörige Komponente auf dem 
Bildschirm repräsentiert.
*/
	public void paintComponent(Graphics myG){
		/*
		Eigene Farben basteln:
		150, 180, 234 sind die Rot-, Grün- und Blauteile einer Farbe 
		jeweils im Bereich zwischen 0 und 255
		*/
		Color myFarbe = new Color(100, 250, 200);
		// Diese Farbe setzen
		myG.setColor(myFarbe);
		/*
		Zeichnet die Randlinie einer Ellipse, die sich in einem gedachten 
		Rechteck befindet. Der linke obere Punkt hat die Koordinaten 
		Koordinate x = 100, Koordinate y = 50.
		Die Breite des Rechtecks in x-Richtung = 250
		Die Breite des Rechtecks in y-Richtung = 300		
		*/
		myG.drawOval(100, 50, 250, 300);
		// Füllt die Ellipse mit der vorher gesetzten Farbe
		myG.fillOval(100, 50, 250, 300);
		
		// Die Farbe rot auswählen (setzen)
		myG.setColor(Color.red);
		// Text ausgeben
		myG.drawString("Das bin ich",200,20);
		// Linie zeichnen
		myG.drawLine(150,160,180,160);
		myG.drawLine(270,160,300,160);		
		myG.drawLine(230,200,230,230);
		myG.drawRect(200,280,50,30);		
	}
}