add Baelle project for simple inheritance

22 files changed, 4052 insertions, 0 deletions

diff --git a/Info/10/2/Baelle/BlueJ_Projekt/.gitignore b/Info/10/2/Baelle/BlueJ_Projekt/.gitignore
new file mode 100644
index 00000000..6b468b62
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/.gitignore
@@ -0,0 +1 @@
+*.class
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Ball.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Ball.ctxt
new file mode 100644
index 00000000..41bcef2c
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Ball.ctxt
@@ -0,0 +1,15 @@
+#BlueJ class context
+comment0.target=Ball
+comment1.params=
+comment1.target=Ball()
+comment2.params=x\ y
+comment2.target=Ball(int,\ int)
+comment3.params=
+comment3.target=void\ Ausf\u00FChren()
+comment4.params=sondertaste
+comment4.target=void\ SonderTaste(int)
+comment5.params=taste
+comment5.target=void\ Taste(char)
+comment6.params=x\ y\ anzahl
+comment6.target=void\ Geklickt(int,\ int,\ int)
+numComments=7
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Ball.java b/Info/10/2/Baelle/BlueJ_Projekt/Ball.java
new file mode 100644
index 00000000..61c92965
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Ball.java
@@ -0,0 +1,33 @@
+public class Ball extends Kreis implements Zeichenfenster.AktionsEmpfaenger {
+    static final double BESCHLEUNIGUNG = 5;
+    double geschwindigkeit = 0;
+    
+    public Ball() {
+        super();
+        Zeichenfenster.AktionsEmpfängerEintragen(this);
+    }
+    
+    public Ball(int x, int y) {
+        this();
+        super.PositionSetzen(x, y);
+    }
+    
+    public void Ausführen() {
+        // Der Ball liegt
+        if (y == 600-radius) {
+            return;
+        }
+        // Der Ball faellt
+        geschwindigkeit += BESCHLEUNIGUNG; // Beschleunigung
+        int ny = y + (int)geschwindigkeit;
+        if (ny >= 600-radius) { // Der Ball ist aufgeschlagen
+            ny = 600-radius;
+            geschwindigkeit = 0;
+        }
+
+        super.PositionSetzen(x, ny);
+    }
+    public void SonderTaste(int sondertaste) {}
+    public void Taste(char taste) {}
+    public void Geklickt(int x, int y , int anzahl) {}
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Dreieck.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Dreieck.ctxt
new file mode 100644
index 00000000..54170c4f
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Dreieck.ctxt
@@ -0,0 +1,43 @@
+#BlueJ class context
+comment0.target=Dreieck
+comment0.text=\n\ Wrapperklasse\ f\u00FCr\ ein\ Dreieck\ auf\ der\ Zeichenfl\u00E4che.\n\ \n\ @author\ Albert\ Wiedemann\ \n\ @version\ 1.0\n
+comment1.params=
+comment1.target=Dreieck()
+comment1.text=\n\ Der\ Konstruktor\ erzeugt\ das\ Delegate-Objekt\n
+comment10.params=
+comment10.target=void\ NachVornBringen()
+comment10.text=\n\ Bringt\ das\ Dreieck\ eine\ Ebene\ nach\ vorn.\n
+comment11.params=
+comment11.target=void\ GanzNachVornBringen()
+comment11.text=\n\ Bringt\ das\ Dreieck\ in\ die\ vorderste\ Ebene.\n
+comment12.params=
+comment12.target=void\ NachHintenBringen()
+comment12.text=\n\ Bringt\ das\ Dreieck\ eine\ Ebene\ nach\ hinten.\n
+comment13.params=
+comment13.target=void\ GanzNachHintenBringen()
+comment13.text=\n\ Bringt\ das\ Dreieck\ in\ die\ hinterste\ Ebene.\n
+comment2.params=x\ y
+comment2.target=void\ PositionSetzen(int,\ int)
+comment2.text=\n\ Setzt\ die\ Position\ (der\ Spitze)\ des\ Dreiecks.\n\ @param\ x\ x-Position\ der\ Spitze\n\ @param\ y\ y-Position\ der\ Spitze\n
+comment3.params=deltaX\ deltaY
+comment3.target=void\ Verschieben(int,\ int)
+comment3.text=\n\ Verschiebt\ das\ Dreieck\ um\ die\ angegebenen\ Werte.\n\ @param\ deltaX\ Verschiebung\ in\ x-Richtung\n\ @param\ deltaY\ Verschiebung\ in\ y-Richtung\n
+comment4.params=grad
+comment4.target=void\ Drehen(int)
+comment4.text=\n\ Dreht\ das\ Dreieck\n\ @param\ grad\ Drehwinkel\ (mathematisch\ positiver\ Drehsinn)\ im\ Gradmass\n
+comment5.params=breite\ h\u00F6he
+comment5.target=void\ Gr\u00F6\u00DFeSetzen(int,\ int)
+comment5.text=\n\ Setzt\ die\ Gr\u00F6\u00DFe\ des\ Dreiecks.\n\ @param\ breite\ (neue)\ Breite\n\ @param\ h\u00F6he\ (neue)\ H\u00F6he\n
+comment6.params=farbe
+comment6.target=void\ FarbeSetzen(java.lang.String)
+comment6.text=\n\ Setzt\ die\ Farbe\ des\ Dreiecks.\n\ Erlaubte\ Farben\ sind\:\n\ "wei\u00DF",\ "weiss",\ "rot",\ "gr\u00FCn",\ "gruen",\ "blau",\ "gelb",\n\ "magenta",\ "cyan",\ "hellgelb",\ "hellgr\u00FCn",\ "hellgruen",\n\ "orange",\ "braun",\ "grau",\ "schwarz"\n\ Alle\ anderen\ Eingaben\ werden\ auf\ die\ Farbe\ schwarz\ abgebildet.\n\ @param\ farbe\ (neue)\ Farbe\n
+comment7.params=winkel
+comment7.target=void\ WinkelSetzen(int)
+comment7.text=\n\ Setzt\ den\ Drehwinkel\ des\ Dreiecks.\n\ Die\ Winkelangabe\ ist\ in\ Grad,positive\ Werte\ drehen\ gegen\ den\ Uhrzeigersinn,\n\ negative\ Werte\ drehen\ im\ Uhrzeigersinn\ (mathematisch\ positiver\ Drehsinn).\n\ @param\ winkel\ der\ (neue)\ Drehwinkel\ des\ Dreiecks\n
+comment8.params=sichtbar
+comment8.target=void\ SichtbarkeitSetzen(boolean)
+comment8.text=\n\ Schaltet\ die\ Sichtbarkeit\ des\ Dreiecks\ ein\ oder\ aus.\n\ Erlaubte\ Parameterwerte\:\ true,\ false\n\ @param\ sichtbar\ (neue)\ Sichtbarkeit\ des\ Dreiecks\n
+comment9.params=
+comment9.target=void\ Entfernen()
+comment9.text=\n\ Entfernt\ das\ Dreieck\ aus\ dem\ Zeichenfenster.\n
+numComments=14
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Dreieck.java b/Info/10/2/Baelle/BlueJ_Projekt/Dreieck.java
new file mode 100644
index 00000000..de96f38b
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Dreieck.java
@@ -0,0 +1,170 @@
+/**
+ * Wrapperklasse für ein Dreieck auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Dreieck
+{
+    /** x-Position der Spitze. */
+    protected int x;
+    /** y-Position der Spitze. */
+    protected int y;
+    /** Breite des umgebenden Rechtecks. */
+    protected int breite;
+    /** Höhe des umgebenden Rechtecks. */
+    protected int höhe;
+    /** Farbe des Dreiecks. */
+    protected String farbe;
+    /** Sichtbarkeit des Dreiecks. */
+    protected boolean sichtbar;
+    /** Drehwinkel (mathematisch positiver Drehsinn) des Dreiecks in Grad. */
+    protected int winkel;
+    /** Referenz auf das Delegate-Objekt. */
+    Zeichenfenster.GrafikSymbol symbol;
+
+    /**
+     * Der Konstruktor erzeugt das Delegate-Objekt
+     */
+    Dreieck ()
+    {
+        x = 60;
+        y = 10;
+        breite = 100;
+        höhe = 100;
+        farbe = "rot";
+        sichtbar = true;
+        winkel = 0;
+        symbol = Zeichenfenster.SymbolErzeugen(Zeichenfenster.SymbolArt.dreieck);
+        symbol.PositionSetzen(x - breite / 2, y);
+        symbol.GrößeSetzen(breite, höhe);
+        symbol.FarbeSetzen(farbe);
+        symbol.SichtbarkeitSetzen(sichtbar);
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Setzt die Position (der Spitze) des Dreiecks.
+     * @param x x-Position der Spitze
+     * @param y y-Position der Spitze
+     */
+    void PositionSetzen(int x, int y)
+    {
+        this.x = x;
+        this.y = y;
+        symbol.PositionSetzen(x - breite / 2, y);
+    }
+    
+    /**
+     * Verschiebt das Dreieck um die angegebenen Werte.
+     * @param deltaX Verschiebung in x-Richtung
+     * @param deltaY Verschiebung in y-Richtung
+     */
+    void Verschieben(int deltaX, int deltaY)
+    {
+        x += deltaX;
+        y += deltaY;
+        symbol.PositionSetzen(x - breite / 2, y);
+    }
+    
+    /**
+     * Dreht das Dreieck
+     * @param grad Drehwinkel (mathematisch positiver Drehsinn) im Gradmass
+     */
+    void Drehen(int grad)
+    {
+        winkel += grad;
+        symbol.WinkelSetzen(winkel);
+    }
+        
+    /**
+     * Setzt die Größe des Dreiecks.
+     * @param breite (neue) Breite
+     * @param höhe (neue) Höhe
+     */
+    void GrößeSetzen (int breite, int höhe)
+    {
+        this.breite = breite;
+        this.höhe = höhe;
+        symbol.GrößeSetzen(breite, höhe);
+        symbol.PositionSetzen(x - breite / 2, y);
+    }
+    
+    /**
+     * Setzt die Farbe des Dreiecks.
+     * Erlaubte Farben sind:
+     * "weiß", "weiss", "rot", "grün", "gruen", "blau", "gelb",
+     * "magenta", "cyan", "hellgelb", "hellgrün", "hellgruen",
+     * "orange", "braun", "grau", "schwarz"
+     * Alle anderen Eingaben werden auf die Farbe schwarz abgebildet.
+     * @param farbe (neue) Farbe
+     */
+    void FarbeSetzen (String farbe)
+    {
+        this.farbe = farbe;
+        symbol.FarbeSetzen(farbe);
+    }
+        
+    /**
+     * Setzt den Drehwinkel des Dreiecks.
+     * Die Winkelangabe ist in Grad,positive Werte drehen gegen den Uhrzeigersinn,
+     * negative Werte drehen im Uhrzeigersinn (mathematisch positiver Drehsinn).
+     * @param winkel der (neue) Drehwinkel des Dreiecks
+     */
+    void WinkelSetzen (int winkel)
+    {
+        this.winkel = winkel;
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Schaltet die Sichtbarkeit des Dreiecks ein oder aus.
+     * Erlaubte Parameterwerte: true, false
+     * @param sichtbar (neue) Sichtbarkeit des Dreiecks
+     */
+    void SichtbarkeitSetzen (boolean sichtbar)
+    {
+        this.sichtbar = sichtbar;
+        symbol.SichtbarkeitSetzen(sichtbar);
+    }
+        
+    /**
+     * Entfernt das Dreieck aus dem Zeichenfenster.
+     */
+    void Entfernen ()
+    {
+        symbol.Entfernen();
+    }
+    
+    /**
+     * Bringt das Dreieck eine Ebene nach vorn.
+     */
+    void NachVornBringen ()
+    {
+        symbol.NachVornBringen();
+    }
+    
+    /**
+     * Bringt das Dreieck in die vorderste Ebene.
+     */
+    void GanzNachVornBringen ()
+    {
+        symbol.GanzNachVornBringen();
+    }
+    
+    /**
+     * Bringt das Dreieck eine Ebene nach hinten.
+     */
+    void NachHintenBringen ()
+    {
+        symbol.NachHintenBringen();
+    }
+    
+    /**
+     * Bringt das Dreieck in die hinterste Ebene.
+     */
+    void GanzNachHintenBringen ()
+    {
+        symbol.GanzNachHintenBringen();
+    }
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Ereignisbehandlung.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Ereignisbehandlung.ctxt
new file mode 100644
index 00000000..f071cf37
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Ereignisbehandlung.ctxt
@@ -0,0 +1,36 @@
+#BlueJ class context
+comment0.target=Ereignisbehandlung
+comment0.text=\n\ Zugriff\ auf\ die\ Ereignisse\ einschlie\u00DFlich\ Taktgeber.\n\ \n\ @author\ Albert\ Wiedemann\n\ @version\ 1.0\n
+comment1.params=
+comment1.target=Ereignisbehandlung()
+comment1.text=\n\ Der\ Konstruktor\ meldet\ den\ Taktgeber\n\ und\ die\ Eventlistener\ bei\ der\ Zeichenfl\u00E4che\ an.\n
+comment10.params=taste
+comment10.target=void\ TasteGedr\u00FCckt(char)
+comment10.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ gedr\u00FCckte\ Tasten.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ taste\ die\ gedr\u00FCckte\ Taste\n
+comment11.params=taste
+comment11.target=void\ SonderTasteGedr\u00FCckt(int)
+comment11.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ gedr\u00FCckte\ Sondertasten.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ taste\ KeyCode\ der\ gedr\u00FCckten\ Taste\n
+comment12.params=x\ y\ anzahl
+comment12.target=void\ MausGeklickt(int,\ int,\ int)
+comment12.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ einen\ Mausklick.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ x\ x-Position\ des\ Mausklicks\n\ @param\ y\ y-Position\ des\ Mausklicks\n\ @param\ anzahl\ Anzahl\ der\ aufeinanderfolgenden\ Mausklicks\n
+comment2.params=
+comment2.target=void\ Ausf\u00FChren()
+comment3.params=taste
+comment3.target=void\ Taste(char)
+comment4.params=taste
+comment4.target=void\ SonderTaste(int)
+comment5.params=x\ y\ anzahl
+comment5.target=void\ Geklickt(int,\ int,\ int)
+comment6.params=
+comment6.target=void\ TaktImpulsAusf\u00FChren()
+comment6.text=\n\ Die\ eigentliche\ Aktionsmethode\ des\ Zeitgebers.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n
+comment7.params=
+comment7.target=void\ Starten()
+comment7.text=\n\ Zeitgeber\ starten.\n
+comment8.params=
+comment8.target=void\ Anhalten()
+comment8.text=\n\ Zeitgeber\ anhalten.\n
+comment9.params=dauer
+comment9.target=void\ TaktdauerSetzen(int)
+comment9.text=\n\ Ablaufgeschwindigkeit\ des\ Zeitgebers\ einstellen.\n\ \n\ @param\ dauer\:\ Angabe\ in\ Millisekunden\n
+numComments=13
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Ereignisbehandlung.java b/Info/10/2/Baelle/BlueJ_Projekt/Ereignisbehandlung.java
new file mode 100644
index 00000000..5f2ab844
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Ereignisbehandlung.java
@@ -0,0 +1,109 @@
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+
+/**
+ * Zugriff auf die Ereignisse einschließlich Taktgeber.
+ * 
+ * @author Albert Wiedemann
+ * @version 1.0
+ */
+public class Ereignisbehandlung
+{
+    /**
+     * Der Konstruktor meldet den Taktgeber
+     * und die Eventlistener bei der Zeichenfläche an.
+     */
+    Ereignisbehandlung ()
+    {
+        Zeichenfenster.AktionsEmpfängerEintragen(new Zeichenfenster.AktionsEmpfaenger()
+        {
+            public void Ausführen ()
+            {
+                TaktImpulsAusführen();
+            }
+            
+            public void Taste (char taste)
+            {
+                TasteGedrückt(taste);
+            }
+            
+            public void SonderTaste (int taste)
+            {
+                SonderTasteGedrückt(taste);
+            }
+            
+            public void Geklickt (int x, int y, int anzahl)
+            {
+                MausGeklickt(x, y, anzahl);
+            }
+        });
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode des Zeitgebers.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     */
+    void TaktImpulsAusführen ()
+    {
+        System.out.println ("Tick");
+    }
+
+    /**
+     * Zeitgeber starten.
+     */
+    void Starten ()
+    {
+        Zeichenfenster.TaktgeberStarten();
+    }
+
+    /**
+     * Zeitgeber anhalten.
+     */
+    void Anhalten ()
+    {
+        Zeichenfenster.TaktgeberStoppen();
+    }
+    
+    /**
+     * Ablaufgeschwindigkeit des Zeitgebers einstellen.
+     * 
+     * @param dauer: Angabe in Millisekunden
+     */
+    void TaktdauerSetzen (int dauer)
+    {
+        Zeichenfenster.TaktdauerSetzen(dauer);
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für gedrückte Tasten.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param taste die gedrückte Taste
+     */
+    void TasteGedrückt (char taste)
+    {
+        System. out. println ("Taste: " + taste);
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für gedrückte Sondertasten.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param taste KeyCode der gedrückten Taste
+     */
+    void SonderTasteGedrückt (int taste)
+    {
+        System. out. println ("Sondertaste: " + taste);
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für einen Mausklick.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param x x-Position des Mausklicks
+     * @param y y-Position des Mausklicks
+     * @param anzahl Anzahl der aufeinanderfolgenden Mausklicks
+     */
+    void MausGeklickt (int x, int y, int anzahl)
+    {
+        System. out. println ("Maus: (" + x + "|" + y + "), " + anzahl + " mal");
+    }
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Figur.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Figur.ctxt
new file mode 100644
index 00000000..a6543cc3
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Figur.ctxt
@@ -0,0 +1,93 @@
+#BlueJ class context
+comment0.target=Figur
+comment0.text=\n\ Wrapperklasse\ f\u00FCr\ die\ Turtle\ auf\ der\ Zeichenfl\u00E4che.\n\ \n\ @author\ Albert\ Wiedemann\ \n\ @version\ 1.0\n
+comment1.params=
+comment1.target=Figur()
+comment1.text=\n\ Konstruktor\ der\ Figur\n\ Erzeugt\ eine\ Figur\ und\ versetzt\ sie\ in\ einen\ g\u00FCltigen\ Startzustand.\n
+comment10.params=x\ y
+comment10.target=void\ PositionSetzen(int,\ int)
+comment10.text=\n\ Setzt\ die\ Position\ der\ Figur.\n\ @param\ x\ x-Position\ der\ Figur\n\ @param\ y\ y-Position\ der\ Figur\n
+comment11.params=gr\u00F6\u00DFe
+comment11.target=void\ Gr\u00F6\u00DFeSetzen(int)
+comment11.text=\n\ Setzt\ die\ Gr\u00F6\u00DFe\ des\ Figurensymbols.\n\ @param\ gr\u00F6\u00DFe\ (neue)\ Gr\u00F6\u00DFe\n
+comment12.params=winkel
+comment12.target=void\ WinkelSetzen(int)
+comment12.text=\n\ Setzt\ den\ Drehwinkel\ der\ Figur.\n\ Die\ Winkelangabe\ ist\ in\ Grad,\ positive\ Werte\ drehen\ gegen\ den\ Uhrzeigersinn,\n\ negative\ Werte\ drehen\ im\ Uhrzeigersinn\ (mathematisch\ positiver\ Drehsinn),\ d.\ h.\n\ 0\u02DA\:\ Figur\ schaut\ nach\ rechts,\n\ 90\u02DA\:\ Figur\ schaut\ nach\ oben,\n\ 180\u02DA\:\ Figur\ schaut\ nach\ links,\n\ 270\u02DAbzw.\ -90\u02DA\:\ Figur\ schaut\ nach\ unten\n\ @param\ winkel\ der\ (neue)\ Drehwinkel\ der\ Figur\n
+comment13.params=sichtbar
+comment13.target=void\ SichtbarkeitSetzen(boolean)
+comment13.text=\n\ Schaltet\ die\ Sichtbarkeit\ der\ Figur\ ein\ oder\ aus.\n\ Erlaubte\ Parameterwerte\:\ true,\ false\n\ @param\ sichtbar\ (neue)\ Sichtbarkeit\ der\ Figur\n
+comment14.params=
+comment14.target=void\ Entfernen()
+comment14.text=\n\ Entfernt\ die\ Figur\ aus\ dem\ Zeichenfenster.\n
+comment15.params=
+comment15.target=void\ NachVornBringen()
+comment15.text=\n\ Bringt\ die\ Figur\ eine\ Ebene\ nach\ vorn.\n
+comment16.params=
+comment16.target=void\ GanzNachVornBringen()
+comment16.text=\n\ Bringt\ die\ Figur\ in\ die\ vorderste\ Ebene.\n
+comment17.params=
+comment17.target=void\ NachHintenBringen()
+comment17.text=\n\ Bringt\ die\ Figur\ eine\ Ebene\ nach\ hinten.\n
+comment18.params=
+comment18.target=void\ GanzNachHintenBringen()
+comment18.text=\n\ Bringt\ die\ Figur\ in\ die\ hinterste\ Ebene.\n
+comment19.params=
+comment19.target=void\ ZumStartpunktGehen()
+comment19.text=\n\ Setzt\ die\ Figur\ wieder\ an\ ihre\ Ausgangsposition.\n
+comment2.params=
+comment2.target=void\ Ausf\u00FChren()
+comment20.params=l\u00E4nge
+comment20.target=void\ Gehen(double)
+comment20.text=\n\ Bewegt\ die\ Figur\ nach\ vorne.\n\ @param\ l\u00E4nge\ Anzahl\ der\ L\u00E4ngeneinheiten\n
+comment21.params=grad
+comment21.target=void\ Drehen(int)
+comment21.text=\n\ Dreht\ die\ Figur\n\ @param\ grad\ Drehwinkel\ (mathematisch\ positiver\ Drehsinn)\ im\ Gradma\u00DF\n
+comment22.params=
+comment22.target=int\ WinkelGeben()
+comment22.text=\n\ Gibt\ den\ aktuellen\ Winkel\ der\ Figur\ zur\u00FCck.\n\ Die\ Winkelangabe\ ist\ in\ Grad,\ positive\ Werte\ drehen\ gegen\ den\ Uhrzeigersinn,\n\ negative\ Werte\ drehen\ im\ Uhrzeigersinn\ (mathematisch\ positiver\ Drehsinn),\ d.\ h.\n\ 0\u02DA\:\ Figur\ schaut\ nach\ rechts,\n\ 90\u02DA\:\ Figur\ schaut\ nach\ oben,\n\ 180\u02DA\:\ Figur\ schaut\ nach\ links,\n\ 270\u02DAbzw.\ -90\u02DA\:\ Figur\ schaut\ nach\ unten\n\ @return\ Winkel\ im\ Gradma\u00DF\n
+comment23.params=
+comment23.target=int\ XPositionGeben()
+comment23.text=\n\ Gibt\ die\ x-Koordinate\ der\ Figur\ zur\u00FCck.\n\ @return\ x-Koordinate\n
+comment24.params=
+comment24.target=int\ YPositionGeben()
+comment24.text=\n\ Gibt\ die\ y-Koordinate\ der\ Figur\ zur\u00FCck.\n\ @return\ y-Koordinate\n
+comment25.params=
+comment25.target=boolean\ Ber\u00FChrt()
+comment25.text=\n\ Testet,\ ob\ die\ Figur\ eine\ Grafik-Figur\ ber\u00FChrt.\n\ @return\ true,\ wenn\ die\ Figur\ und\ eine\ Grafikfigur\ \u00FCberlappen\n
+comment26.params=farbe
+comment26.target=boolean\ Ber\u00FChrt(java.lang.String)
+comment26.text=\n\ Testet,\ ob\ die\ Figur\ eine\ Grafik-Figur\ in\ der\ angegebenen\ Farbe\ ber\u00FChrt.\n\ @param\ farbe\ die\ Farbe,\ die\ die\ ber\u00FChrte\ Figur\ haben\ muss\n\ @return\ true,\ wenn\ die\ Figur\ und\ eine\ Grafikfigur\ in\ der\ angegebenen\ Farbe\ \u00FCberlappen\n
+comment27.params=objekt
+comment27.target=boolean\ Ber\u00FChrt(java.lang.Object)
+comment27.text=\n\ Testet,\ ob\ die\ Figur\ die\ angegebene\ Figur\ ber\u00FChrt.\n\ @param\ objekt\ das\ Objekt,\ das\ getestet\ werden\ soll\n\ @return\ true,\ wenn\ die\ Figur\ die\ angegebene\ Grafikfigur\ \u00FCberlappen\n
+comment28.params=x\ y\ breite\ h\u00F6he\ farbe
+comment28.target=void\ FigurteilFestlegenRechteck(int,\ int,\ int,\ int,\ java.lang.String)
+comment28.text=\n\ Erzeugt\ ein\ neues,\ rechteckiges\ Element\ einer\ eigenen\ Darstellung\ der\ Figur.\n\ Alle\ Werte\ beziehen\ sich\ auf\ eine\ Figur\ der\ Gr\u00F6\u00DFe\ 100x100\ und\ den\ Koordinaten\ (0|0)\ in\ der\ Mitte\ des\ Quadrats\n\ @param\ x\ x-Wert\ der\ linken\ oberen\ Ecke\ des\ Rechtecks\n\ @param\ y\ y-Wert\ der\ linken\ oberen\ Ecke\ des\ Rechtecks\n\ @param\ breite\ Breite\ des\ Rechtecks\n\ @param\ h\u00F6he\ H\u00F6he\ des\ Rechtecks\n\ @param\ farbe\ (F\u00FCll-)Farbe\ des\ Rechtecks\n
+comment29.params=x\ y\ breite\ h\u00F6he\ farbe
+comment29.target=void\ FigurteilFestlegenEllipse(int,\ int,\ int,\ int,\ java.lang.String)
+comment29.text=\n\ Erzeugt\ ein\ neues,\ elliptisches\ Element\ einer\ eigenen\ Darstellung\ der\ Figur.\n\ Alle\ Werte\ beziehen\ sich\ auf\ eine\ Figur\ der\ Gr\u00F6\u00DFe\ 100x100\ und\ den\ Koordinaten\ (0|0)\ in\ der\ Mitte\ des\ Quadrats\n\ @param\ x\ x-Wert\ der\ linken\ oberen\ Ecke\ des\ umgebenden\ Rechtecks\ der\ Ellipse\n\ @param\ y\ y-Wert\ der\ linken\ oberen\ Ecke\ des\ umgebenden\ Rechtecks\ der\ Ellipse\n\ @param\ breite\ Breite\ des\ umgebenden\ Rechtecks\ der\ Ellipse\n\ @param\ h\u00F6he\ H\u00F6he\ des\ umgebenden\ Rechtecks\ der\ Ellipse\n\ @param\ farbe\ (F\u00FCll-)Farbe\ der\ Ellipse\n
+comment3.params=taste
+comment3.target=void\ Taste(char)
+comment30.params=x1\ y1\ x2\ y2\ x3\ y3\ farbe
+comment30.target=void\ FigurteilFestlegenDreieck(int,\ int,\ int,\ int,\ int,\ int,\ java.lang.String)
+comment30.text=\n\ Erzeugt\ ein\ neues,\ dreieckiges\ Element\ einer\ eigenen\ Darstellung\ der\ Figur.\n\ Alle\ Werte\ beziehen\ sich\ auf\ eine\ Figur\ der\ Gr\u00F6\u00DFe\ 100x100\ und\ den\ Koordinaten\ (0|0)\ in\ der\ Mitte\ des\ Quadrats\n\ @param\ x1\ x-Wert\ des\ ersten\ Punkts\ des\ Dreiecks\n\ @param\ y1\ y-Wert\ des\ ersten\ Punkts\ des\ Dreiecks\n\ @param\ x2\ x-Wert\ des\ zweiten\ Punkts\ des\ Dreiecks\n\ @param\ y2\ y-Wert\ des\ zweiten\ Punkts\ des\ Dreiecks\n\ @param\ x3\ x-Wert\ des\ dritten\ Punkts\ des\ Dreiecks\n\ @param\ y3\ y-Wert\ des\ dritten\ Punkts\ des\ Dreiecks\n\ @param\ farbe\ (F\u00FCll)Farbe\ des\ Dreiecks\n
+comment31.params=
+comment31.target=void\ EigeneFigurL\u00F6schen()
+comment31.text=\n\ L\u00F6scht\ die\ Vereinbarung\ f\u00FCr\ die\ eigene\ Darstellung\ der\ Figur.\n\ Die\ Figur\ wird\ wieder\ durch\ die\ Originalfigur\ dargestellt.\n
+comment4.params=taste
+comment4.target=void\ SonderTaste(int)
+comment5.params=x\ y\ anzahl
+comment5.target=void\ Geklickt(int,\ int,\ int)
+comment6.params=
+comment6.target=void\ AktionAusf\u00FChren()
+comment6.text=\n\ Methode\ wird\ aufgerufen,\ wenn\ die\ Figur\ handeln\ soll.\n\ Die\ vordefinierte\ Methode\ tut\ nichts.\n
+comment7.params=taste
+comment7.target=void\ TasteGedr\u00FCckt(char)
+comment7.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ gedr\u00FCckte\ Tasten.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ taste\ die\ gedr\u00FCckte\ Taste\n
+comment8.params=taste
+comment8.target=void\ SonderTasteGedr\u00FCckt(int)
+comment8.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ gedr\u00FCckte\ Sondertasten.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ taste\ KeyCode\ der\ gedr\u00FCckten\ Taste\n
+comment9.params=x\ y\ anzahl
+comment9.target=void\ MausGeklickt(int,\ int,\ int)
+comment9.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ einen\ Mausklick.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ x\ x-Position\ des\ Mausklicks\n\ @param\ y\ y-Position\ des\ Mausklicks\n\ @param\ anzahl\ Anzahl\ der\ aufeinanderfolgenden\ Mausklicks\n
+numComments=32
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Figur.java b/Info/10/2/Baelle/BlueJ_Projekt/Figur.java
new file mode 100644
index 00000000..ca38c584
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Figur.java
@@ -0,0 +1,340 @@
+/**
+ * Wrapperklasse für die Turtle auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Figur
+{
+    /** x-Position der Figur. */
+    private int x;
+    /** y-Position der Figur. */
+    private int y;
+    /** Größe der Figur. */
+    private int größe;
+    /** Farbe der Figur. */
+    private String farbe;
+    /** Sichtbarkeit der Figur. */
+    private boolean sichtbar;
+    /** Drehwinkel (mathemtisch positiver Drehsinn) der Turtle in Grad. */
+    private int winkel;
+    /** Referenz auf das echte Figursymbol. */
+    Zeichenfenster.FigurIntern symbol;
+    /** Referenz auf das Aktionsempfängerobjekt. */
+    Zeichenfenster.AktionsEmpfaenger aktionsEmpfänger;
+    
+    /**
+     * Konstruktor der Figur
+     * Erzeugt eine Figur und versetzt sie in einen gültigen Startzustand.
+     */
+    Figur ()
+    {
+        symbol = (Zeichenfenster.FigurIntern) Zeichenfenster.SymbolErzeugen(Zeichenfenster.SymbolArt.figur);
+        symbol.SichtbarkeitSetzen(true);
+        x = symbol.x;
+        y = symbol.y;
+        winkel = symbol.winkel;
+        größe = symbol.b;
+        sichtbar = symbol.sichtbar;
+        aktionsEmpfänger = new Zeichenfenster.AktionsEmpfaenger()
+        {
+            public void Ausführen ()
+            {
+                AktionAusführen();
+            }
+            
+            public void Taste (char taste)
+            {
+                TasteGedrückt(taste);
+            }
+            
+            public void SonderTaste (int taste)
+            {
+                SonderTasteGedrückt(taste);
+            }
+            
+            public void Geklickt (int x, int y, int anzahl)
+            {
+                MausGeklickt(x, y, anzahl);
+            }
+        };
+        Zeichenfenster.AktionsEmpfängerEintragen(aktionsEmpfänger);
+    }
+    
+    /**
+     * Methode wird aufgerufen, wenn die Figur handeln soll.
+     * Die vordefinierte Methode tut nichts.
+     */
+    void AktionAusführen()
+    {
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für gedrückte Tasten.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param taste die gedrückte Taste
+     */
+    void TasteGedrückt (char taste)
+    {
+        //System. out. println ("Taste: " + taste);
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für gedrückte Sondertasten.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param taste KeyCode der gedrückten Taste
+     */
+    void SonderTasteGedrückt (int taste)
+    {
+        //System. out. println ("Sondertaste: " + taste);
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für einen Mausklick.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param x x-Position des Mausklicks
+     * @param y y-Position des Mausklicks
+     * @param anzahl Anzahl der aufeinanderfolgenden Mausklicks
+     */
+    void MausGeklickt (int x, int y, int anzahl)
+    {
+        //System. out. println ("Maus: (" + x + "|" + y + "), " + anzahl + " mal");
+    }
+    
+    /**
+     * Setzt die Position der Figur.
+     * @param x x-Position der Figur
+     * @param y y-Position der Figur
+     */
+    void PositionSetzen(int x, int y)
+    {
+        this.x = x;
+        this.y = y;
+        symbol.PositionSetzen(x, y);
+    }
+        
+    /**
+     * Setzt die Größe des Figurensymbols.
+     * @param größe (neue) Größe
+     */
+    void GrößeSetzen (int größe)
+    {
+        this.größe = größe;
+        symbol.GrößeSetzen(größe, größe);
+    }
+        
+    /**
+     * Setzt den Drehwinkel der Figur.
+     * Die Winkelangabe ist in Grad, positive Werte drehen gegen den Uhrzeigersinn,
+     * negative Werte drehen im Uhrzeigersinn (mathematisch positiver Drehsinn), d. h.
+     * 0˚: Figur schaut nach rechts,
+     * 90˚: Figur schaut nach oben,
+     * 180˚: Figur schaut nach links,
+     * 270˚bzw. -90˚: Figur schaut nach unten
+     * @param winkel der (neue) Drehwinkel der Figur
+     */
+    void WinkelSetzen (int winkel)
+    {
+        this.winkel = winkel;
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Schaltet die Sichtbarkeit der Figur ein oder aus.
+     * Erlaubte Parameterwerte: true, false
+     * @param sichtbar (neue) Sichtbarkeit der Figur
+     */
+    void SichtbarkeitSetzen (boolean sichtbar)
+    {
+        this.sichtbar = sichtbar;
+        symbol.SichtbarkeitSetzen(sichtbar);
+    }
+        
+    /**
+     * Entfernt die Figur aus dem Zeichenfenster.
+     */
+    void Entfernen ()
+    {
+        Zeichenfenster.AktionsEmpfängerEntfernen(aktionsEmpfänger);
+        symbol.Entfernen();
+    }
+    
+    /**
+     * Bringt die Figur eine Ebene nach vorn.
+     */
+    void NachVornBringen ()
+    {
+        symbol.NachVornBringen();
+    }
+    
+    /**
+     * Bringt die Figur in die vorderste Ebene.
+     */
+    void GanzNachVornBringen ()
+    {
+        symbol.GanzNachVornBringen();
+    }
+    
+    /**
+     * Bringt die Figur eine Ebene nach hinten.
+     */
+    void NachHintenBringen ()
+    {
+        symbol.NachHintenBringen();
+    }
+    
+    /**
+     * Bringt die Figur in die hinterste Ebene.
+     */
+    void GanzNachHintenBringen ()
+    {
+        symbol.GanzNachHintenBringen();
+    }
+
+    /**
+     * Setzt die Figur wieder an ihre Ausgangsposition.
+     */
+    void ZumStartpunktGehen()
+    {
+        symbol.ZumStartpunktGehen();
+        x = symbol.x;
+        y = symbol.y;
+        winkel = symbol.winkel;
+    }
+
+    /**
+     * Bewegt die Figur nach vorne.
+     * @param länge Anzahl der Längeneinheiten
+     */
+    void Gehen(double länge)
+    {
+        symbol.Gehen(länge);
+        x = symbol.x;
+        y = symbol.y;
+    }
+    
+    /**
+     * Dreht die Figur
+     * @param grad Drehwinkel (mathematisch positiver Drehsinn) im Gradmaß
+     */
+    void Drehen(int grad)
+    {
+        symbol.Drehen(grad);
+        winkel = symbol.winkel;
+    }
+
+    /**
+     * Gibt den aktuellen Winkel der Figur zurück.
+     * Die Winkelangabe ist in Grad, positive Werte drehen gegen den Uhrzeigersinn,
+     * negative Werte drehen im Uhrzeigersinn (mathematisch positiver Drehsinn), d. h.
+     * 0˚: Figur schaut nach rechts,
+     * 90˚: Figur schaut nach oben,
+     * 180˚: Figur schaut nach links,
+     * 270˚bzw. -90˚: Figur schaut nach unten
+     * @return Winkel im Gradmaß
+     */
+    int WinkelGeben()
+    {
+        return winkel;
+    }
+
+    /**
+     * Gibt die x-Koordinate der Figur zurück.
+     * @return x-Koordinate
+     */
+    int XPositionGeben()
+    {
+        return x;
+    }
+    
+    /**
+     * Gibt die y-Koordinate der Figur zurück.
+     * @return y-Koordinate
+     */ 
+    int YPositionGeben()
+    {
+        return y;
+    }
+    
+    /**
+     * Testet, ob die Figur eine Grafik-Figur berührt.
+     * @return true, wenn die Figur und eine Grafikfigur überlappen
+     */
+    boolean Berührt ()
+    {
+        return symbol.Berührt();
+    }
+    
+    /**
+     * Testet, ob die Figur eine Grafik-Figur in der angegebenen Farbe berührt.
+     * @param farbe die Farbe, die die berührte Figur haben muss
+     * @return true, wenn die Figur und eine Grafikfigur in der angegebenen Farbe überlappen
+     */
+    boolean Berührt (String farbe)
+    {
+        return symbol.Berührt(farbe);
+    }
+
+    /**
+     * Testet, ob die Figur die angegebene Figur berührt.
+     * @param objekt das Objekt, das getestet werden soll
+     * @return true, wenn die Figur die angegebene Grafikfigur überlappen
+     */
+    boolean Berührt (Object objekt)
+    {
+        return symbol.Berührt(objekt);
+    }
+
+    /**
+     * Erzeugt ein neues, rechteckiges Element einer eigenen Darstellung der Figur.
+     * Alle Werte beziehen sich auf eine Figur der Größe 100x100 und den Koordinaten (0|0) in der Mitte des Quadrats
+     * @param x x-Wert der linken oberen Ecke des Rechtecks
+     * @param y y-Wert der linken oberen Ecke des Rechtecks
+     * @param breite Breite des Rechtecks
+     * @param höhe Höhe des Rechtecks
+     * @param farbe (Füll-)Farbe des Rechtecks
+     */
+    void FigurteilFestlegenRechteck (int x, int y, int breite, int höhe, String farbe)
+    {
+        symbol.FigurteilFestlegenRechteck(x, y, breite, höhe, farbe);
+    }
+
+    /**
+     * Erzeugt ein neues, elliptisches Element einer eigenen Darstellung der Figur.
+     * Alle Werte beziehen sich auf eine Figur der Größe 100x100 und den Koordinaten (0|0) in der Mitte des Quadrats
+     * @param x x-Wert der linken oberen Ecke des umgebenden Rechtecks der Ellipse
+     * @param y y-Wert der linken oberen Ecke des umgebenden Rechtecks der Ellipse
+     * @param breite Breite des umgebenden Rechtecks der Ellipse
+     * @param höhe Höhe des umgebenden Rechtecks der Ellipse
+     * @param farbe (Füll-)Farbe der Ellipse
+     */
+    void FigurteilFestlegenEllipse (int x, int y, int breite, int höhe, String farbe)
+    {
+        symbol.FigurteilFestlegenEllipse(x, y, breite, höhe, farbe);
+    }
+
+    /**
+     * Erzeugt ein neues, dreieckiges Element einer eigenen Darstellung der Figur.
+     * Alle Werte beziehen sich auf eine Figur der Größe 100x100 und den Koordinaten (0|0) in der Mitte des Quadrats
+     * @param x1 x-Wert des ersten Punkts des Dreiecks
+     * @param y1 y-Wert des ersten Punkts des Dreiecks
+     * @param x2 x-Wert des zweiten Punkts des Dreiecks
+     * @param y2 y-Wert des zweiten Punkts des Dreiecks
+     * @param x3 x-Wert des dritten Punkts des Dreiecks
+     * @param y3 y-Wert des dritten Punkts des Dreiecks
+     * @param farbe (Füll)Farbe des Dreiecks
+     */
+    void FigurteilFestlegenDreieck (int x1, int y1, int x2, int y2, int x3, int y3, String farbe)
+    {
+        symbol.FigurteilFestlegenDreieck(x1, y1, x2, y2, x3, y3, farbe);
+    }
+        
+    /**
+     * Löscht die Vereinbarung für die eigene Darstellung der Figur.
+     * Die Figur wird wieder durch die Originalfigur dargestellt.
+     */
+    void EigeneFigurLöschen()
+    {
+        symbol.EigeneFigurLöschen();
+    }
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Flummi.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Flummi.ctxt
new file mode 100644
index 00000000..ed7cd2c2
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Flummi.ctxt
@@ -0,0 +1,15 @@
+#BlueJ class context
+comment0.target=Flummi
+comment1.params=neuerBounceFaktor
+comment1.target=Flummi(double)
+comment2.params=x\ y\ neuerBounceFaktor
+comment2.target=Flummi(int,\ int,\ double)
+comment3.params=
+comment3.target=void\ Ausf\u00FChren()
+comment4.params=sondertaste
+comment4.target=void\ SonderTaste(int)
+comment5.params=taste
+comment5.target=void\ Taste(char)
+comment6.params=x\ y\ anzahl
+comment6.target=void\ Geklickt(int,\ int,\ int)
+numComments=7
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Flummi.java b/Info/10/2/Baelle/BlueJ_Projekt/Flummi.java
new file mode 100644
index 00000000..7ee870aa
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Flummi.java
@@ -0,0 +1,36 @@
+public class Flummi extends Ball {
+    double bounceFaktor;
+
+    public Flummi(double neuerBounceFaktor) {
+        super();
+        bounceFaktor = neuerBounceFaktor;
+        super.RadiusSetzen(20);
+        super.FarbeSetzen("gruen");
+    }
+    
+    public Flummi(int x, int y, double neuerBounceFaktor) {
+        super(x, y);
+        bounceFaktor = neuerBounceFaktor;
+        super.RadiusSetzen(20);
+        super.FarbeSetzen("gruen");
+    }
+    
+    public void Ausführen() {
+        // Der Flummi liegt
+        if (y == 600-radius && geschwindigkeit > 0) {
+            return;
+        }
+        // Der Flummi faellt
+        geschwindigkeit += BESCHLEUNIGUNG; // Beschleunigung
+        int ny = y + (int)geschwindigkeit;
+        if (ny >= 600-radius) { // Der Flummi ist aufgeschlagen
+            ny = 600-radius;
+            geschwindigkeit = -1 * bounceFaktor * geschwindigkeit;
+        }
+
+        super.PositionSetzen(x, ny);
+    }
+    public void SonderTaste(int sondertaste) {}
+    public void Taste(char taste) {}
+    public void Geklickt(int x, int y , int anzahl) {}
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Kreis.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Kreis.ctxt
new file mode 100644
index 00000000..24b34c85
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Kreis.ctxt
@@ -0,0 +1,43 @@
+#BlueJ class context
+comment0.target=Kreis
+comment0.text=\n\ Wrapperklasse\ f\u00FCr\ einen\ Kreis\ auf\ der\ Zeichenfl\u00E4che.\n\ \n\ @author\ Albert\ Wiedemann\ \n\ @version\ 1.0\n
+comment1.params=
+comment1.target=Kreis()
+comment1.text=\n\ Der\ Konstruktor\ erzeugt\ das\ Delegate-Objekt\n
+comment10.params=
+comment10.target=void\ NachVornBringen()
+comment10.text=\n\ Bringt\ den\ Kreis\ eine\ Ebene\ nach\ vorn.\n
+comment11.params=
+comment11.target=void\ GanzNachVornBringen()
+comment11.text=\n\ Bringt\ den\ Kreis\ in\ die\ vorderste\ Ebene.\n
+comment12.params=
+comment12.target=void\ NachHintenBringen()
+comment12.text=\n\ Bringt\ den\ Kreis\ eine\ Ebene\ nach\ hinten.\n
+comment13.params=
+comment13.target=void\ GanzNachHintenBringen()
+comment13.text=\n\ Bringt\ den\ Kreis\ in\ die\ hinterste\ Ebene.\n
+comment2.params=x\ y
+comment2.target=void\ PositionSetzen(int,\ int)
+comment2.text=\n\ Setzt\ die\ Position\ (des\ Mittelpunkts)\ des\ Kreises.\n\ @param\ x\ x-Position\ des\ Mittelpunkts\n\ @param\ y\ y-Position\ des\ Mittelpunkts\n
+comment3.params=deltaX\ deltaY
+comment3.target=void\ Verschieben(int,\ int)
+comment3.text=\n\ Verschiebt\ den\ Kreis\ um\ die\ angegebenen\ Werte.\n\ @param\ deltaX\ Verschiebung\ in\ x-Richtung\n\ @param\ deltaY\ Verschiebung\ in\ y-Richtung\n
+comment4.params=grad
+comment4.target=void\ Drehen(int)
+comment4.text=\n\ Dreht\ den\ Kreis\n\ @param\ grad\ Drehwinkel\ (mathematisch\ positiver\ Drehsinn)\ im\ Gradmass\n
+comment5.params=radius
+comment5.target=void\ RadiusSetzen(int)
+comment5.text=\n\ Setzt\ den\ Radius\ des\ Kreises.\n\ @param\ radius\ (neuer)\ Radius\n
+comment6.params=farbe
+comment6.target=void\ FarbeSetzen(java.lang.String)
+comment6.text=\n\ Setzt\ die\ Farbe\ des\ Kreises.\n\ Erlaubte\ Farben\ sind\:\n\ "wei\u00DF",\ "weiss",\ "rot",\ "gr\u00FCn",\ "gruen",\ "blau",\ "gelb",\n\ "magenta",\ "cyan",\ "hellgelb",\ "hellgr\u00FCn",\ "hellgruen",\n\ "orange",\ "braun",\ "grau",\ "schwarz"\n\ Alle\ anderen\ Eingaben\ werden\ auf\ die\ Farbe\ schwarz\ abgebildet.\n\ @param\ farbe\ (neue)\ Farbe\n
+comment7.params=winkel
+comment7.target=void\ WinkelSetzen(int)
+comment7.text=\n\ Setzt\ den\ Drehwinkel\ des\ Kreises.\n\ Die\ Winkelangabe\ ist\ in\ Grad,positive\ Werte\ drehen\ gegen\ den\ Uhrzeigersinn,\n\ negative\ Werte\ drehen\ im\ Uhrzeigersinn\ (mathematisch\ positiver\ Drehsinn).\n\ @param\ winkel\ der\ (neue)\ Drehwinkel\ des\ Kreises\n
+comment8.params=sichtbar
+comment8.target=void\ SichtbarkeitSetzen(boolean)
+comment8.text=\n\ Schaltet\ die\ Sichtbarkeit\ des\ Kreises\ ein\ oder\ aus.\n\ Erlaubte\ Parameterwerte\:\ true,\ false\n\ @param\ sichtbar\ (neue)\ Sichtbarkeit\ des\ Kreises\n
+comment9.params=
+comment9.target=void\ Entfernen()
+comment9.text=\n\ Entfernt\ den\ Kreis\ aus\ dem\ Zeichenfenster.\n
+numComments=14
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Kreis.java b/Info/10/2/Baelle/BlueJ_Projekt/Kreis.java
new file mode 100644
index 00000000..8d7820ff
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Kreis.java
@@ -0,0 +1,165 @@
+/**
+ * Wrapperklasse für einen Kreis auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Kreis
+{
+    /** x-Position des Kreismittelpunktes. */
+    protected int x;
+    /** y-Position des Kreismittelpunktes. */
+    protected int y;
+    /** Radius des Kreises. */
+    protected int radius;
+    /** Farbe des Kreises. */
+    protected String farbe;
+    /** Sichtbarkeit des Kreises. */
+    protected boolean sichtbar;
+    /** Drehwinkel (mathematisch positiver Drehsinn) des Kreises in Grad. */
+    protected int winkel;
+    /** Referenz auf das Delegate-Objekt. */
+    Zeichenfenster.GrafikSymbol symbol;
+
+    /**
+     * Der Konstruktor erzeugt das Delegate-Objekt
+     */
+    Kreis ()
+    {
+        x = 60;
+        y = 60;
+        radius = 50;
+        farbe = "rot";
+        sichtbar = true;
+        winkel = 0;
+        symbol = Zeichenfenster.SymbolErzeugen(Zeichenfenster.SymbolArt.kreis);
+        symbol.PositionSetzen(x - radius, y - radius);
+        symbol.GrößeSetzen(radius * 2, radius * 2);
+        symbol.FarbeSetzen(farbe);
+        symbol.SichtbarkeitSetzen(sichtbar);
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Setzt die Position (des Mittelpunkts) des Kreises.
+     * @param x x-Position des Mittelpunkts
+     * @param y y-Position des Mittelpunkts
+     */
+    void PositionSetzen(int x, int y)
+    {
+        this.x = x;
+        this.y = y;
+        symbol.PositionSetzen(x - radius, y - radius);
+    }
+    
+    /**
+     * Verschiebt den Kreis um die angegebenen Werte.
+     * @param deltaX Verschiebung in x-Richtung
+     * @param deltaY Verschiebung in y-Richtung
+     */
+    void Verschieben(int deltaX, int deltaY)
+    {
+        x += deltaX;
+        y += deltaY;
+        symbol.PositionSetzen(x - radius, y - radius);
+    }
+    
+    /**
+     * Dreht den Kreis
+     * @param grad Drehwinkel (mathematisch positiver Drehsinn) im Gradmass
+     */
+    void Drehen(int grad)
+    {
+        winkel += grad;
+        symbol.WinkelSetzen(winkel);
+    }
+        
+    /**
+     * Setzt den Radius des Kreises.
+     * @param radius (neuer) Radius
+     */
+    void RadiusSetzen (int radius)
+    {
+        this.radius = radius;
+        symbol.GrößeSetzen(radius * 2, radius * 2);
+        symbol.PositionSetzen(x - radius, y - radius);
+    }
+    
+    /**
+     * Setzt die Farbe des Kreises.
+     * Erlaubte Farben sind:
+     * "weiß", "weiss", "rot", "grün", "gruen", "blau", "gelb",
+     * "magenta", "cyan", "hellgelb", "hellgrün", "hellgruen",
+     * "orange", "braun", "grau", "schwarz"
+     * Alle anderen Eingaben werden auf die Farbe schwarz abgebildet.
+     * @param farbe (neue) Farbe
+     */
+    void FarbeSetzen (String farbe)
+    {
+        this.farbe = farbe;
+        symbol.FarbeSetzen(farbe);
+    }
+        
+    /**
+     * Setzt den Drehwinkel des Kreises.
+     * Die Winkelangabe ist in Grad,positive Werte drehen gegen den Uhrzeigersinn,
+     * negative Werte drehen im Uhrzeigersinn (mathematisch positiver Drehsinn).
+     * @param winkel der (neue) Drehwinkel des Kreises
+     */
+    void WinkelSetzen (int winkel)
+    {
+        this.winkel = winkel;
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Schaltet die Sichtbarkeit des Kreises ein oder aus.
+     * Erlaubte Parameterwerte: true, false
+     * @param sichtbar (neue) Sichtbarkeit des Kreises
+     */
+    void SichtbarkeitSetzen (boolean sichtbar)
+    {
+        this.sichtbar = sichtbar;
+        symbol.SichtbarkeitSetzen(sichtbar);
+    }
+        
+    /**
+     * Entfernt den Kreis aus dem Zeichenfenster.
+     */
+    void Entfernen ()
+    {
+        symbol.Entfernen();
+    }
+    
+    /**
+     * Bringt den Kreis eine Ebene nach vorn.
+     */
+    void NachVornBringen ()
+    {
+        symbol.NachVornBringen();
+    }
+    
+    /**
+     * Bringt den Kreis in die vorderste Ebene.
+     */
+    void GanzNachVornBringen ()
+    {
+        symbol.GanzNachVornBringen();
+    }
+    
+    /**
+     * Bringt den Kreis eine Ebene nach hinten.
+     */
+    void NachHintenBringen ()
+    {
+        symbol.NachHintenBringen();
+    }
+    
+    /**
+     * Bringt den Kreis in die hinterste Ebene.
+     */
+    void GanzNachHintenBringen ()
+    {
+        symbol.GanzNachHintenBringen();
+    }
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Rechteck.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Rechteck.ctxt
new file mode 100644
index 00000000..919a4661
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Rechteck.ctxt
@@ -0,0 +1,43 @@
+#BlueJ class context
+comment0.target=Rechteck
+comment0.text=\n\ Wrapperklasse\ f\u00FCr\ ein\ Rechteck\ auf\ der\ Zeichenfl\u00E4che.\n\ \n\ @author\ Albert\ Wiedemann\ \n\ @version\ 1.0\n
+comment1.params=
+comment1.target=Rechteck()
+comment1.text=\n\ Der\ Konstruktor\ erzeugt\ das\ Delegate-Objekt\n
+comment10.params=
+comment10.target=void\ NachVornBringen()
+comment10.text=\n\ Bringt\ das\ Rechteck\ eine\ Ebene\ nach\ vorn.\n
+comment11.params=
+comment11.target=void\ GanzNachVornBringen()
+comment11.text=\n\ Bringt\ das\ Rechteck\ in\ die\ vorderste\ Ebene.\n
+comment12.params=
+comment12.target=void\ NachHintenBringen()
+comment12.text=\n\ Bringt\ das\ Rechteck\ eine\ Ebene\ nach\ hinten.\n
+comment13.params=
+comment13.target=void\ GanzNachHintenBringen()
+comment13.text=\n\ Bringt\ das\ Rechteck\ in\ die\ hinterste\ Ebene.\n
+comment2.params=x\ y
+comment2.target=void\ PositionSetzen(int,\ int)
+comment2.text=\n\ Setzt\ die\ Position\ (der\ linken\ oberen\ Ecke)\ des\ Rechtecks.\n\ @param\ x\ x-Position\ der\ linken\ oberen\ Ecke\n\ @param\ y\ y-Position\ der\ linken\ oberen\ Ecke\n
+comment3.params=deltaX\ deltaY
+comment3.target=void\ Verschieben(int,\ int)
+comment3.text=\n\ Verschiebt\ das\ Rechteck\ um\ die\ angegebenen\ Werte.\n\ @param\ deltaX\ Verschiebung\ in\ x-Richtung\n\ @param\ deltaY\ Verschiebung\ in\ y-Richtung\n
+comment4.params=grad
+comment4.target=void\ Drehen(int)
+comment4.text=\n\ Dreht\ das\ Rechteck\n\ @param\ grad\ Drehwinkel\ (mathematisch\ positiver\ Drehsinn)\ im\ Gradmass\n
+comment5.params=breite\ h\u00F6he
+comment5.target=void\ Gr\u00F6\u00DFeSetzen(int,\ int)
+comment5.text=\n\ Setzt\ die\ Gr\u00F6\u00DFe\ des\ Rechtecks.\n\ @param\ breite\ (neue)\ Breite\n\ @param\ h\u00F6he\ (neue)\ H\u00F6he\n
+comment6.params=farbe
+comment6.target=void\ FarbeSetzen(java.lang.String)
+comment6.text=\n\ Setzt\ die\ Farbe\ des\ Rechtecks.\n\ Erlaubte\ Farben\ sind\:\n\ "wei\u00DF",\ "weiss",\ "rot",\ "gr\u00FCn",\ "gruen",\ "blau",\ "gelb",\n\ "magenta",\ "cyan",\ "hellgelb",\ "hellgr\u00FCn",\ "hellgruen",\n\ "orange",\ "braun",\ "grau",\ "schwarz"\n\ Alle\ anderen\ Eingaben\ werden\ auf\ die\ Farbe\ schwarz\ abgebildet.\n\ @param\ farbe\ (neue)\ Farbe\n
+comment7.params=winkel
+comment7.target=void\ WinkelSetzen(int)
+comment7.text=\n\ Setzt\ den\ Drehwinkel\ des\ Rechtecks.\n\ Die\ Winkelangabe\ ist\ in\ Grad,positive\ Werte\ drehen\ gegen\ den\ Uhrzeigersinn,\n\ negative\ Werte\ drehen\ im\ Uhrzeigersinn\ (mathematisch\ positiver\ Drehsinn).\n\ @param\ winkel\ der\ (neue)\ Drehwinkel\ des\ Rechtecks\n
+comment8.params=sichtbar
+comment8.target=void\ SichtbarkeitSetzen(boolean)
+comment8.text=\n\ Schaltet\ die\ Sichtbarkeit\ des\ Rechtecks\ ein\ oder\ aus.\n\ Erlaubte\ Parameterwerte\:\ true,\ false\n\ @param\ sichtbar\ (neue)\ Sichtbarkeit\ des\ Rechtecks\n
+comment9.params=
+comment9.target=void\ Entfernen()
+comment9.text=\n\ Entfernt\ das\ Rechteck\ aus\ dem\ Zeichenfenster.\n
+numComments=14
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Rechteck.java b/Info/10/2/Baelle/BlueJ_Projekt/Rechteck.java
new file mode 100644
index 00000000..e9f34b04
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Rechteck.java
@@ -0,0 +1,169 @@
+/**
+ * Wrapperklasse für ein Rechteck auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Rechteck
+{
+    /** x-Position der linken oberen Ecke. */
+    protected int x;
+    /** y-Position der linken oberen Ecke. */
+    protected int y;
+    /** Breite des Rechtecks. */
+    protected int breite;
+    /** Höhe des Rechtecks. */
+    protected int höhe;
+    /** Farbe des Rechtecks. */
+    protected String farbe;
+    /** Sichtbarkeit des Rechtecks. */
+    protected boolean sichtbar;
+    /** Drehwinkel (mathematisch positiver Drehsinn) des Rechtecks in Grad. */
+    protected int winkel;
+    /** Referenz auf das Delegate-Objekt. */
+    Zeichenfenster.GrafikSymbol symbol;
+
+    /**
+     * Der Konstruktor erzeugt das Delegate-Objekt
+     */
+    Rechteck ()
+    {
+        x = 10;
+        y = 10;
+        breite = 100;
+        höhe = 100;
+        farbe = "rot";
+        sichtbar = true;
+        winkel = 0;
+        symbol = Zeichenfenster.SymbolErzeugen(Zeichenfenster.SymbolArt.rechteck);
+        symbol.PositionSetzen(x, y);
+        symbol.GrößeSetzen(breite, höhe);
+        symbol.FarbeSetzen(farbe);
+        symbol.SichtbarkeitSetzen(sichtbar);
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Setzt die Position (der linken oberen Ecke) des Rechtecks.
+     * @param x x-Position der linken oberen Ecke
+     * @param y y-Position der linken oberen Ecke
+     */
+    void PositionSetzen(int x, int y)
+    {
+        this.x = x;
+        this.y = y;
+        symbol.PositionSetzen(x, y);
+    }
+    
+    /**
+     * Verschiebt das Rechteck um die angegebenen Werte.
+     * @param deltaX Verschiebung in x-Richtung
+     * @param deltaY Verschiebung in y-Richtung
+     */
+    void Verschieben(int deltaX, int deltaY)
+    {
+        x += deltaX;
+        y += deltaY;
+        symbol.PositionSetzen(x, y);
+    }
+    
+    /**
+     * Dreht das Rechteck
+     * @param grad Drehwinkel (mathematisch positiver Drehsinn) im Gradmass
+     */
+    void Drehen(int grad)
+    {
+        winkel += grad;
+        symbol.WinkelSetzen(winkel);
+    }
+        
+    /**
+     * Setzt die Größe des Rechtecks.
+     * @param breite (neue) Breite
+     * @param höhe (neue) Höhe
+     */
+    void GrößeSetzen (int breite, int höhe)
+    {
+        this.breite = breite;
+        this.höhe = höhe;
+        symbol.GrößeSetzen(breite, höhe);
+    }
+    
+    /**
+     * Setzt die Farbe des Rechtecks.
+     * Erlaubte Farben sind:
+     * "weiß", "weiss", "rot", "grün", "gruen", "blau", "gelb",
+     * "magenta", "cyan", "hellgelb", "hellgrün", "hellgruen",
+     * "orange", "braun", "grau", "schwarz"
+     * Alle anderen Eingaben werden auf die Farbe schwarz abgebildet.
+     * @param farbe (neue) Farbe
+     */
+    void FarbeSetzen (String farbe)
+    {
+        this.farbe = farbe;
+        symbol.FarbeSetzen(farbe);
+    }
+        
+    /**
+     * Setzt den Drehwinkel des Rechtecks.
+     * Die Winkelangabe ist in Grad,positive Werte drehen gegen den Uhrzeigersinn,
+     * negative Werte drehen im Uhrzeigersinn (mathematisch positiver Drehsinn).
+     * @param winkel der (neue) Drehwinkel des Rechtecks
+     */
+    void WinkelSetzen (int winkel)
+    {
+        this.winkel = winkel;
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Schaltet die Sichtbarkeit des Rechtecks ein oder aus.
+     * Erlaubte Parameterwerte: true, false
+     * @param sichtbar (neue) Sichtbarkeit des Rechtecks
+     */
+    void SichtbarkeitSetzen (boolean sichtbar)
+    {
+        this.sichtbar = sichtbar;
+        symbol.SichtbarkeitSetzen(sichtbar);
+    }
+        
+    /**
+     * Entfernt das Rechteck aus dem Zeichenfenster.
+     */
+    void Entfernen ()
+    {
+        symbol.Entfernen();
+    }
+    
+    /**
+     * Bringt das Rechteck eine Ebene nach vorn.
+     */
+    void NachVornBringen ()
+    {
+        symbol.NachVornBringen();
+    }
+    
+    /**
+     * Bringt das Rechteck in die vorderste Ebene.
+     */
+    void GanzNachVornBringen ()
+    {
+        symbol.GanzNachVornBringen();
+    }
+    
+    /**
+     * Bringt das Rechteck eine Ebene nach hinten.
+     */
+    void NachHintenBringen ()
+    {
+        symbol.NachHintenBringen();
+    }
+    
+    /**
+     * Bringt das Rechteck in die hinterste Ebene.
+     */
+    void GanzNachHintenBringen ()
+    {
+        symbol.GanzNachHintenBringen();
+    }
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Text.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Text.ctxt
new file mode 100644
index 00000000..4cf8727b
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Text.ctxt
@@ -0,0 +1,52 @@
+#BlueJ class context
+comment0.target=Text
+comment0.text=\n\ Wrapperklasse\ f\u00FCr\ einen\ Text\ auf\ der\ Zeichenfl\u00E4che.\n\ \n\ @author\ Albert\ Wiedemann\ \n\ @version\ 1.0\n
+comment1.params=
+comment1.target=Text()
+comment1.text=\n\ Der\ Konstruktor\ erzeugt\ das\ Delegate-Objekt\n
+comment10.params=winkel
+comment10.target=void\ WinkelSetzen(int)
+comment10.text=\n\ Setzt\ den\ Drehwinkel\ des\ Textes.\n\ Die\ Winkelangabe\ ist\ in\ Grad,positive\ Werte\ drehen\ gegen\ den\ Uhrzeigersinn,\n\ negative\ Werte\ drehen\ im\ Uhrzeigersinn\ (mathematisch\ positiver\ Drehsinn).\n\ @param\ winkel\ der\ (neue)\ Drehwinkel\ des\ Textes\n
+comment11.params=sichtbar
+comment11.target=void\ SichtbarkeitSetzen(boolean)
+comment11.text=\n\ Schaltet\ die\ Sichtbarkeit\ des\ Textes\ ein\ oder\ aus.\n\ Erlaubte\ Parameterwerte\:\ true,\ false\n\ @param\ sichtbar\ (neue)\ Sichtbarkeit\ des\ Textes\n
+comment12.params=
+comment12.target=void\ Entfernen()
+comment12.text=\n\ Entfernt\ den\ Text\ aus\ dem\ Zeichenfenster.\n
+comment13.params=
+comment13.target=void\ NachVornBringen()
+comment13.text=\n\ Bringt\ den\ Text\ eine\ Ebene\ nach\ vorn.\n
+comment14.params=
+comment14.target=void\ GanzNachVornBringen()
+comment14.text=\n\ Bringt\ den\ Text\ in\ die\ vorderste\ Ebene.\n
+comment15.params=
+comment15.target=void\ NachHintenBringen()
+comment15.text=\n\ Bringt\ den\ Text\ eine\ Ebene\ nach\ hinten.\n
+comment16.params=
+comment16.target=void\ GanzNachHintenBringen()
+comment16.text=\n\ Bringt\ den\ Text\ in\ die\ hinterste\ Ebene.\n
+comment2.params=x\ y
+comment2.target=void\ PositionSetzen(int,\ int)
+comment2.text=\n\ Setzt\ die\ Position\ (der\ Grundline)\ des\ Textes.\n\ @param\ x\ x-Position\ der\ linken\ Seite\ der\ Grundlinie\n\ @param\ y\ y-Position\ der\ Grundlinie\n
+comment3.params=text
+comment3.target=void\ TextSetzen(java.lang.String)
+comment3.text=\n\ Setzt\ den\ aktuellen\ Text.\n\ @param\ text\ der\ neue\ Text\n
+comment4.params=gr\u00F6\u00DFe
+comment4.target=void\ TextGr\u00F6\u00DFeSetzen(int)
+comment4.text=\n\ Setzt\ die\ Gr\u00F6\u00DFe\ des\ Textes.\n\ @param\ gr\u00F6\u00DFe\ die\ (neue)\ Textgr\u00F6\u00DFe\n
+comment5.params=
+comment5.target=void\ TextVergr\u00F6\u00DFern()
+comment5.text=\n\ Vergr\u00F6\u00DFert\ den\ Text.\n
+comment6.params=
+comment6.target=void\ TextVerkleinern()
+comment6.text=\n\ Verkleinert\ den\ Text.\n
+comment7.params=deltaX\ deltaY
+comment7.target=void\ Verschieben(int,\ int)
+comment7.text=\n\ Verschiebt\ den\ Text\ um\ die\ angegebenen\ Werte.\n\ @param\ deltaX\ Verschiebung\ in\ x-Richtung\n\ @param\ deltaY\ Verschiebung\ in\ y-Richtung\n
+comment8.params=grad
+comment8.target=void\ Drehen(int)
+comment8.text=\n\ Dreht\ den\ Text\n\ @param\ grad\ Drehwinkel\ (mathematisch\ positiver\ Drehsinn)\ im\ Gradmass\n
+comment9.params=farbe
+comment9.target=void\ FarbeSetzen(java.lang.String)
+comment9.text=\n\ Setzt\ die\ Farbe\ des\ Textes.\n\ Erlaubte\ Farben\ sind\:\n\ "wei\u00DF",\ "weiss",\ "rot",\ "gr\u00FCn",\ "gruen",\ "blau",\ "gelb",\n\ "magenta",\ "cyan",\ "hellgelb",\ "hellgr\u00FCn",\ "hellgruen",\n\ "orange",\ "braun",\ "grau",\ "schwarz"\n\ Alle\ anderen\ Eingaben\ werden\ auf\ die\ Farbe\ schwarz\ abgebildet.\n\ @param\ farbe\ (neue)\ Farbe\n
+numComments=17
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Text.java b/Info/10/2/Baelle/BlueJ_Projekt/Text.java
new file mode 100644
index 00000000..3fa1325a
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Text.java
@@ -0,0 +1,192 @@
+/**
+ * Wrapperklasse für einen Text auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Text
+{
+    /** x-Position der linken Seite der Grundlinie. */
+    private int x;
+    /** y-Position der Grundlinie. */
+    private int y;
+    /** Farbe des Textes. */
+    private String farbe;
+    /** Sichtbarkeit des Textes. */
+    private boolean sichtbar;
+    /** Drehwinkel (mathematisch positiver Drehsinn) des Textes in Grad. */
+    private int winkel;
+    /** Größe des Textes in Punkten. */
+    private int textgröße;
+    
+    /** Referenz auf das Delegate-Objekt. */
+    private Zeichenfenster.TextIntern symbol;
+
+    /**
+     * Der Konstruktor erzeugt das Delegate-Objekt
+     */
+    Text ()
+    {
+        x = 10;
+        y = 10;
+        farbe = "schwarz";
+        sichtbar = true;
+        winkel = 0;
+        textgröße = 12;
+        symbol = (Zeichenfenster.TextIntern) Zeichenfenster.SymbolErzeugen(Zeichenfenster.SymbolArt.text);
+        symbol.PositionSetzen(x, y);
+        symbol.FarbeSetzen(farbe);
+        symbol.SichtbarkeitSetzen(sichtbar);
+        symbol.WinkelSetzen(winkel);
+        symbol.TextGrößeSetzen(textgröße);
+    }
+    
+    /**
+     * Setzt die Position (der Grundline) des Textes.
+     * @param x x-Position der linken Seite der Grundlinie
+     * @param y y-Position der Grundlinie
+     */
+    void PositionSetzen(int x, int y)
+    {
+        this.x = x;
+        this.y = y;
+        symbol.PositionSetzen(x, y);
+    }
+        
+    /**
+     * Setzt den aktuellen Text.
+     * @param text der neue Text
+     */
+    void TextSetzen (String text)
+    {
+        symbol.TextSetzen(text);
+    }
+    
+    /**
+     * Setzt die Größe des Textes.
+     * @param größe die (neue) Textgröße
+     */
+    void TextGrößeSetzen (int größe)
+    {
+        textgröße = größe;
+        symbol.TextGrößeSetzen(größe);
+    }
+    
+    /**
+     * Vergrößert den Text.
+     */
+    void TextVergrößern()
+    {
+        symbol.TextVergrößern();
+        textgröße = (int) symbol.size;
+    }
+    
+    /**
+     * Verkleinert den Text.
+     */
+    void TextVerkleinern()
+    {
+        symbol.TextVerkleinern();
+        textgröße = (int) symbol.size;
+    }
+    
+    /**
+     * Verschiebt den Text um die angegebenen Werte.
+     * @param deltaX Verschiebung in x-Richtung
+     * @param deltaY Verschiebung in y-Richtung
+     */
+    void Verschieben(int deltaX, int deltaY)
+    {
+        x += deltaX;
+        y += deltaY;
+        symbol.PositionSetzen(x, y);
+    }
+    
+    /**
+     * Dreht den Text
+     * @param grad Drehwinkel (mathematisch positiver Drehsinn) im Gradmass
+     */
+    void Drehen(int grad)
+    {
+        winkel += grad;
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Setzt die Farbe des Textes.
+     * Erlaubte Farben sind:
+     * "weiß", "weiss", "rot", "grün", "gruen", "blau", "gelb",
+     * "magenta", "cyan", "hellgelb", "hellgrün", "hellgruen",
+     * "orange", "braun", "grau", "schwarz"
+     * Alle anderen Eingaben werden auf die Farbe schwarz abgebildet.
+     * @param farbe (neue) Farbe
+     */
+    void FarbeSetzen (String farbe)
+    {
+        this.farbe = farbe;
+        symbol.FarbeSetzen(farbe);
+    }
+        
+    /**
+     * Setzt den Drehwinkel des Textes.
+     * Die Winkelangabe ist in Grad,positive Werte drehen gegen den Uhrzeigersinn,
+     * negative Werte drehen im Uhrzeigersinn (mathematisch positiver Drehsinn).
+     * @param winkel der (neue) Drehwinkel des Textes
+     */
+    void WinkelSetzen (int winkel)
+    {
+        this.winkel = winkel;
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Schaltet die Sichtbarkeit des Textes ein oder aus.
+     * Erlaubte Parameterwerte: true, false
+     * @param sichtbar (neue) Sichtbarkeit des Textes
+     */
+    void SichtbarkeitSetzen (boolean sichtbar)
+    {
+        this.sichtbar = sichtbar;
+        symbol.SichtbarkeitSetzen(sichtbar);
+    }
+        
+    /**
+     * Entfernt den Text aus dem Zeichenfenster.
+     */
+    void Entfernen ()
+    {
+        symbol.Entfernen();
+    }
+    
+    /**
+     * Bringt den Text eine Ebene nach vorn.
+     */
+    void NachVornBringen ()
+    {
+        symbol.NachVornBringen();
+    }
+    
+    /**
+     * Bringt den Text in die vorderste Ebene.
+     */
+    void GanzNachVornBringen ()
+    {
+        symbol.GanzNachVornBringen();
+    }
+    
+    /**
+     * Bringt den Text eine Ebene nach hinten.
+     */
+    void NachHintenBringen ()
+    {
+        symbol.NachHintenBringen();
+    }
+    
+    /**
+     * Bringt den Text in die hinterste Ebene.
+     */
+    void GanzNachHintenBringen ()
+    {
+        symbol.GanzNachHintenBringen();
+    }
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Turtle.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Turtle.ctxt
new file mode 100644
index 00000000..7635b815
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Turtle.ctxt
@@ -0,0 +1,96 @@
+#BlueJ class context
+comment0.target=Turtle
+comment0.text=\n\ Wrapperklasse\ f\u00FCr\ die\ Turtle\ auf\ der\ Zeichenfl\u00E4che.\n\ \n\ @author\ Albert\ Wiedemann\ \n\ @version\ 1.0\n
+comment1.params=
+comment1.target=Turtle()
+comment1.text=\n\ Konstruktor\ der\ Turtle\n\ Erzeugt\ eine\ Turtle\ und\ versetzt\ sie\ in\ einen\ g\u00FCltigen\ Startzustand.\n
+comment10.params=x\ y
+comment10.target=void\ PositionSetzen(int,\ int)
+comment10.text=\n\ Setzt\ die\ Position\ der\ Turtle.\n\ @param\ x\ x-Position\ der\ Turtle\n\ @param\ y\ y-Position\ der\ Turtle\n
+comment11.params=gr\u00F6\u00DFe
+comment11.target=void\ Gr\u00F6\u00DFeSetzen(int)
+comment11.text=\n\ Setzt\ die\ Gr\u00F6\u00DFe\ des\ Turtlesymbols.\n\ @param\ gr\u00F6\u00DFe\ (neue)\ Gr\u00F6\u00DFe\n
+comment12.params=farbe
+comment12.target=void\ FarbeSetzen(java.lang.String)
+comment12.text=\n\ Setzt\ die\ Farbe\ der\ Linie.\n\ Erlaubte\ Farben\ sind\:\n\ "wei\u00DF",\ "weiss",\ "rot",\ "gr\u00FCn",\ "gruen",\ "blau",\ "gelb",\n\ "magenta",\ "cyan",\ "hellgelb",\ "hellgr\u00FCn",\ "hellgruen",\n\ "orange",\ "braun",\ "grau",\ "schwarz"\n\ Alle\ anderen\ Eingaben\ werden\ auf\ die\ Farbe\ schwarz\ abgebildet.\n\ @param\ farbe\ (neue)\ Farbe\n
+comment13.params=winkel
+comment13.target=void\ WinkelSetzen(int)
+comment13.text=\n\ Setzt\ den\ Drehwinkel\ der\ Turtle.\n\ Die\ Winkelangabe\ ist\ in\ Grad,\ positive\ Werte\ drehen\ gegen\ den\ Uhrzeigersinn,\n\ negative\ Werte\ drehen\ im\ Uhrzeigersinn\ (mathematisch\ positiver\ Drehsinn),\ d.\ h.\n\ 0\u02DA\:\ Turtle\ schaut\ nach\ rechts,\n\ 90\u02DA\:\ Turtle\ schaut\ nach\ oben,\n\ 180\u02DA\:\ Turtle\ schaut\ nach\ links,\n\ 270\u02DAbzw.\ -90\u02DA\:\ Turtle\ schaut\ nach\ unten\n\ @param\ winkel\ der\ (neue)\ Drehwinkel\ der\ Turtle\n
+comment14.params=sichtbar
+comment14.target=void\ SichtbarkeitSetzen(boolean)
+comment14.text=\n\ Schaltet\ die\ Sichtbarkeit\ der\ Turtle\ ein\ oder\ aus.\n\ Erlaubte\ Parameterwerte\:\ true,\ false\n\ @param\ sichtbar\ (neue)\ Sichtbarkeit\ der\ Turtle\n
+comment15.params=
+comment15.target=void\ Entfernen()
+comment15.text=\n\ Entfernt\ die\ Turtle\ aus\ dem\ Zeichenfenster.\n
+comment16.params=
+comment16.target=void\ NachVornBringen()
+comment16.text=\n\ Bringt\ die\ Turtle\ eine\ Ebene\ nach\ vorn.\n
+comment17.params=
+comment17.target=void\ GanzNachVornBringen()
+comment17.text=\n\ Bringt\ die\ Turtle\ in\ die\ vorderste\ Ebene.\n
+comment18.params=
+comment18.target=void\ NachHintenBringen()
+comment18.text=\n\ Bringt\ die\ Turtle\ eine\ Ebene\ nach\ hinten.\n
+comment19.params=
+comment19.target=void\ GanzNachHintenBringen()
+comment19.text=\n\ Bringt\ die\ Turtle\ in\ die\ hinterste\ Ebene.\n
+comment2.params=
+comment2.target=void\ Ausf\u00FChren()
+comment20.params=
+comment20.target=void\ ZumStartpunktGehen()
+comment20.text=\n\ Setzt\ die\ Turtle\ wieder\ an\ ihre\ Ausgangsposition.\n
+comment21.params=l\u00E4nge
+comment21.target=void\ Gehen(double)
+comment21.text=\n\ Bewegt\ die\ Turtle\ nach\ vorne.\n\ @param\ l\u00E4nge\ Anzahl\ der\ L\u00E4ngeneinheiten\n
+comment22.params=grad
+comment22.target=void\ Drehen(int)
+comment22.text=\n\ Dreht\ die\ Turtle\n\ @param\ grad\ Drehwinkel\ (mathematisch\ positiver\ Drehsinn)\ im\ Gradma\u00DF\n
+comment23.params=
+comment23.target=void\ L\u00F6schen()
+comment23.text=\n\ Versetzt\ Zeichenfl\u00E4che\ und\ Turtle\ in\ den\ Ausgangszustand\n
+comment24.params=
+comment24.target=void\ StiftHeben()
+comment24.text=\n\ Turtle\ wechselt\ in\ den\ Modus\ "nicht\ zeichnen"\n
+comment25.params=
+comment25.target=void\ StiftSenken()
+comment25.text=\n\ Turtle\ wechselt\ in\ den\ Modus\ "zeichnen"\n
+comment26.params=
+comment26.target=int\ WinkelGeben()
+comment26.text=\n\ Gibt\ den\ aktuellen\ Winkel\ der\ Turtle\ zur\u00FCck.\n\ Die\ Winkelangabe\ ist\ in\ Grad,\ positive\ Werte\ drehen\ gegen\ den\ Uhrzeigersinn,\n\ negative\ Werte\ drehen\ im\ Uhrzeigersinn\ (mathematisch\ positiver\ Drehsinn),\ d.\ h.\n\ 0\u02DA\:\ Turtle\ schaut\ nach\ rechts,\n\ 90\u02DA\:\ Turtle\ schaut\ nach\ oben,\n\ 180\u02DA\:\ Turtle\ schaut\ nach\ links,\n\ 270\u02DAbzw.\ -90\u02DA\:\ Turtle\ schaut\ nach\ unten\n\ @return\ Winkel\ im\ Gradmass\n
+comment27.params=
+comment27.target=int\ XPositionGeben()
+comment27.text=\n\ Gibt\ die\ x-Koordinate\ der\ Turtle\ zur\u00FCck\n\ @return\ x-Koordinate\n
+comment28.params=
+comment28.target=int\ YPositionGeben()
+comment28.text=\n\ Gibt\ die\ y-Koordinate\ der\ Turtle\ zur\u00FCck\n\ @return\ y-Koordinate\n
+comment29.params=sichtbar
+comment29.target=void\ SichtbarkeitF\u00FCrSymbolSetzen(boolean)
+comment29.text=\n\ Schaltet\ die\ Sichtbarkeit\ des\ Turtlesymbols\ ein\ oder\ aus.\n\ Erlaubte\ Parameterwerte\:\ true,\ false\n\ @param\ sichtbar\ (neue)\ Sichtbarkeit\ des\ Turtlesymbols\n
+comment3.params=taste
+comment3.target=void\ Taste(char)
+comment30.params=
+comment30.target=boolean\ Ber\u00FChrt()
+comment30.text=\n\ Testet,\ ob\ die\ Turtle\ eine\ Figur\ \ ber\u00FChrt.\n\ @return\ true,\ wenn\ die\ Turtlekoordinaten\ innerhalb\ einer\ Grafikfigur\ sind\n
+comment31.params=farbe
+comment31.target=boolean\ Ber\u00FChrt(java.lang.String)
+comment31.text=\n\ Testet,\ ob\ die\ Turtle\ eine\ Figur\ in\ der\ angegebenen\ Farbe\ ber\u00FChrt.\n\ @param\ farbe\ die\ Farbe,\ die\ die\ ber\u00FChrte\ Figur\ haben\ muss.\n\ @return\ true,\ wenn\ die\ Turtlekoordinaten\ innerhalb\ einer\ Grafikfigur\ in\ der\ angegebenen\ Farbe\ sind\n
+comment32.params=objekt
+comment32.target=boolean\ Ber\u00FChrt(java.lang.Object)
+comment32.text=\n\ Testet,\ ob\ die\ Turtle\ die\ angegebene\ Figur\ ber\u00FChrt.\n\ @param\ objekt\ das\ Objekt,\ das\ getestet\ werden\ soll.\n\ @return\ true,\ wenn\ die\ Turtlekoordinaten\ innerhalb\ der\ angegebenen\ Grafikfigur\ sind\n
+comment4.params=taste
+comment4.target=void\ SonderTaste(int)
+comment5.params=x\ y\ anzahl
+comment5.target=void\ Geklickt(int,\ int,\ int)
+comment6.params=
+comment6.target=void\ AktionAusf\u00FChren()
+comment6.text=\n\ Methode\ wird\ aufgerufen,\ wenn\ die\ Turtle\ handeln\ soll.\n\ Die\ vordefinierte\ Methode\ tut\ nichts.\n
+comment7.params=taste
+comment7.target=void\ TasteGedr\u00FCckt(char)
+comment7.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ gedr\u00FCckte\ Tasten.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ taste\ die\ gedr\u00FCckte\ Taste\n
+comment8.params=taste
+comment8.target=void\ SonderTasteGedr\u00FCckt(int)
+comment8.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ gedr\u00FCckte\ Sondertasten.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ taste\ KeyCode\ der\ gedr\u00FCckten\ Taste\n
+comment9.params=x\ y\ anzahl
+comment9.target=void\ MausGeklickt(int,\ int,\ int)
+comment9.text=\n\ Die\ eigentliche\ Aktionsmethode\ f\u00FCr\ einen\ Mausklick.\n\ <br>Muss\ bei\ Bedarf\ von\ einer\ Unterklasse\ \u00FCberschrieben\ werden.\ \n\ @param\ x\ x-Position\ des\ Mausklicks\n\ @param\ y\ y-Position\ des\ Mausklicks\n\ @param\ anzahl\ Anzahl\ der\ aufeinanderfolgenden\ Mausklicks\n
+numComments=33
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Turtle.java b/Info/10/2/Baelle/BlueJ_Projekt/Turtle.java
new file mode 100644
index 00000000..7fb912a0
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Turtle.java
@@ -0,0 +1,341 @@
+/**
+ * Wrapperklasse für die Turtle auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Turtle
+{
+    /** x-Position der Turtle. */
+    private int x;
+    /** y-Position der Turtle. */
+    private int y;
+    /** Größe der Turtle. */
+    private int größe;
+    /** Farbe der Turtle. */
+    private String farbe;
+    /** Sichtbarkeit der Turtles. */
+    private boolean sichtbar;
+    /** Drehwinkel (mathemtisch positiver Drehsinn) der Turtle in Grad. */
+    private int winkel;
+    /**Stiftposition*/
+    private boolean stiftUnten;
+    /** Referenz auf das echte Turtlesybol. */
+    Zeichenfenster.TurtleIntern symbol;
+    /** Referenz auf das Aktionsempfängerobjekt. */
+    Zeichenfenster.AktionsEmpfaenger aktionsEmpfänger;
+    
+    /**
+     * Konstruktor der Turtle
+     * Erzeugt eine Turtle und versetzt sie in einen gültigen Startzustand.
+     */
+    Turtle ()
+    {
+        symbol = (Zeichenfenster.TurtleIntern) Zeichenfenster.SymbolErzeugen(Zeichenfenster.SymbolArt.turtle);
+        symbol.SichtbarkeitSetzen(true);
+        x = symbol.x;
+        y = symbol.y;
+        winkel = symbol.winkel;
+        größe = symbol.b;
+        stiftUnten = symbol.stiftUnten;
+        sichtbar = symbol.sichtbar;
+        aktionsEmpfänger = new Zeichenfenster.AktionsEmpfaenger()
+        {
+            public void Ausführen ()
+            {
+                AktionAusführen();
+            }
+            
+            public void Taste (char taste)
+            {
+                TasteGedrückt(taste);
+            }
+            
+            public void SonderTaste (int taste)
+            {
+                SonderTasteGedrückt(taste);
+            }
+            
+            public void Geklickt (int x, int y, int anzahl)
+            {
+                MausGeklickt(x, y, anzahl);
+            }
+        };
+        Zeichenfenster.AktionsEmpfängerEintragen(aktionsEmpfänger);
+    }
+    
+    /**
+     * Methode wird aufgerufen, wenn die Turtle handeln soll.
+     * Die vordefinierte Methode tut nichts.
+     */
+    void AktionAusführen()
+    {
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für gedrückte Tasten.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param taste die gedrückte Taste
+     */
+    void TasteGedrückt (char taste)
+    {
+        //System. out. println ("Taste: " + taste);
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für gedrückte Sondertasten.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param taste KeyCode der gedrückten Taste
+     */
+    void SonderTasteGedrückt (int taste)
+    {
+        //System. out. println ("Sondertaste: " + taste);
+    }
+    
+    /**
+     * Die eigentliche Aktionsmethode für einen Mausklick.
+     * <br>Muss bei Bedarf von einer Unterklasse überschrieben werden. 
+     * @param x x-Position des Mausklicks
+     * @param y y-Position des Mausklicks
+     * @param anzahl Anzahl der aufeinanderfolgenden Mausklicks
+     */
+    void MausGeklickt (int x, int y, int anzahl)
+    {
+        System. out. println ("Maus: (" + x + "|" + y + "), " + anzahl + " mal");
+    }
+    
+    /**
+     * Setzt die Position der Turtle.
+     * @param x x-Position der Turtle
+     * @param y y-Position der Turtle
+     */
+    void PositionSetzen(int x, int y)
+    {
+        this.x = x;
+        this.y = y;
+        symbol.PositionSetzen(x, y);
+    }
+        
+    /**
+     * Setzt die Größe des Turtlesymbols.
+     * @param größe (neue) Größe
+     */
+    void GrößeSetzen (int größe)
+    {
+        this.größe = größe;
+        symbol.GrößeSetzen(größe, größe);
+    }
+    
+    /**
+     * Setzt die Farbe der Linie.
+     * Erlaubte Farben sind:
+     * "weiß", "weiss", "rot", "grün", "gruen", "blau", "gelb",
+     * "magenta", "cyan", "hellgelb", "hellgrün", "hellgruen",
+     * "orange", "braun", "grau", "schwarz"
+     * Alle anderen Eingaben werden auf die Farbe schwarz abgebildet.
+     * @param farbe (neue) Farbe
+     */
+    void FarbeSetzen (String farbe)
+    {
+        this.farbe = farbe;
+        symbol.FarbeSetzen(farbe);
+    }
+        
+    /**
+     * Setzt den Drehwinkel der Turtle.
+     * Die Winkelangabe ist in Grad, positive Werte drehen gegen den Uhrzeigersinn,
+     * negative Werte drehen im Uhrzeigersinn (mathematisch positiver Drehsinn), d. h.
+     * 0˚: Turtle schaut nach rechts,
+     * 90˚: Turtle schaut nach oben,
+     * 180˚: Turtle schaut nach links,
+     * 270˚bzw. -90˚: Turtle schaut nach unten
+     * @param winkel der (neue) Drehwinkel der Turtle
+     */
+    void WinkelSetzen (int winkel)
+    {
+        this.winkel = winkel;
+        symbol.WinkelSetzen(winkel);
+    }
+    
+    /**
+     * Schaltet die Sichtbarkeit der Turtle ein oder aus.
+     * Erlaubte Parameterwerte: true, false
+     * @param sichtbar (neue) Sichtbarkeit der Turtle
+     */
+    void SichtbarkeitSetzen (boolean sichtbar)
+    {
+        this.sichtbar = sichtbar;
+        symbol.SichtbarkeitSetzen(sichtbar);
+    }
+        
+    /**
+     * Entfernt die Turtle aus dem Zeichenfenster.
+     */
+    void Entfernen ()
+    {
+        Zeichenfenster.AktionsEmpfängerEntfernen(aktionsEmpfänger);
+        symbol.Entfernen();
+    }
+    
+    /**
+     * Bringt die Turtle eine Ebene nach vorn.
+     */
+    void NachVornBringen ()
+    {
+        symbol.NachVornBringen();
+    }
+    
+    /**
+     * Bringt die Turtle in die vorderste Ebene.
+     */
+    void GanzNachVornBringen ()
+    {
+        symbol.GanzNachVornBringen();
+    }
+    
+    /**
+     * Bringt die Turtle eine Ebene nach hinten.
+     */
+    void NachHintenBringen ()
+    {
+        symbol.NachHintenBringen();
+    }
+    
+    /**
+     * Bringt die Turtle in die hinterste Ebene.
+     */
+    void GanzNachHintenBringen ()
+    {
+        symbol.GanzNachHintenBringen();
+    }
+
+    /**
+     * Setzt die Turtle wieder an ihre Ausgangsposition.
+     */
+    void ZumStartpunktGehen()
+    {
+        symbol.ZumStartpunktGehen();
+        x = symbol.x;
+        y = symbol.y;
+        winkel = symbol.winkel;
+    }
+
+    /**
+     * Bewegt die Turtle nach vorne.
+     * @param länge Anzahl der Längeneinheiten
+     */
+    void Gehen(double länge)
+    {
+        symbol.Gehen(länge);
+        x = symbol.x;
+        y = symbol.y;
+    }
+    
+    /**
+     * Dreht die Turtle
+     * @param grad Drehwinkel (mathematisch positiver Drehsinn) im Gradmaß
+     */
+    void Drehen(int grad)
+    {
+        symbol.Drehen(grad);
+        winkel = symbol.winkel;
+    }
+
+    /**
+     * Versetzt Zeichenfläche und Turtle in den Ausgangszustand
+     */
+    void Löschen()
+    {
+        symbol.Löschen();
+    }
+
+    /**
+     * Turtle wechselt in den Modus "nicht zeichnen"
+     */
+    void StiftHeben()
+    {
+        symbol.StiftHeben();
+        stiftUnten = false;
+    }
+
+    /**
+     * Turtle wechselt in den Modus "zeichnen"
+     */
+    void StiftSenken()
+    {
+        symbol.StiftSenken();
+        stiftUnten = true;
+    }
+
+    /**
+     * Gibt den aktuellen Winkel der Turtle zurück.
+     * Die Winkelangabe ist in Grad, positive Werte drehen gegen den Uhrzeigersinn,
+     * negative Werte drehen im Uhrzeigersinn (mathematisch positiver Drehsinn), d. h.
+     * 0˚: Turtle schaut nach rechts,
+     * 90˚: Turtle schaut nach oben,
+     * 180˚: Turtle schaut nach links,
+     * 270˚bzw. -90˚: Turtle schaut nach unten
+     * @return Winkel im Gradmass
+     */
+    int WinkelGeben()
+    {
+        return winkel;
+    }
+
+    /**
+     * Gibt die x-Koordinate der Turtle zurück
+     * @return x-Koordinate
+     */
+    int XPositionGeben()
+    {
+        return x;
+    }
+    
+    /**
+     * Gibt die y-Koordinate der Turtle zurück
+     * @return y-Koordinate
+     */ 
+    int YPositionGeben()
+    {
+        return y;
+    }
+    
+    /**
+     * Schaltet die Sichtbarkeit des Turtlesymbols ein oder aus.
+     * Erlaubte Parameterwerte: true, false
+     * @param sichtbar (neue) Sichtbarkeit des Turtlesymbols
+     */
+    void SichtbarkeitFürSymbolSetzen (boolean sichtbar)
+    {
+        symbol.SichtbarkeitFürSymbolSetzen(sichtbar);
+    }
+    
+    /**
+     * Testet, ob die Turtle eine Figur  berührt.
+     * @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur sind
+     */
+    boolean Berührt ()
+    {
+        return symbol.Berührt();
+    }
+    
+    /**
+     * Testet, ob die Turtle eine Figur in der angegebenen Farbe berührt.
+     * @param farbe die Farbe, die die berührte Figur haben muss.
+     * @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
+     */
+    boolean Berührt (String farbe)
+    {
+        return symbol.Berührt(farbe);
+    }
+
+    /**
+     * Testet, ob die Turtle die angegebene Figur berührt.
+     * @param objekt das Objekt, das getestet werden soll.
+     * @return true, wenn die Turtlekoordinaten innerhalb der angegebenen Grafikfigur sind
+     */
+    boolean Berührt (Object objekt)
+    {
+        return symbol.Berührt(objekt);
+    }
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Zeichenfenster.ctxt b/Info/10/2/Baelle/BlueJ_Projekt/Zeichenfenster.ctxt
new file mode 100644
index 00000000..2200e591
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Zeichenfenster.ctxt
@@ -0,0 +1,60 @@
+#BlueJ class context
+comment0.target=Zeichenfenster
+comment0.text=\n\ Die\ Klasse\ stellt\ ein\ Fenster\ mit\ einer\ Malfl\u00E4che\ zur\ Verf\u00FCgung,\n\ auf\ der\ Objekte\ der\ Klassen\ Rechteck,\ Kreis\ und\ Dreieck\ sowie\ Turtle\ dargestellt\n\ werden\ k\u00F6nnen.\n\ Die\ Zeichenfl\u00E4che\ wird\ beim\ ersten\ Anlegen\ eines\ Zeichenobjekts\ automatisch\n\ nach\ dem\ Muster\ Singleton\ angelegt.\n\ \n\ @author\ Albert\ Wiedemann\ \n\ @version\ 1.0\n
+comment1.params=
+comment1.target=Zeichenfenster()
+comment1.text=\n\ Legt\ das\ Fenster\ und\ die\ Malfl\u00E4che\ an\n
+comment10.params=
+comment10.target=int\ Malfl\u00E4chenBreiteGeben()
+comment10.text=\n\ Meldet\ die\ aktuelle\ Breite\ der\ Malfl\u00E4che.\n\ @returns\ Breite\ der\ Malfl\u00E4che\n
+comment11.params=
+comment11.target=int\ Malfl\u00E4chenH\u00F6heGeben()
+comment11.text=\n\ Meldet\ die\ aktuelle\ H\u00F6he\ der\ Malfl\u00E4che.\n\ @returns\ H\u00F6he\ der\ Malfl\u00E4che\n
+comment12.params=neu
+comment12.target=void\ AktionsEmpf\u00E4ngerEintragen(Zeichenfenster.AktionsEmpfaenger)
+comment12.text=\n\ Tr\u00E4gt\ einen\ neuen\ Aktionsempf\u00E4nger\ ein.\n\ @param\ neu\ der\ neue\ Aktionsempf\u00E4nger\n
+comment13.params=alt
+comment13.target=void\ AktionsEmpf\u00E4ngerEntfernen(Zeichenfenster.AktionsEmpfaenger)
+comment13.text=\n\ L\u00F6scht\ einen\ Aktionsempf\u00E4nger\ aus\ der\ Liste.\n\ @param\ alt\ der\ zu\ l\u00F6schende\ Aktionsempf\u00E4nger\n
+comment14.params=art
+comment14.target=Zeichenfenster.GrafikSymbol\ SymbolErzeugen(Zeichenfenster.SymbolArt)
+comment14.text=\n\ Erzeugt\ ein\ neues\ darzustelledes\ Symbol.\n\ Die\ m\u00F6glichen\ Symbole\ sind\ im\ Aufz\u00E4hlungstyp\ SymbolArt\ beschrieben.\n\ @param\ art\ Art\ des\ zu\ erzeugenden\ Symbols.\n\ @return\ Referenz\ auf\ das\ Delegate-Objekt.\n
+comment15.params=
+comment15.target=void\ TaktgeberStarten()
+comment15.text=\n\ Startet\ den\ Taktgeber.\n
+comment16.params=
+comment16.target=void\ TaktgeberStoppen()
+comment16.text=\n\ Stoppt\ den\ Taktgeber.\n
+comment17.params=dauer
+comment17.target=void\ TaktdauerSetzen(int)
+comment17.text=\n\ Ablaufgeschwindigkeit\ des\ Zeitgebers\ einstellen.\n\ \n\ @param\ dauer\:\ Angabe\ in\ Millisekunden\n
+comment18.params=art
+comment18.target=Zeichenfenster.GrafikSymbol\ SymbolAnlegen(Zeichenfenster.SymbolArt)
+comment18.text=\n\ Erzeugt\ das\ neue\ Symbol\ tats\u00E4chlich.\n\ @param\ art\ Art\ des\ zu\ erzeugenden\ Symbols.\n\ @return\ Referenz\ auf\ das\ Delegate-Objekt.\n
+comment19.params=
+comment19.target=void\ TaktgeberStartenIntern()
+comment19.text=\n\ Startet\ den\ Taktgeber.\n
+comment2.params=g
+comment2.target=void\ paint(java.awt.Graphics)
+comment20.params=
+comment20.target=void\ TaktgeberStoppenIntern()
+comment20.text=\n\ Stoppt\ den\ Taktgeber.\n
+comment3.params=e
+comment3.target=void\ mousePressed(java.awt.event.MouseEvent)
+comment3.text=\n\ Gibt\ den\ Ort\ eines\ Mouseclicks\ an\ die\ eigentliche\ Aktionsmethode\ weiter.\n\ @param\ e\ das\ zugrestellte\ Ereignis\n
+comment4.params=e
+comment4.target=void\ keyPressed(java.awt.event.KeyEvent)
+comment4.text=\n\ Gibt\ die\ Taste\ an\ die\ eigentliche\ Aktionsmethode\ weiter.\n\ @param\ e\ das\ zugestellte\ Ereignis\n
+comment5.params=e
+comment5.target=void\ componentResized\u200B(java.awt.event.ComponentEvent)
+comment5.text=\n\ Setzt\ die\ Hintegrundbilder\ aller\ Turtle\ auf\ die\ neue\ Gr\u00F6\u00DFe.\n
+comment6.params=evt
+comment6.target=void\ actionPerformed(java.awt.event.ActionEvent)
+comment7.params=evt
+comment7.target=void\ actionPerformed(java.awt.event.ActionEvent)
+comment8.params=e
+comment8.target=void\ stateChanged\u200B(javax.swing.event.ChangeEvent)
+comment9.params=evt
+comment9.target=void\ actionPerformed(java.awt.event.ActionEvent)
+comment9.text=\n\ Vom\ Timer\ aufgerufen.\n\ Erzeugt\ den\ n\u00E4chsten\ Taktimpuls\n\ @param\ evt\ der\ Timerevent\n
+numComments=21
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/Zeichenfenster.java b/Info/10/2/Baelle/BlueJ_Projekt/Zeichenfenster.java
new file mode 100644
index 00000000..e17192e3
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/Zeichenfenster.java
@@ -0,0 +1,1866 @@
+import java.awt.*;
+import java.awt.geom.*;
+import java.awt.event.*;
+import java.awt.image.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+/**
+ * Die Klasse stellt ein Fenster mit einer Malfläche zur Verfügung,
+ * auf der Objekte der Klassen Rechteck, Kreis und Dreieck sowie Turtle dargestellt
+ * werden können.
+ * Die Zeichenfläche wird beim ersten Anlegen eines Zeichenobjekts automatisch
+ * nach dem Muster Singleton angelegt.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+class Zeichenfenster
+{
+    /** Interface für die Aktionsausführung. */
+    interface AktionsEmpfaenger
+    {
+        /** Methode wird vom Taktgeber aufgerufen. */
+        void Ausführen();
+        void Taste (char taste);
+        void SonderTaste (int taste);
+        void Geklickt (int x, int y, int anzahl);
+    }
+    
+    /** Aufzählung der erzeugbaren Objektarten. */
+    static enum SymbolArt {kreis, dreieck, rechteck, turtle, figur, text;};
+    
+    /** Einziges Objekt der Zeichenfläche. */
+    private static Zeichenfenster zeichenfläche = null;
+    
+    /** Fenster für die Zeichenfläche. */
+    private JFrame fenster;
+    /** Die eigentliche Darstellungskomponente. */
+    private JComponent malfläche;
+    /** Stop-Knopf für den Taktgeber. */
+    private JButton stop;
+    /** Start-Knopf für den Taktgeber. */
+    private JButton start;
+    /** Einsteller für die Taktrate*/
+    private JSlider slider;
+    /** Feld aller zu zeichnenden Objekte. */
+    private ArrayList<GrafikSymbol> alleSymbole;
+    /** Feld aller zu zeichnenden Objekte. */
+    private ArrayList<AktionsEmpfaenger> aktionsEmpfänger;
+    /** Timerobjekt für die zentrale Zeitverwaltung */
+    private javax.swing.Timer timer;
+
+    /**
+     * Legt das Fenster und die Malfläche an
+     */
+    private Zeichenfenster ()
+    {
+        alleSymbole = new ArrayList<GrafikSymbol>();
+        aktionsEmpfänger = new ArrayList<AktionsEmpfaenger>();
+        fenster = new JFrame("Zeichenfenster");
+        fenster.setLocation(50, 50);
+        fenster.setSize(800, 600);
+        fenster.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE); //Close-Button kann nicht versteckt oder abgestellt werden.
+        
+        malfläche = new JComponent()
+        {
+            public void paint (Graphics g)
+            {
+                g.setColor(new Color (230, 230, 230));
+                g.fillRect(0, 0, getWidth() - 1, getHeight() - 1);
+                synchronized (malfläche)
+                {
+                    for (GrafikSymbol s: alleSymbole)
+                    {
+                        if (s.sichtbar)
+                        {
+                            s.Zeichnen(g);
+                        }
+                    }
+                }
+            }
+        };
+        malfläche.setOpaque(true);
+        malfläche.addMouseListener(new MouseAdapter ()
+        {
+            /**
+             * Gibt den Ort eines Mouseclicks an die eigentliche Aktionsmethode weiter.
+             * @param e das zugrestellte Ereignis
+             */
+            public void mousePressed(MouseEvent e)
+            {
+                malfläche.requestFocus();
+                ArrayList<AktionsEmpfaenger> empfänger = new ArrayList<AktionsEmpfaenger>(aktionsEmpfänger);
+                for (AktionsEmpfaenger em: empfänger)
+                {
+                    em.Geklickt(e.getX(), e.getY(), e.getClickCount());
+                }
+            }
+        }
+        );
+        malfläche.addKeyListener(new KeyAdapter ()
+        {
+            /**
+             * Gibt die Taste an die eigentliche Aktionsmethode weiter.
+             * @param e das zugestellte Ereignis
+             */
+            public void keyPressed(KeyEvent e)
+            {
+                ArrayList<AktionsEmpfaenger> empfänger = new ArrayList<AktionsEmpfaenger>(aktionsEmpfänger);
+                if ((int) e.getKeyChar() == KeyEvent.CHAR_UNDEFINED)
+                {
+                    switch (e.getKeyCode())
+                    {
+                        case KeyEvent.VK_ENTER:
+                            for (AktionsEmpfaenger em: empfänger)
+                            {
+                                em.Taste((char) KeyEvent.VK_ENTER);
+                            }
+                            break;
+                        default:
+                            for (AktionsEmpfaenger em: empfänger)
+                            {
+                                em.SonderTaste(e.getKeyCode());
+                            }
+                    }
+                }
+                else
+                {
+                    for (AktionsEmpfaenger em: empfänger)
+                    {
+                        em.Taste(e.getKeyChar());
+                    }
+                }
+            }
+        }
+        );
+        malfläche.addComponentListener(new ComponentAdapter()
+        {
+            /**
+             * Setzt die Hintegrundbilder aller Turtle auf die neue Größe.
+             */
+            public void componentResized​(ComponentEvent e)
+            {
+                synchronized (malfläche)
+                {
+                    for (GrafikSymbol s: alleSymbole)
+                    {
+                        if (s instanceof TurtleIntern)
+                        {
+                            ((TurtleIntern) s).NeueGrößeSetzen();
+                        }
+                    }
+                }
+            }
+        }
+        );
+        fenster.add(malfläche, BorderLayout.CENTER);
+        JPanel panel = new JPanel();
+        panel.setMinimumSize(new Dimension(200, 60));
+        panel.setSize(200,60);
+        panel.setVisible(true);
+        panel.setLayout(new GridLayout(1, 2));
+        JPanel panel2 = new JPanel();
+        panel2.setMinimumSize(new Dimension(100, 60));
+        panel2.setSize(100,60);
+        panel2.setVisible(true);
+        panel2.setLayout(new GridLayout(1, 1));
+        stop = new JButton();
+        start = new JButton();
+        start.setLocation(10, 10);
+        start.setSize(80, 30);
+        start.setText("Start");
+        start.setVisible(true);
+        start.addActionListener(new ActionListener ()
+        {
+            public void actionPerformed (ActionEvent evt)
+            {
+                TaktgeberStartenIntern();
+                malfläche.requestFocus();
+            }
+        }
+        );
+        panel2.add(start);
+        stop.setLocation(100, 10);
+        stop.setSize(80, 30);
+        stop.setText("Stop");
+        stop.setVisible(true);
+        stop.setEnabled(false);
+        stop.addActionListener(new ActionListener ()
+        {
+            public void actionPerformed (ActionEvent evt)
+            {
+                TaktgeberStoppenIntern();
+                malfläche.requestFocus();
+            }
+        }
+        );
+        panel2.add(stop);
+        panel.add(panel2);
+        slider = new JSlider(0, 1000, 100);
+        slider.setLocation(190, 10);
+        slider.setSize(160, 40);
+        slider.setMinimumSize(new Dimension(160, 40));
+        slider.setPreferredSize(new Dimension(160, 40));
+        slider.setMajorTickSpacing(100);
+        slider.setPaintTicks(true);
+        slider.setPaintLabels(true);
+        slider.setValue(1000);
+        slider.addChangeListener(new ChangeListener()
+        {
+            public void stateChanged​(ChangeEvent e)
+            {
+                timer.setDelay(slider.getValue());
+                malfläche.requestFocus();
+            }
+        }
+        );
+        panel.add(slider);
+        
+        fenster.add(panel, BorderLayout.SOUTH);
+        fenster.setVisible(true);
+        malfläche.requestFocus();
+
+        timer = new javax.swing.Timer (1000, new ActionListener ()
+        {
+            /**
+             * Vom Timer aufgerufen.
+             * Erzeugt den nächsten Taktimpuls
+             * @param evt der Timerevent
+             */
+            public void actionPerformed (ActionEvent evt)
+            {
+                ArrayList<AktionsEmpfaenger> empfänger = new ArrayList<AktionsEmpfaenger>(aktionsEmpfänger);
+                for (AktionsEmpfaenger e: empfänger)
+                {
+                    e.Ausführen();
+                }
+            }
+        }
+        );
+    }
+    
+    /**
+     * Meldet die aktuelle Breite der Malfläche.
+     * @returns Breite der Malfläche
+     */
+    static int MalflächenBreiteGeben()
+    {
+        if (zeichenfläche == null)
+        {
+            zeichenfläche = new Zeichenfenster();
+        }
+        return zeichenfläche.malfläche.getWidth();
+    }
+    
+    /**
+     * Meldet die aktuelle Höhe der Malfläche.
+     * @returns Höhe der Malfläche
+     */
+    static int MalflächenHöheGeben()
+    {
+        if (zeichenfläche == null)
+        {
+            zeichenfläche = new Zeichenfenster();
+        }
+        return zeichenfläche.malfläche.getHeight();
+    }
+    
+    /**
+     * Trägt einen neuen Aktionsempfänger ein.
+     * @param neu der neue Aktionsempfänger
+     */
+    static void AktionsEmpfängerEintragen(AktionsEmpfaenger neu)
+    {
+        if (zeichenfläche == null)
+        {
+            zeichenfläche = new Zeichenfenster();
+        }
+        zeichenfläche.aktionsEmpfänger.add(neu);
+    }
+    
+    /**
+     * Löscht einen Aktionsempfänger aus der Liste.
+     * @param alt der zu löschende Aktionsempfänger
+     */
+    static void AktionsEmpfängerEntfernen(AktionsEmpfaenger alt)
+    {
+        if (zeichenfläche == null)
+        {
+            zeichenfläche = new Zeichenfenster();
+        }
+        zeichenfläche.aktionsEmpfänger.remove(alt);
+    }
+    
+    /**
+     * Erzeugt ein neues darzustelledes Symbol.
+     * Die möglichen Symbole sind im Aufzählungstyp SymbolArt beschrieben.
+     * @param art Art des zu erzeugenden Symbols.
+     * @return Referenz auf das Delegate-Objekt.
+     */
+    static GrafikSymbol SymbolErzeugen (SymbolArt art)
+    {
+        if (zeichenfläche == null)
+        {
+            zeichenfläche = new Zeichenfenster();
+        }
+        return zeichenfläche.SymbolAnlegen(art);
+    }
+    
+    /**
+     * Startet den Taktgeber.
+     */
+    static void TaktgeberStarten ()
+    {
+        if (zeichenfläche == null)
+        {
+            zeichenfläche = new Zeichenfenster();
+        }
+        zeichenfläche.TaktgeberStartenIntern();
+    }
+    
+    /**
+     * Stoppt den Taktgeber.
+     */
+    static void TaktgeberStoppen ()
+    {
+        if (zeichenfläche == null)
+        {
+            zeichenfläche = new Zeichenfenster();
+        }
+        zeichenfläche.TaktgeberStoppenIntern();
+    }
+    
+    /**
+     * Ablaufgeschwindigkeit des Zeitgebers einstellen.
+     * 
+     * @param dauer: Angabe in Millisekunden
+     */
+    static void TaktdauerSetzen (int dauer)
+    {
+        if (zeichenfläche == null)
+        {
+            zeichenfläche = new Zeichenfenster();
+        }
+        zeichenfläche.slider.setValue(dauer < 0 ? 0 : (dauer > 1000 ? 1000: dauer));
+    }
+    
+    /**
+     * Erzeugt das neue Symbol tatsächlich.
+     * @param art Art des zu erzeugenden Symbols.
+     * @return Referenz auf das Delegate-Objekt.
+     */
+    private GrafikSymbol SymbolAnlegen (SymbolArt art)
+    {
+        GrafikSymbol neu = null;
+        switch (art)
+        {
+            case rechteck:
+                neu = new RechteckIntern();
+                break;
+            case kreis:
+                neu = new EllipseIntern();
+                break;
+            case dreieck:
+                neu = new DreieckIntern();
+                break;
+            case turtle:
+                neu = new TurtleIntern();
+                break;
+            case figur:
+                neu = new FigurIntern();
+                break;
+            case text:
+                neu = new TextIntern();
+                break;
+        }
+        synchronized (zeichenfläche.malfläche)
+        {
+            zeichenfläche.alleSymbole.add(neu);
+        }
+        malfläche.repaint();
+        return neu;
+    }
+    
+    /**
+     * Startet den Taktgeber.
+     */
+    private void TaktgeberStartenIntern()
+    {
+        start.setEnabled(false);
+        stop.setEnabled(true);
+        timer.start();
+    }
+    
+    /**
+     * Stoppt den Taktgeber.
+     */
+    private void TaktgeberStoppenIntern()
+    {
+        start.setEnabled(true);
+        stop.setEnabled(false);
+        timer.stop();
+    }
+    
+    /**
+     * Oberklasse für alle verfügbaren Grafiksymbole.
+     * Alle Grafiksymbole werden über ihr umgebendes Rechteck beschrieben.
+     */
+    abstract class GrafikSymbol
+    {
+        /** x-Position der linken oberen Ecke. */
+        protected int x;
+        /** y-Position der linken oberen Ecke. */
+        protected int y;
+        /** Breite des umgebenden Rechtecks. */
+        protected int b;
+        /** Höhe des umgebenden Rechtecks. */
+        protected int h;
+        /** Farbe des Symbols. */
+        protected Color c;
+        /** Sichtbarkeit des Symbols. */
+        protected boolean sichtbar;
+        /** Drehwinkel (mathematisch positiver Drehsinn) des Symbols. */
+        protected int winkel;
+        /** Die Form des Grafiksymbols. */
+        protected Area form;
+        /** Farbe Hellgelb. */
+        protected final Color hellgelb = new Color(255,255,128);
+        /** Farbe Hellgrün. */
+        protected final Color hellgrün = new Color(128,255,128);
+        /** Farbe Orange. */
+        protected final Color orange = new Color(255,128,0);
+        /** Farbe Braun. */
+        protected final Color braun = new Color(128,64,0);
+        
+        /**
+         * Der Konstruktor erzeugt ein rotes Symbol in der linken oberen Ecke des Fensters.
+         */
+        GrafikSymbol()
+        {
+            x = 10;
+            y = 10;
+            b = 100;
+            h = 100;
+            c = Color.RED;
+            sichtbar = true;
+            winkel = 0;
+            FormErzeugen();
+        }
+        
+        /**
+         * Normiert den Winkel auf Werte im Bereich [0; 360[
+         * @param winkel der Eingabewinkel
+         * @return der normierte Winkel
+         */
+        int WinkelNormieren(int winkel)
+        {
+            while (winkel < 0)
+            {
+                winkel += 360;
+            }
+            return winkel % 360;
+        }
+        
+        /**
+         * Setzt die Position (der linken oberen Ecke) des Objekts.
+         * @param x x-Position der linken oberen Ecke
+         * @param y y-Position der linken oberen Ecke
+         */
+        void PositionSetzen (int x, int y)
+        {
+            this.x = x;
+            this.y = y;
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Setzt die Größe des Objekts.
+         * @param breite (neue) Breite des Objekts
+         * @param höhe (neue) Höhe des Objekts
+         */
+        void GrößeSetzen (int breite, int höhe)
+        {
+            b = breite;
+            h = höhe;
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+    
+        /**
+         * Bestimmt die RGB-Farbe für den gegeben String.
+         * @param farbe die Farbe als String
+         * @return die Farbe als RGB-Farbe
+         */
+        Color FarbeCodieren (String farbe)
+        {
+            farbe = farbe.toLowerCase();
+            switch (farbe)
+            {
+                case "weiß":
+                case "weiss":
+                    return Color.WHITE;
+                case "rot":
+                    return Color.RED;
+                case "grün":
+                case "gruen":
+                    return Color.GREEN;
+                case "blau":
+                    return Color.BLUE;
+                case "gelb":
+                    return Color.YELLOW;
+                case "magenta":
+                    return Color.MAGENTA;
+                case "cyan":
+                    return Color.CYAN;
+                case "hellgelb":
+                    return hellgelb;
+                case "hellgrün":
+                case "hellgruen":
+                    return hellgrün;
+                case "orange":
+                    return orange;
+                case "braun":
+                    return braun;
+                case "grau":
+                    return Color.GRAY;
+                case "schwarz":
+                    return Color.BLACK;
+                default:
+                    return Color.BLACK;
+            }
+        }
+
+        /**
+         * Setzt die Farbe des Objekts.
+         * @param farbe (neue) Farbe des Objekts
+         */
+        void FarbeSetzen (String farbe)
+        {
+            FarbeSetzen(FarbeCodieren(farbe));
+        }
+        
+        /**
+         * Setzt die Farbe des Objekts.
+         * @param c (neue) Farbe des Objekts
+         */
+        void FarbeSetzen (Color c)
+        {
+            this.c = c;
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Setzt die Sichtbarkeit des Objekts.
+         * @param sichtbar (neue) Sichtbarkeit des Objekts
+         */
+        void SichtbarkeitSetzen (boolean sichtbar)
+        {
+            this.sichtbar = sichtbar;
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Setzt den Drehwinkel des Objekts.
+         * @param winkel der (neue) Drehwinkel des Objekts
+         */
+        void WinkelSetzen (int winkel)
+        {
+            this.winkel = WinkelNormieren(winkel);
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Entfernt das Objekt aus dem Zeichenfenster.
+         */
+        void Entfernen ()
+        {
+            synchronized (zeichenfläche.malfläche)
+            {
+                zeichenfläche.alleSymbole.remove(this);
+                zeichenfläche.malfläche.repaint();
+            }
+        }
+        
+        /**
+         * Bringt das Objekt eine Ebene nach vorn.
+         */
+        void NachVornBringen ()
+        {
+            synchronized (zeichenfläche.malfläche)
+            {
+                int index = zeichenfläche.alleSymbole.indexOf(this);
+                if (index < zeichenfläche.alleSymbole.size() - 1)
+                {
+                    zeichenfläche.alleSymbole.set(index, zeichenfläche.alleSymbole.get(index + 1));
+                    zeichenfläche.alleSymbole.set(index + 1, this);
+                    zeichenfläche.malfläche.repaint();
+                }
+            }
+        }
+        
+        /**
+         * Bringt das Objekt in die vorderste Ebene.
+         */
+        void GanzNachVornBringen ()
+        {
+            synchronized (zeichenfläche.malfläche)
+            {
+                int index = zeichenfläche.alleSymbole.indexOf(this);
+                if (index < zeichenfläche.alleSymbole.size() - 1)
+                {
+                    zeichenfläche.alleSymbole.remove(index);
+                    zeichenfläche.alleSymbole.add(this);
+                    zeichenfläche.malfläche.repaint();
+                }
+            }
+        }
+        
+        /**
+         * Bringt das Objekt eine Ebene nach hinten.
+         */
+        void NachHintenBringen ()
+        {
+            synchronized (zeichenfläche.malfläche)
+            {
+                int index = zeichenfläche.alleSymbole.indexOf(this);
+                if (index > 0)
+                {
+                    zeichenfläche.alleSymbole.set(index, zeichenfläche.alleSymbole.get(index - 1));
+                    zeichenfläche.alleSymbole.set(index - 1, this);
+                    zeichenfläche.malfläche.repaint();
+                }
+            }
+        }
+        
+        /**
+         * Bringt das Objekt in die hinterste Ebene.
+         */
+        void GanzNachHintenBringen ()
+        {
+            synchronized (zeichenfläche.malfläche)
+            {
+                int index = zeichenfläche.alleSymbole.indexOf(this);
+                if (index > 0)
+                {
+                    zeichenfläche.alleSymbole.remove(index);
+                    zeichenfläche.alleSymbole.add(0, this);
+                    zeichenfläche.malfläche.repaint();
+                }
+            }
+        }
+        
+        /**
+         * Testet, ob der angegebene Punkt innerhalb der Figur ist.
+         * @param x x-Koordinate des zu testenden Punktes
+         * @param y y-Koordinate des zu testenden Punktes
+         * @return wahr, wenn der Punkt innerhalb der Figur ist
+         */
+        boolean IstInnerhalb (int x, int y)
+        {
+            return form.contains(x, y);
+        }
+        
+        /**
+         * Testet, ob die beiden Figuren überlappen.
+         * @param wen die andere Form
+         * @return wahr, wenn die beiden Formen überlappen.
+         */
+        boolean Schneidet (Area wen)
+        {
+            Area area = new Area(form);
+            area.intersect (wen);
+            return !area.isEmpty();
+        }
+        
+        /**
+         * Zeichnet das Objekt
+         * @param g das Grafikobjekt zum Zeichnen
+         */
+        void Zeichnen(Graphics g)
+        {
+            g.setColor(c);
+            ((Graphics2D) g).fill(form);
+        }
+        
+        /**
+         * Berechnet den Drehwinkel gemäß den Konventionen des Graphik-Frameworks.
+         * Für Java: Winkel in Radians, positive Drehrichtng im Uhrzeiger.
+         * @param winkel: Der Winkel in Grad, mathematischer Drehsinn
+         * @return Winkel für Graphik-Framework
+         */
+        double DrehwinkelGeben (int winkel)
+        {
+            return - Math.PI * (winkel > 180 ? winkel - 360 : winkel)  / 180.0;
+        }
+        
+        /**
+         * Erstellt die Form des Objekts.
+         */
+        abstract void FormErzeugen();
+    }
+    
+    /**
+     * Objekte dieser Klasse verwalten ein Rechteck.
+     */
+    private class RechteckIntern extends GrafikSymbol
+    {        
+        /**
+         * Erstellt die Form des Rechtecks.
+         */
+        @Override void FormErzeugen()
+        {
+            AffineTransform a = new AffineTransform();
+            a.rotate(DrehwinkelGeben (winkel), this.x + b / 2, this.y + h / 2);
+            form = new Area(new Path2D.Double (new Rectangle2D.Double(this.x, this.y, b, h), a));
+        }
+    }
+    
+    /**
+     * Objekte dieser Klasse verwalten eine Ellipse.
+     */
+    private class EllipseIntern extends GrafikSymbol
+    {
+        /**
+         * Erstellt die Form der Ellipse.
+         */
+        @Override void FormErzeugen()
+        {
+            AffineTransform a = new AffineTransform();
+            a.rotate(DrehwinkelGeben (winkel), this.x + b / 2, this.y + h / 2);
+            form = new Area(new Path2D.Double (new Ellipse2D.Double(this.x, this.y, b, h), a));
+        }
+    }
+    
+    /**
+     * Objekte dieser Klasse verwalten ein Dreieck.
+     */
+    private class DreieckIntern extends GrafikSymbol
+    {
+        /**
+         * Erstellt die Form des Dreiecks.
+         */
+        @Override void FormErzeugen()
+        {
+            Polygon rand = new Polygon (new int [] {x + b / 2, x + b, x, x + b / 2},
+                                        new int [] {y, y + h, y + h, y}, 4);
+            AffineTransform a = new AffineTransform();
+            a.rotate(DrehwinkelGeben (winkel), this.x + b / 2, this.y + h / 2);
+            form = new Area(new Path2D.Double (rand, a));
+        }
+    }
+    
+    /**
+     * Objekte dieser Klasse verwalten einen Text.
+     */
+    class TextIntern extends GrafikSymbol
+    {
+        /** Der aktuelle Text. */
+        private String text;
+        /** Die aktuelle Textgröße. */
+        float size;
+
+        /**
+         * Belegt text und size mit Defaultwerten.
+         */
+        TextIntern ()
+        {
+            super();
+            text = "Text";
+            size = 12;
+            c = Color.black;
+        }
+        
+        /**
+         * Erstellt die Form des Textes.
+         * Dummy, legt ein leeres Area an.
+         */
+        @Override void FormErzeugen()
+        {
+            form = new Area();
+        }
+        
+        /**
+         * Testet, ob der angegebene Punkt innerhalb der Figur ist.
+         * @param x x-Koordinate des zu testenden Punktes
+         * @param y y-Koordinate des zu testenden Punktes
+         * @return falsch
+         */
+        @Override boolean IstInnerhalb (int x, int y)
+        {
+            return false;
+        }
+        
+        /**
+         * Setzt den aktuellen Text.
+         * @param t der neue Text
+         */
+        void TextSetzen (String t)
+        {
+            text = t;
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Setzt die Größe des Textes.
+         */
+        void TextGrößeSetzen (int größe)
+        {
+            size = größe;
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Vergrößert den Text.
+         */
+        void TextVergrößern()
+        {
+            if (size <= 10)
+            {
+                size += 1;
+            }
+            else if (size <= 40)
+            {
+                size += 2;
+            }
+            else
+            {
+                size += 4;
+            }
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Verkleinert den Text.
+         */
+        void TextVerkleinern()
+        {
+            if (size <= 10)
+            {
+                size -= 1;
+            }
+            else if (size <= 40)
+            {
+                size -= 2;
+            }
+            else
+            {
+                size -= 4;
+            }
+            if (size < 1)
+            {
+                size = 1;
+            }
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Zeichnet das Objekt als Dreieck in der gegebenen Farbe.
+         * @param g das Grafikobjekt zum Zeichnen
+         */
+        @Override void Zeichnen(Graphics g)
+        {
+            g.setColor(c);
+            Font f = g.getFont();
+            Font f2 = f.deriveFont(size);
+            g.setFont(f2);
+            
+            if (winkel == 0)
+            {
+                g.drawString(text, x, y);
+            }
+            else
+            {
+                Graphics2D g2 = (Graphics2D) g;
+                AffineTransform alt = g2.getTransform();
+                //g2.rotate(DrehwinkelGeben (winkel), x + b / 2, y + h / 2);
+                //g2.rotate(DrehwinkelGeben (winkel), x + text.length() * size / 4, y + size / 2);
+                Rectangle2D bounds = f2.getStringBounds(text, g2.getFontRenderContext());
+                g2.rotate(DrehwinkelGeben (winkel), x + bounds.getWidth() / 2, y - bounds.getHeight() / 2);
+                g.drawString(text, x, y);
+                g2.setTransform(alt);
+            }
+            g.setFont(f);
+        }
+    }
+    
+    /**
+     * Oberklasse für alle Elemente einer Figur (Figur, Turtle).
+     */
+    private abstract class FigurenElement
+    {
+        double xe;
+        double ye;
+        double breite;
+        double höhe;
+        Color c;
+        /**
+         * Zeichnet das Figurenelement.
+         * @param g das Grafikobjekt
+         * @param größe die aktuelle Größe der Figur
+         * @param x die x-Koordinate des Aufhängepunkts der Figur
+         * @param y die y-Koordinate des Aufhängepunkts der Figur
+         */
+        abstract void ElementZeichnen(Graphics2D g, double größe, int x, int y);
+        
+        /**
+         * Fügt den Pfadteil deiser Komponente zum umgebenden Pfad hinzu.
+         * @param p der Gesamtpfad
+         * @param größe die aktuelle Größe der Figur
+         * @param x die x-Koordinate des Aufhängepunkts der Figur
+         * @param y die y-Koordinate des Aufhängepunkts der Figur
+         */
+        abstract void ElementZuForm (Path2D.Double p, double größe, int x, int y);
+    }
+    
+    /**
+     * Ein rechteckiges Figurenelement.
+     */
+    private class FigurenElementRechteck extends FigurenElement
+    {
+        /**
+         * Der Konstruktor speichert die Rahmendaten.
+         * @param x x-Koordinate der linken oberen Ecke des Rechtecks relativ zum Aufhängepunkt.
+         * @param y y-Koordinate der linken oberen Ecke des Rechtecks relativ zum Aufhängepunkt.
+         * @param breite Breite des Rechtecks
+         * @param höhe Höhe des Rechtecks
+         * @param c Farbe des Rechtecks
+         */
+        FigurenElementRechteck (double x, double y, double breite, double höhe, Color c)
+        {
+            this.xe = x;
+            this.ye = y;
+            this.breite = breite;
+            this.höhe = höhe;
+            this.c = c;
+        }
+        
+        /**
+         * Zeichnet das Figurenelement.
+         * @param g das Grafikobjekt
+         * @param größe die aktuelle Größe der Figur
+         * @param x die x-Koordinate des Aufhängepunkts der Figur
+         * @param y die y-Koordinate des Aufhängepunkts der Figur
+         */
+        @Override void ElementZeichnen(Graphics2D g, double größe, int x, int y)
+        {
+            g.setColor(c);
+            g.fill(new Rectangle2D.Double (x+größe*xe/100.0, y+größe*ye/100.0, größe*breite/100.0, größe*höhe/100.0));
+        }
+        
+        /**
+         * Fügt den Pfadteil dieser Komponente zum umgebenden Pfad hinzu.
+         * @param p der Gesamtpfad
+         * @param größe die aktuelle Größe der Figur
+         * @param x die x-Koordinate des Aufhängepunkts der Figur
+         * @param y die y-Koordinate des Aufhängepunkts der Figur
+         */
+        @Override void ElementZuForm (Path2D.Double p, double größe, int x, int y)
+        {
+            p.append(new Rectangle2D.Double (x+größe*xe/100.0, y+größe*ye/100.0, größe*breite/100.0, größe*höhe/100.0), false);
+        }
+    }
+    
+    /**
+     * Ein elliptisches Figurenelement.
+     */
+    private class FigurenElementEllipse extends FigurenElement
+    {
+        /**
+         * Der Konstruktor speichert die Rahmendaten.
+         * @param x x-Koordinate der linken oberen Ecke des umgebenden Rechtecks relativ zum Aufhängepunkt.
+         * @param y y-Koordinate der linken oberen Ecke des umgebenden Rechtecks relativ zum Aufhängepunkt.
+         * @param breite Breite der Ellipse
+         * @param höhe Höhe der Ellipse
+         * @param c Farbe der Ellipse
+         */
+        FigurenElementEllipse (double x, double y, double breite, double höhe, Color c)
+        {
+            this.xe = x;
+            this.ye = y;
+            this.breite = breite;
+            this.höhe = höhe;
+            this.c = c;
+        }
+        
+        /**
+         * Zeichnet das Figurenelement.
+         * @param g das Grafikobjekt
+         * @param größe die aktuelle Größe der Figur
+         * @param x die x-Koordinate des Aufhängepunkts der Figur
+         * @param y die y-Koordinate des Aufhängepunkts der Figur
+         */
+        @Override void ElementZeichnen(Graphics2D g, double größe, int x, int y)
+        {
+            g.setColor(c);
+            g.fill(new Ellipse2D.Double (x+größe*xe/100.0, y+größe*ye/100.0, größe*breite/100.0, größe*höhe/100.0));
+        }
+        
+        /**
+         * Fügt den Pfadteil dieser Komponente zum umgebenden Pfad hinzu.
+         * @param p der Gesamtpfad
+         * @param größe die aktuelle Größe der Figur
+         * @param x die x-Koordinate des Aufhängepunkts der Figur
+         * @param y die y-Koordinate des Aufhängepunkts der Figur
+         */
+        @Override void ElementZuForm (Path2D.Double p, double größe, int x, int y)
+        {
+            p.append(new Ellipse2D.Double (x+größe*xe/100.0, y+größe*ye/100.0, größe*breite/100.0, größe*höhe/100.0), false);
+        }
+    }
+    
+    /**
+     * Ein Figurenelement begrenzt durch das angegebene Polygon.
+     */
+    private class FigurenElementPolygon extends FigurenElement
+    {
+        /** Das Polygonobjekt */
+        private Polygon poly;
+        
+        /**
+         * Der Konstruktor speichert die Rahmendaten.
+         * @param x x-Koordinaten der Stützpunkte des Polygons relativ zum Aufhängepunkt.
+         * @param y y-Koordinaten der Stützpunkte des Polygons relativ zum Aufhängepunkt.
+         * @param c Farbe der Polygonfläche
+         */
+        FigurenElementPolygon (int [] x, int[] y, Color c)
+        {
+            int anz = x.length <= y.length ? x.length : y.length;
+            poly = new Polygon (x, y, anz);
+            Rectangle2D bounds = poly.getBounds2D();
+            xe = bounds.getX();
+            ye = bounds.getY();
+            breite = bounds.getWidth();
+            höhe = bounds.getHeight();
+            this.c = c;
+        }
+        
+        /**
+         * Zeichnet das Figurenelement.
+         * @param g das Grafikobjekt
+         * @param größe die aktuelle Größe der Figur
+         * @param x die x-Koordinate des Aufhängepunkts der Figur
+         * @param y die y-Koordinate des Aufhängepunkts der Figur
+         */
+        @Override void ElementZeichnen(Graphics2D g, double größe, int x, int y)
+        {
+            g.setColor(c);
+            AffineTransform at = new AffineTransform(größe/100.0, 0, 0, größe/100.0, x, y);
+            g.fill(new Path2D.Double (poly, at));
+        }
+        
+        /**
+         * Fügt den Pfadteil dieser Komponente zum umgebenden Pfad hinzu.
+         * @param p der Gesamtpfad
+         * @param größe die aktuelle Größe der Figur
+         * @param x die x-Koordinate des Aufhängepunkts der Figur
+         * @param y die y-Koordinate des Aufhängepunkts der Figur
+         */
+        @Override void ElementZuForm (Path2D.Double p, double größe, int x, int y)
+        {
+            AffineTransform at = new AffineTransform(größe/100.0, 0, 0, größe/100.0, x, y);
+            Path2D.Double p2 = new Path2D.Double (poly, at);
+            p2.closePath();
+            p2.setWindingRule(Path2D.WIND_EVEN_ODD);
+            p.append(p2, false);
+        }
+    }
+    
+    /**
+     * Das Objekt dieser Klasse zeichnet den Weg der Turtle.
+     */
+    class TurtleIntern extends GrafikSymbol
+    {
+        private class LinienElement
+        {
+            /** x-Koordinate des Startpunktes. */
+            private double xStart;
+            /** y-Koordinate des Startpunktes. */
+            private double yStart;
+            /** x-Koordinate des Endpunktes. */
+            private double xEnde;
+            /** y-Koordinate des Endpunktes. */
+            private double yEnde;
+            /** Farbe des LinienElements. */
+            private Color c;
+            
+            LinienElement (double xStart, double yStart, double xEnde, double yEnde, Color c)
+            {
+                this.xStart = xStart;
+                this.yStart = yStart;
+                this.xEnde = xEnde;
+                this.yEnde = yEnde;
+                this.c = c;
+            }
+            
+            void Zeichnen (Graphics2D g)
+            {
+                g.setColor(c);
+                g.draw(new Line2D.Double (xStart, yStart, xEnde, yEnde));
+            }
+        }
+        
+        /**
+         * Verwaltet das Hintergrundfenster für die Turtlezeichnung.
+         */
+        private class HintergrundBild
+        {
+            /** Das aktuelle Hintergrundbild. */
+            private BufferedImage bild;
+            /** Das zugehörige Zeichenobjekt. */
+            private Graphics2D g;
+            
+            /**
+             * Der Konstruktor legt das Bild in der Größe der Zeichenfläche an.
+             */
+            HintergrundBild()
+            {
+                bild = new BufferedImage(Zeichenfenster.MalflächenBreiteGeben(), Zeichenfenster.MalflächenBreiteGeben(), BufferedImage.TYPE_INT_ARGB);
+                g = bild.createGraphics();
+                g.setColor(new Color (0, 0, 0, 0));
+                g.fillRect(0, 0, bild.getWidth(), bild.getHeight());
+            }
+            
+            /**
+             * Zeichent die angegebe Linie in das Bild.
+             * @param linie das zu zeichnende Linienelement.
+             */
+            void LinieZeichnen(LinienElement linie)
+            {
+                linie.Zeichnen(g);
+            }
+            
+            /**
+             * Zeichnet das Bild in das angegebene Zeichenobjekt.
+             * @param wohin Zeichenobjekt
+             */
+            void BildZeichnen (Graphics2D wohin)
+            {
+                wohin.drawImage(bild, null, 0, 0);
+            }
+        }
+        
+        /** Genaue x-Koordinate der Turtle. */
+        double xD;
+        /** Genaue y-Koordinate der Turtle. */
+        double yD;
+        /** Startkoordinate der Turtle. */
+        private int homeX;
+        /** Startkoordinate der Turtle. */
+        private int homeY;
+        /** Startwinkel der Turtle. */
+        private int homeWinkel; 
+        /** Stiftposition. */
+        boolean stiftUnten;
+        /** Die Sichtbarkeit des Turtle-Symbols. */
+        private boolean symbolSichtbar;
+        /** Linienelemente. */
+        private ArrayList<LinienElement> linien;
+        /** Standardfigur für Turtle. */
+        private LinkedList<FigurenElement> standardFigur;
+        /** Das Hintergrundbild für die Linien. */
+        private HintergrundBild hintergrund;
+
+        /**
+         * Legt die Turtle mit Startpunkt (100|200) in Richtung 0˚ an.
+         */
+        TurtleIntern ()
+        {
+            super ();
+            x = 100;
+            y = 200;
+            xD = x;
+            yD = y;
+            h = 40;
+            b = 40;
+            homeX=x;
+            homeY=y;
+            homeWinkel=winkel;
+            c = Color.black;
+            stiftUnten = true;
+            symbolSichtbar = true;
+            linien = new ArrayList<LinienElement>();
+            hintergrund = new HintergrundBild();
+            standardFigur = new LinkedList<FigurenElement>();
+            StandardfigurErzeugen();
+            FormErzeugen();
+        }
+        
+        /**
+         * Baut die Standardfigur aus den Elementen auf.
+         */
+        private void StandardfigurErzeugen()
+        {
+            //Kopf
+            standardFigur.add(new FigurenElementEllipse(50, -12.5, 25, 25, Color.GREEN));
+            //Beine
+            standardFigur.add(new FigurenElementEllipse(22.5, -32.5, 12.5, 17.5, Color.GREEN));
+            standardFigur.add(new FigurenElementEllipse(40.0, -32.5, 12.5, 17.5, Color.GREEN));
+            standardFigur.add(new FigurenElementEllipse(22.5, 15.0, 12.5, 17.5, Color.GREEN));
+            standardFigur.add(new FigurenElementEllipse(40.0, 15.0, 12.5, 17.5, Color.GREEN));
+            //Augen
+            standardFigur.add(new FigurenElementRechteck(67.5, -10.0, 5.0, 7.5, c));
+            standardFigur.add(new FigurenElementRechteck(67.5, 2.5, 5.0, 7.5, c));
+            //Schwanz
+            standardFigur.add(new FigurenElementEllipse(0, -3.75, 25, 7.5, c));
+            //Rumpf
+            standardFigur.add(new FigurenElementEllipse(7.5, -23.75, 57.5, 47.5, braun));
+        }
+        
+        /**
+         * Passt das Hintergrundbild an eine neue Größe der Zeichenfläche an.
+         */
+        void NeueGrößeSetzen()
+        {
+            hintergrund = new HintergrundBild();
+            for (LinienElement l: linien)
+            {
+                hintergrund.LinieZeichnen(l);
+            }
+        }
+                
+        /**
+         * Erstellt die Form der Turtle.
+         */
+        @Override void FormErzeugen()
+        {
+            Area area = new Area();
+            AffineTransform a = new AffineTransform();
+            a.rotate(DrehwinkelGeben (winkel), this.x, this.y);
+            double größe = h > b ? b : h;
+            if (standardFigur != null)
+            {
+                synchronized (standardFigur)
+                {
+                    for (FigurenElement e: standardFigur)
+                    {
+                        Path2D.Double p = new Path2D.Double();
+                        e.ElementZuForm(p, größe, x, y);
+                        area.add( new Area(new Path2D.Double (p, a)));
+                    }
+                }
+               
+            }
+            form = area;
+        }
+        
+        /**
+         * Setzt die Position (der linken oberen Ecke) des Objekts.
+         * @param x x-Position der linken oberen Ecke
+         * @param y y-Position der linken oberen Ecke
+         */
+        @Override void PositionSetzen (int x, int y)
+        {
+            super.PositionSetzen (x, y);
+            xD = x;
+            yD = y;
+        }
+
+        /**
+         * Setzt die Turtle wieder an ihre Ausgangsposition.
+         */
+        void ZumStartpunktGehen()
+        {
+            x = homeX;
+            y = homeY;
+            xD = x;
+            yD = y;
+            winkel = homeWinkel;
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+    
+        /**
+         * Bewegt die Turtle nach vorne.
+         * @param länge Anzahl der Längeneinheiten
+         */
+        void Gehen(double länge)
+        {   
+            double neuX = xD + Math.cos(DrehwinkelGeben (winkel)) * länge;
+            double neuY = yD + Math.sin(DrehwinkelGeben (winkel)) * länge;            
+            if (stiftUnten)
+            {
+                synchronized (this)
+                {
+                    LinienElement l = new LinienElement(xD, yD, neuX, neuY, c);
+                    linien.add (l);
+                    hintergrund.LinieZeichnen (l);
+                }
+            }    
+            xD = neuX;
+            yD = neuY;
+            x =(int) Math.round(xD);
+            y =(int) Math.round(yD);
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+    
+        /**
+         * Dreht die Turtle
+         * @param grad Drehwinkel im Gradmass
+         */
+        void Drehen(int grad)
+        {
+            winkel = WinkelNormieren(winkel + grad);
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+
+        /**
+         * Versetzt Zeichenfläche und Turtle in den Ausgangszustand
+         */
+        void Löschen()
+        {
+            linien.clear();
+            hintergrund = new HintergrundBild();
+            ZumStartpunktGehen();
+        }
+
+        /**
+         * Turtle wechselt in den Modus "nicht zeichnen"
+         */
+        void StiftHeben()
+        {
+            stiftUnten = false;
+        }
+    
+        /**
+         * Turtle wechselt in den Modus "zeichnen"
+         */
+        void StiftSenken()
+        {
+            stiftUnten = true;
+        }
+    
+        /**
+         * Schaltet die Sichtbarkeit des Turtlesymbols ein oder aus.
+         * Erlaubte Parameterwerte: true, false
+         * @param sichtbar (neue) Sichtbarkeit des Turtlesymbols
+         */
+        void SichtbarkeitFürSymbolSetzen (boolean sichtbar)
+        {
+            symbolSichtbar = sichtbar;
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Testet, ob der angegebene Punkt innerhalb der Figur ist.
+         * @param x x-Koordinate des zu testenden Punktes
+         * @param y y-Koordinate des zu testenden Punktes
+         * @return wahr, wenn der Punkt innerhalb der Figur ist
+         */
+        
+        /**
+         * Testet, ob die Turtle eine (sichtbare) Figur berührt.
+         * @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur sind
+         */
+        boolean Berührt ()
+        {
+            for (GrafikSymbol g: zeichenfläche.alleSymbole)
+            {
+                if ((g != this) && g.IstInnerhalb(x, y) && g.sichtbar && (!(g instanceof TurtleIntern) || ((TurtleIntern) g).symbolSichtbar))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+        
+        /**
+         * Testet, ob die Turtle eine (sichtbare) Figur in der angegebenen Farbe berührt.
+         * Bei Überlappungen 
+         * @param farbe die Farbe, die die berührte Figur haben muss.
+         * @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
+         */
+        boolean Berührt (String farbe)
+        {
+            Color c2 = FarbeCodieren(farbe);
+            boolean ok = false;
+            for (GrafikSymbol g: zeichenfläche.alleSymbole)
+            {
+                if ((g != this) && g.IstInnerhalb(x, y) && g.sichtbar)
+                {
+                    if (g instanceof TurtleIntern)
+                    {
+                        TurtleIntern t = (TurtleIntern) g;
+                        if (t.symbolSichtbar)
+                        {
+                            for (FigurenElement e: t.standardFigur)
+                            {
+                                Path2D.Double p = new Path2D.Double();
+                                double größe = t.h > t.b ? t.b : t.h;
+                                e.ElementZuForm(p, größe, t.x, t.y);  
+                                AffineTransform a = new AffineTransform();
+                                a.rotate(DrehwinkelGeben (t.winkel), t.x, t.y);
+                                p = new Path2D.Double (p, a);
+                                if (p.contains(x, y))
+                                {
+                                    ok = c2.equals(e.c);
+                                }
+                            }
+                        }
+                    }
+                    else if (g instanceof FigurIntern)
+                    {
+                        FigurIntern t = (FigurIntern) g;
+                        LinkedList<FigurenElement> figur = ((t.eigeneFigur == null) || (t.eigeneFigur.size() == 0)) ? t.standardFigur : t.eigeneFigur;
+                        for (FigurenElement e: figur)
+                        {
+                            Path2D.Double p = new Path2D.Double();
+                            double größe = t.h > t.b ? t.b : t.h;
+                            e.ElementZuForm(p, größe, t.x, t.y);  
+                            AffineTransform a = new AffineTransform();
+                            a.rotate(DrehwinkelGeben (t.winkel), t.x, t.y);
+                            p = new Path2D.Double (p, a);
+                            if (p.contains(x, y))
+                            {
+                                ok = c2.equals(e.c);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        ok = ok || c2.equals(g.c);
+                    }
+                }
+            }
+            return ok;
+        }
+        
+        /**
+         * Testet, ob die Turtle die (sichtbare, ) angegebene Figur berührt.
+         * @param object das Objekt, das getestet werden soll.
+         * @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
+         */
+        boolean Berührt (Object object)
+        {
+            GrafikSymbol s = null;
+            if (object instanceof Rechteck)
+            {
+                s = ((Rechteck) object).symbol;
+            }
+            else if (object instanceof Dreieck)
+            {
+                s = ((Dreieck) object).symbol;
+            }
+            else if (object instanceof Kreis)
+            {
+                s = ((Kreis) object).symbol;
+            }
+            else if (object instanceof Turtle)
+            {
+                s = ((Turtle) object).symbol;
+            }
+            else if (object instanceof Figur)
+            {
+                s = ((Figur) object).symbol;
+            }
+            return (s != null) && (s != this) && s.IstInnerhalb(x, y) && s.sichtbar && (!(s instanceof TurtleIntern) || ((TurtleIntern) s).symbolSichtbar);
+        }
+
+        /**
+         * Zeichnet das Objekt als Dreieck in der gegebenen Farbe.
+         * @param g das Grafikobjekt zum Zeichnen
+         */
+        @Override void Zeichnen(Graphics g)
+        {
+            Graphics2D g2 = (Graphics2D) g;
+            synchronized (this)
+            {
+                hintergrund.BildZeichnen(g2);
+            }
+            
+            if (symbolSichtbar)
+            {
+                g.setColor(Color.black);
+                double größe = h > b ? b : h;
+                AffineTransform alt = g2.getTransform();
+                g2.rotate(DrehwinkelGeben (winkel), x, y);
+                if (standardFigur != null)
+                {
+                    synchronized (standardFigur)
+                    {
+                        for (FigurenElement e: standardFigur)
+                        {
+                            e.ElementZeichnen(g2, größe, x, y);
+                        }
+                    }
+                }
+                g2.setTransform(alt);
+            }
+        }
+    }
+    
+    /**
+     * Das Objekt dieser Klasse ist ein in der Gestalt definierbarer Akteur.
+     */
+    class FigurIntern extends GrafikSymbol
+    {
+        
+        /** Genaue x-Koordinate der Figur. */
+        double xD;
+        /** Genaue y-Koordinate der Figur. */
+        double yD;
+        /** Startkoordinate der Figur. */
+        private int homeX;
+        /** Startkoordinate der Figur. */
+        private int homeY;
+        /** Startwinkel der Figur. */
+        private int homeWinkel; 
+        /** Eigene Figur für Figur. */
+        private LinkedList<FigurenElement> eigeneFigur;
+        /** Standardfigur für Figur. */
+        private LinkedList<FigurenElement> standardFigur;
+
+        /**
+         * Legt die Figur mit Startpunkt (100|200) in Richtung 0˚ an.
+         */
+        FigurIntern ()
+        {
+            super ();
+            x = 100;
+            y = 200;
+            xD = x;
+            yD = y;
+            h = 40;
+            b = 40;
+            homeX=x;
+            homeY=y;
+            homeWinkel=winkel;
+            c = Color.black;
+            eigeneFigur = new LinkedList<FigurenElement>();
+            standardFigur = new LinkedList<FigurenElement>();
+            StandardfigurErzeugen();
+            FormErzeugen();
+        }
+        
+        /**
+         * Baut die Standardfigur aus den Elementen auf.
+         */
+        private void StandardfigurErzeugen()
+        {            
+            int[] x = new int [] {-50, 50, -50};
+            int[] y = new int [] {-50, 0, 50};
+            standardFigur.add (new FigurenElementPolygon (x, y, Color.yellow));
+            standardFigur.add(new FigurenElementEllipse(-10, -10, 20, 20, Color.blue));
+        }
+                
+        /**
+         * Erstellt die Form der Figur.
+         */
+        @Override void FormErzeugen()
+        {
+            Area area = new Area();
+            AffineTransform a = new AffineTransform();
+            a.rotate(DrehwinkelGeben (winkel), this.x, this.y);
+            double größe = h > b ? b : h;
+            if (standardFigur != null)
+            {
+                LinkedList<FigurenElement> figur = ((eigeneFigur == null) || (eigeneFigur.size() == 0)) ? standardFigur : eigeneFigur;
+                synchronized (figur)
+                {
+                    for (FigurenElement e: figur)
+                    {
+                        Path2D.Double p = new Path2D.Double();
+                        e.ElementZuForm(p, größe, x, y);
+                        area.add(new Area(new Path2D.Double (p, a)));
+                    }
+                }
+               
+            }
+            form = area;
+        }
+        
+        /**
+         * Setzt die Position (der Mitte) des Objekts.
+         * @param x x-Position der Mitte
+         * @param y y-Position der Mitte
+         */
+        @Override void PositionSetzen (int x, int y)
+        {
+            super.PositionSetzen (x, y);
+            xD = x;
+            yD = y;
+        }
+
+        /**
+         * Setzt die Figur wieder an ihre Ausgangsposition.
+         */
+        void ZumStartpunktGehen()
+        {
+            x = homeX;
+            y = homeY;
+            xD = x;
+            yD = y;
+            winkel = homeWinkel;
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+    
+        /**
+         * Bewegt die Figur nach vorne.
+         * @param länge Anzahl der Längeneinheiten
+         */
+        void Gehen(double länge)
+        {   
+            double neuX = xD + Math.cos(DrehwinkelGeben (winkel)) * länge;
+            double neuY = yD + Math.sin(DrehwinkelGeben (winkel)) * länge;            
+            xD = neuX;
+            yD = neuY;
+            x =(int) Math.round(xD);
+            y =(int) Math.round(yD);
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+    
+        /**
+         * Dreht die Figur
+         * @param grad Drehwinkel im Gradmass
+         */
+        void Drehen(int grad)
+        {
+            winkel = WinkelNormieren(winkel + grad);
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Testet, ob die Figur eine (sichtbare) Grafik-Figur berührt.
+         * @return true, wenn die Figurkoordinaten innerhalb einer Grafikfigur sind
+         */
+        boolean Berührt ()
+        {
+            for (GrafikSymbol g: zeichenfläche.alleSymbole)
+            {
+                if ((g != this) && g.Schneidet(form) && g.sichtbar && (!(g instanceof TurtleIntern) || ((TurtleIntern) g).symbolSichtbar))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+        
+        /**
+         * Testet, ob die Figur eine (sichtbare) Grafik-Figur in der angegebenen Farbe berührt.
+         * Bei Überlappungen 
+         * @param farbe die Farbe, die die berührte Figur haben muss.
+         * @return true, wenn die Figurkoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
+         */
+        boolean Berührt (String farbe)
+        {
+            Color c2 = FarbeCodieren(farbe);
+            boolean ok = false;
+            for (GrafikSymbol g: zeichenfläche.alleSymbole)
+            {
+                if ((g != this) && g.Schneidet(form) && g.sichtbar)
+                {
+                    if (g instanceof TurtleIntern)
+                    {
+                        TurtleIntern t = (TurtleIntern) g;
+                        if (t.symbolSichtbar)
+                        {
+                            Area[] areas = new Area [t.standardFigur.size()];
+                            Color[] colors = new Color [t.standardFigur.size()];
+                            AffineTransform a = new AffineTransform();
+                            a.rotate(DrehwinkelGeben (t.winkel), t.x, t.y);
+                            int pos = 0;
+                            for (FigurenElement e: t.standardFigur)
+                            {
+                                Path2D.Double p = new Path2D.Double();
+                                double größe = t.h > t.b ? t.b : t.h;
+                                e.ElementZuForm(p, größe, t.x, t.y);  
+                                p = new Path2D.Double (p, a);
+                                areas [pos] = new Area(p);
+                                colors[pos] = e.c;
+                                for (int i = pos - 1; i >= 0;i--)
+                                {
+                                    areas[i].subtract(areas[pos]);
+                                }
+                                pos += 1;
+                            }
+                            for (int i = 0; i < areas.length; i++)
+                            {
+                                if (Schneidet(areas[i]) && (c2.equals(colors[i])))
+                                {
+                                    ok = true;
+                                }
+                            }
+                        }
+                    }
+                    else if (g instanceof FigurIntern)
+                    {
+                        FigurIntern t = (FigurIntern) g;
+                        LinkedList<FigurenElement> figur = ((t.eigeneFigur == null) || (t.eigeneFigur.size() == 0)) ? t.standardFigur : t.eigeneFigur;
+                        Area[] areas = new Area [figur.size()];
+                        Color[] colors = new Color [figur.size()];
+                        AffineTransform a = new AffineTransform();
+                        a.rotate(DrehwinkelGeben (t.winkel), t.x, t.y);
+                        int pos = 0;
+                        for (FigurenElement e: figur)
+                        {
+                            Path2D.Double p = new Path2D.Double();
+                            double größe = t.h > t.b ? t.b : t.h;
+                            e.ElementZuForm(p, größe, t.x, t.y);  
+                            p = new Path2D.Double (p, a);
+                            areas [pos] = new Area(p);
+                            colors[pos] = e.c;
+                            for (int i = pos - 1; i >= 0;i--)
+                            {
+                                areas[i].subtract(areas[pos]);
+                            }
+                            pos += 1;
+                        }
+                        for (int i = 0; i < areas.length; i++)
+                        {
+                            if (Schneidet(areas[i]) && (c2.equals(colors[i])))
+                            {
+                                ok = true;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        ok = ok || c2.equals(g.c);
+                    }
+                }
+            }
+            return ok;
+        }
+        
+        /**
+         * Testet, ob die Figur die (sichtbare, ) angegebene Grafik-Figur berührt.
+         * @param object das Objekt, das getestet werden soll.
+         * @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
+         */
+        boolean Berührt (Object object)
+        {
+            GrafikSymbol s = null;
+            if (object instanceof Rechteck)
+            {
+                s = ((Rechteck) object).symbol;
+            }
+            else if (object instanceof Dreieck)
+            {
+                s = ((Dreieck) object).symbol;
+            }
+            else if (object instanceof Kreis)
+            {
+                s = ((Kreis) object).symbol;
+            }
+            else if (object instanceof Turtle)
+            {
+                s = ((Turtle) object).symbol;
+            }
+            else if (object instanceof Figur)
+            {
+                s = ((Figur) object).symbol;
+            }
+            return (s != null) && (s != this) && s.Schneidet(form) && s.sichtbar && (!(s instanceof TurtleIntern) || ((TurtleIntern) s).symbolSichtbar);
+        }
+
+        /**
+         * Erzeugt ein neues, rechteckiges Element einer eigenen Darstellung der Figur.
+         * Alle Werte beziehen sich auf eine Figur der Größe 100 und den Koordinaten (0|0) in der Mitte des Quadrats
+         * @param x x-Wert der linken oberen Ecke des Rechtecks
+         * @param y y-Wert der linken oberen Ecke des Rechtecks
+         * @param breite Breite des Rechtecks
+         * @param höhe Höhe des Rechtecks
+         * @param farbe (Füll)Farbe des Rechtecks
+         */
+        void FigurteilFestlegenRechteck (int x, int y, int breite, int höhe, String farbe)
+        {
+            synchronized (eigeneFigur)
+            {
+                eigeneFigur.add(new FigurenElementRechteck(x, y, breite, höhe, FarbeCodieren(farbe)));
+            }
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+
+        /**
+         * Erzeugt ein neues, elliptisches Element einer eigenen Darstellung der Figur.
+         * Alle Werte beziehen sich auf eine Figur der Größe 100 und den Koordinaten (0|0) in der Mitte des Quadrats
+         * @param x x-Wert der linken oberen Ecke des umgebenden Rechtecks der Ellipse
+         * @param y y-Wert der linken oberen Ecke des umgebenden Rechtecks der Ellipse
+         * @param breite Breite des umgebenden Rechtecks der Ellipse
+         * @param höhe Höhe des umgebenden Rechtecks der Ellipse
+         * @param farbe (Füll)Farbe der Ellipse
+         */
+        void FigurteilFestlegenEllipse (int x, int y, int breite, int höhe, String farbe)
+        {
+            synchronized (eigeneFigur)
+            {
+                eigeneFigur.add(new FigurenElementEllipse(x, y, breite, höhe, FarbeCodieren(farbe)));
+            }
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+
+        /**
+         * Erzeugt ein neues, dreieckiges Element einer eigenen Darstellung der Figur.
+         * Alle Werte beziehen sich auf eine Figur der Größe 100 und den Koordinaten (0|0) in der Mitte des Quadrats
+         * @param x1 x-Wert des ersten Punkts des Dreiecks
+         * @param y1 y-Wert des ersten Punkts des Dreiecks
+         * @param x2 x-Wert des zweiten Punkts des Dreiecks
+         * @param y2 y-Wert des zweiten Punkts des Dreiecks
+         * @param x3 x-Wert des dritten Punkts des Dreiecks
+         * @param y3 y-Wert des dritten Punkts des Dreiecks
+         * @param farbe (Füll)Farbe der Ellipse
+         */
+        void FigurteilFestlegenDreieck (int x1, int y1, int x2, int y2, int x3, int y3, String farbe)
+        {
+            synchronized (eigeneFigur)
+            {
+                int[] x = new int [] {x1, x2, x3};
+                int[] y = new int [] {y1, y2, y3};
+                eigeneFigur.add(new FigurenElementPolygon(x, y, FarbeCodieren(farbe)));
+            }
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+        
+        /**
+         * Löscht die Vereinbarung für die eigene Darstellung Figur.
+         * Die Figur wird wieder durch die Originalfigur dargestellt.
+         */
+        void EigeneFigurLöschen()
+        {
+            eigeneFigur.clear();
+            FormErzeugen();
+            zeichenfläche.malfläche.repaint();
+        }
+
+        /**
+         * Zeichnet das Objekt als Dreieck in der gegebenen Farbe.
+         * @param g das Grafikobjekt zum Zeichnen
+         */
+        @Override void Zeichnen(Graphics g)
+        {
+            Graphics2D g2 = (Graphics2D) g;
+            // Outline
+            g.setColor(Color.black);
+            Stroke stAlt = g2.getStroke();
+            g2.setStroke(new BasicStroke(3.0f));
+            g2.draw(form);
+            g2.setStroke(stAlt);
+            // Füllung
+            double größe = h > b ? b : h;
+            AffineTransform alt = g2.getTransform();
+            g2.rotate(DrehwinkelGeben (winkel), x, y);
+            if (standardFigur != null)
+            {
+                LinkedList<FigurenElement> figur = ((eigeneFigur == null) || (eigeneFigur.size() == 0)) ? standardFigur : eigeneFigur;
+                synchronized (figur)
+                {
+                    for (FigurenElement e: figur)
+                    {
+                        e.ElementZeichnen(g2, größe, x, y);
+                    }
+                }
+            }
+            g2.setTransform(alt);
+        }
+    }
+}
diff --git a/Info/10/2/Baelle/BlueJ_Projekt/package.bluej b/Info/10/2/Baelle/BlueJ_Projekt/package.bluej
new file mode 100644
index 00000000..15f0117c
--- /dev/null
+++ b/Info/10/2/Baelle/BlueJ_Projekt/package.bluej
@@ -0,0 +1,134 @@
+#BlueJ package file
+dependency1.from=Turtle
+dependency1.to=Zeichenfenster
+dependency1.type=UsesDependency
+dependency10.from=Text
+dependency10.to=Zeichenfenster
+dependency10.type=UsesDependency
+dependency11.from=Dreieck
+dependency11.to=Zeichenfenster
+dependency11.type=UsesDependency
+dependency12.from=Kreis
+dependency12.to=Zeichenfenster
+dependency12.type=UsesDependency
+dependency13.from=Ball
+dependency13.to=Zeichenfenster
+dependency13.type=UsesDependency
+dependency2.from=Rechteck
+dependency2.to=Zeichenfenster
+dependency2.type=UsesDependency
+dependency3.from=Ereignisbehandlung
+dependency3.to=Zeichenfenster
+dependency3.type=UsesDependency
+dependency4.from=Zeichenfenster
+dependency4.to=Rechteck
+dependency4.type=UsesDependency
+dependency5.from=Zeichenfenster
+dependency5.to=Dreieck
+dependency5.type=UsesDependency
+dependency6.from=Zeichenfenster
+dependency6.to=Kreis
+dependency6.type=UsesDependency
+dependency7.from=Zeichenfenster
+dependency7.to=Turtle
+dependency7.type=UsesDependency
+dependency8.from=Zeichenfenster
+dependency8.to=Figur
+dependency8.type=UsesDependency
+dependency9.from=Figur
+dependency9.to=Zeichenfenster
+dependency9.type=UsesDependency
+editor.fx.0.height=1055
+editor.fx.0.width=960
+editor.fx.0.x=2880
+editor.fx.0.y=0
+objectbench.height=318
+objectbench.width=1896
+package.divider.horizontal=0.6
+package.divider.vertical=0.6723790322580645
+package.editor.height=660
+package.editor.width=1769
+package.editor.x=1920
+package.editor.y=0
+package.frame.height=1055
+package.frame.width=1920
+package.numDependencies=13
+package.numTargets=10
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=60
+readme.name=@README
+readme.width=49
+readme.x=10
+readme.y=10
+target1.height=70
+target1.name=Ball
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=120
+target1.x=190
+target1.y=80
+target10.height=70
+target10.name=Kreis
+target10.showInterface=false
+target10.type=ClassTarget
+target10.width=120
+target10.x=370
+target10.y=80
+target2.height=70
+target2.name=Turtle
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=120
+target2.x=720
+target2.y=10
+target3.height=70
+target3.name=Flummi
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=120
+target3.x=10
+target3.y=80
+target4.height=70
+target4.name=Rechteck
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=120
+target4.x=720
+target4.y=10
+target5.height=70
+target5.name=Ereignisbehandlung
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=170
+target5.x=720
+target5.y=10
+target6.height=70
+target6.name=Zeichenfenster
+target6.showInterface=false
+target6.type=ClassTarget
+target6.width=140
+target6.x=480
+target6.y=170
+target7.height=70
+target7.name=Figur
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=120
+target7.x=720
+target7.y=10
+target8.height=70
+target8.name=Text
+target8.showInterface=false
+target8.type=ClassTarget
+target8.width=120
+target8.x=720
+target8.y=10
+target9.height=70
+target9.name=Dreieck
+target9.showInterface=false
+target9.type=ClassTarget
+target9.width=120
+target9.x=720
+target9.y=10