Initial sharing of project

Aufbau.java

@@ -0,0 +1,22 @@
+
+/**
+ * Baut im Konstruktor das Szenarium auf
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+class Aufbau
+{
+
+    /**
+     * Legt die benötigten Objekte an.
+     */
+    Aufbau ()
+    {
+        new KreisBesser(150, 150, 50, "rot");
+        new DreieckBesser(200, 50, 60, 50, "grün");
+        new RechteckBesser(100, 220, 200, 50, "grün");
+        new RechteckBesser(270, 60, 130, 70, "blau");
+        new DreieckBesser(350, 190, 70, 80, "rot");
+    }
+}

Aufbau2.java

@@ -0,0 +1,26 @@
+
+import java.util.*;
+/**
+ * Baut im Konstruktor das Szenarium auf
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+class Aufbau2
+{
+    /** der Zufallsgenerator */
+    Random zufall;
+    
+    /**
+     * Legt die benötigten Objekte an.
+     */
+    Aufbau2 ()
+    {
+        zufall = new Random();
+        new RechteckBesser(zufall.nextInt(400), zufall.nextInt(200), 200, 50, "grün");
+        new RechteckBesser(zufall.nextInt(400), zufall.nextInt(200), 130, 70, "blau");
+        new DreieckBesser(zufall.nextInt(400) + 50, zufall.nextInt(200), 60, 50, "grün");
+        new DreieckBesser(zufall.nextInt(400) + 50, zufall.nextInt(200), 70, 80, "rot");
+        new KreisBesser(zufall.nextInt(400) + 50, zufall.nextInt(150) + 50, 50, "rot");
+    }
+}

Dreieck.java

@@ -0,0 +1,171 @@
+
+/**
+ * Wrapperklasse für ein Dreieck auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Dreieck
+{
+    /** x-Position der Spitze. */
+    private int x;
+    /** y-Position der Spitze. */
+    private int y;
+    /** Breite des umgebenden Rechtecks. */
+    private int breite;
+    /** Höhe des umgebenden Rechtecks. */
+    private int höhe;
+    /** Farbe des Dreiecks. */
+    private String farbe;
+    /** Sichtbarkeit des Dreiecks. */
+    private boolean sichtbar;
+    /** Drehwinkel (mathematisch positiver Drehsinn) des Dreiecks in Grad. */
+    private 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();
+    }
+}

DreieckBesser.java

@@ -0,0 +1,26 @@
+
+/**
+ * Erlaubt das vollständige Anlegen im Konstruktor.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+class DreieckBesser extends Dreieck
+{
+
+    /**
+     * Legt das Dreieck nach den gegebenen Daten an.
+     * @param x x-Position der Spitze
+     * @param y y-Position der Spitze
+     * @param breite Breite des Dreiecks
+     * @param höhe Höhe des Dreiecks
+     * @param farbe Farbe des Dreiecks
+     */
+    DreieckBesser (int x, int y, int breite, int höhe, String farbe)
+    {
+        super();
+        PositionSetzen(x, y);
+        GrößeSetzen(breite, höhe);
+        FarbeSetzen(farbe);
+    }
+}

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");
+    }
+}

Figur.java

@@ -0,0 +1,341 @@
+
+/**
+ * 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();
+    }
+}

Kreis.java

@@ -0,0 +1,166 @@
+
+/**
+ * Wrapperklasse für einen Kreis auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Kreis
+{
+    /** x-Position des Kreismittelpunktes. */
+    private int x;
+    /** y-Position des Kreismittelpunktes. */
+    private int y;
+    /** Radius des Kreises. */
+    private int radius;
+    /** Farbe des Kreises. */
+    private String farbe;
+    /** Sichtbarkeit des Kreises. */
+    private boolean sichtbar;
+    /** Drehwinkel (mathematisch positiver Drehsinn) des Kreises in Grad. */
+    private 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();
+    }
+}

KreisBesser.java

@@ -0,0 +1,25 @@
+
+/**
+ * Erlaubt das vollständige Anlegen im Konstruktor.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+class KreisBesser extends Kreis
+{
+
+    /**
+     * Legt den Kreis nach den gegebenen Daten an.
+     * @param x x-Position des Mittelpunkts
+     * @param y y-Position des Mittelpunkts
+     * @param radius Radius des Kreises
+     * @param farbe Farbe des Kreises
+     */
+    KreisBesser (int x, int y, int radius, String farbe)
+    {
+        super();
+        PositionSetzen(x, y);
+        RadiusSetzen(radius);
+        FarbeSetzen(farbe);
+    }
+}

README.TXT

@@ -0,0 +1,24 @@
+Projektbezeichnung:
+Grafikdokument
+
+Ziel:
+Ein erstes Einstiegsprojekt in die Entwicklungsumgebung BlueJ.
+Dient zur Wiederholung der Begriffe Klasse, Objekt, Attribut, Methode, etc. 
+aus dem Informatikunterricht der Unterstufe.
+
+Man kann verschiedene Figuren erzeugen, die mit ihrem zugehörigen Grafiksymbol
+in einem Grafikfenster eingezeichnet werden.
+
+Diese Figuren können durch den Aufruf von Methoden interaktiv verändert werden.
+Nach jedem Methodenaufruf wird das Grafiksymbol und damit die ganze Zeichnung
+automatisch angepasst.
+
+Start des Projekts:
+Erzeugen neuer Figur-Objekte über das Kontextmenü.
+
+Version:
+1.0
+
+Autor:
+A. Wiedemann
+

Rechteck.java

@@ -0,0 +1,170 @@
+
+/**
+ * Wrapperklasse für ein Rechteck auf der Zeichenfläche.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+public class Rechteck
+{
+    /** x-Position der linken oberen Ecke. */
+    private int x;
+    /** y-Position der linken oberen Ecke. */
+    private int y;
+    /** Breite des Rechtecks. */
+    private int breite;
+    /** Höhe des Rechtecks. */
+    private int höhe;
+    /** Farbe des Rechtecks. */
+    private String farbe;
+    /** Sichtbarkeit des Rechtecks. */
+    private boolean sichtbar;
+    /** Drehwinkel (mathematisch positiver Drehsinn) des Rechtecks in Grad. */
+    private 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();
+    }
+}

RechteckBesser.java

@@ -0,0 +1,26 @@
+
+/**
+ * Erlaubt das vollständige Anlegen im Konstruktor.
+ * 
+ * @author Albert Wiedemann 
+ * @version 1.0
+ */
+class RechteckBesser extends Rechteck
+{
+
+    /**
+     * Legt das Rechteck nach den gegebenen Daten an.
+     * @param x x-Position der linken oberen Ecke
+     * @param y y-Position der linken oberen Ecke
+     * @param breite Breite des Rechtecks
+     * @param höhe Höhe des Rechtecks
+     * @param farbe Farbe des Rechtecks
+     */
+    RechteckBesser (int x, int y, int breite, int höhe, String farbe)
+    {
+        super();
+        PositionSetzen(x, y);
+        GrößeSetzen(breite, höhe);
+        FarbeSetzen(farbe);
+    }
+}

Text.java

@@ -0,0 +1,193 @@
+
+/**
+ * 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();
+    }
+}

Turtle.java

@@ -0,0 +1,342 @@
+
+/**
+ * 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);
+    }
+}

package.bluej

@@ -0,0 +1,170 @@
+#BlueJ package file
+dependency1.from=Turtle
+dependency1.to=Zeichenfenster
+dependency1.type=UsesDependency
+dependency10.from=Aufbau
+dependency10.to=DreieckBesser
+dependency10.type=UsesDependency
+dependency11.from=Aufbau
+dependency11.to=RechteckBesser
+dependency11.type=UsesDependency
+dependency12.from=Ereignisbehandlung
+dependency12.to=Zeichenfenster
+dependency12.type=UsesDependency
+dependency13.from=Zeichenfenster
+dependency13.to=Rechteck
+dependency13.type=UsesDependency
+dependency14.from=Zeichenfenster
+dependency14.to=Dreieck
+dependency14.type=UsesDependency
+dependency15.from=Zeichenfenster
+dependency15.to=Kreis
+dependency15.type=UsesDependency
+dependency16.from=Zeichenfenster
+dependency16.to=Turtle
+dependency16.type=UsesDependency
+dependency17.from=Zeichenfenster
+dependency17.to=Figur
+dependency17.type=UsesDependency
+dependency18.from=Kreis
+dependency18.to=Zeichenfenster
+dependency18.type=UsesDependency
+dependency2.from=Rechteck
+dependency2.to=Zeichenfenster
+dependency2.type=UsesDependency
+dependency3.from=Aufbau2
+dependency3.to=RechteckBesser
+dependency3.type=UsesDependency
+dependency4.from=Aufbau2
+dependency4.to=DreieckBesser
+dependency4.type=UsesDependency
+dependency5.from=Aufbau2
+dependency5.to=KreisBesser
+dependency5.type=UsesDependency
+dependency6.from=Figur
+dependency6.to=Zeichenfenster
+dependency6.type=UsesDependency
+dependency7.from=Text
+dependency7.to=Zeichenfenster
+dependency7.type=UsesDependency
+dependency8.from=Dreieck
+dependency8.to=Zeichenfenster
+dependency8.type=UsesDependency
+dependency9.from=Aufbau
+dependency9.to=KreisBesser
+dependency9.type=UsesDependency
+editor.fx.0.height=0
+editor.fx.0.width=0
+editor.fx.0.x=0
+editor.fx.0.y=0
+objectbench.height=174
+objectbench.width=1256
+package.divider.horizontal=0.5998578535891969
+package.divider.vertical=0.6901248581157774
+package.editor.height=397
+package.editor.width=1132
+package.editor.x=0
+package.editor.y=0
+package.frame.height=686
+package.frame.width=1294
+package.numDependencies=18
+package.numTargets=13
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=60
+readme.name=@README
+readme.width=48
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=Turtle
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=80
+target1.x=510
+target1.y=100
+target10.height=50
+target10.name=KreisBesser
+target10.showInterface=false
+target10.type=ClassTarget
+target10.width=90
+target10.x=430
+target10.y=210
+target11.height=50
+target11.name=Zeichenfenster
+target11.showInterface=false
+target11.type=ClassTarget
+target11.width=120
+target11.x=70
+target11.y=20
+target12.height=50
+target12.name=DreieckBesser
+target12.showInterface=false
+target12.type=ClassTarget
+target12.width=110
+target12.x=290
+target12.y=240
+target13.height=50
+target13.name=Kreis
+target13.showInterface=false
+target13.type=ClassTarget
+target13.width=80
+target13.x=400
+target13.y=120
+target2.height=50
+target2.name=Rechteck
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=80
+target2.x=190
+target2.y=160
+target3.height=50
+target3.name=Aufbau2
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=80
+target3.x=780
+target3.y=310
+target4.height=50
+target4.name=Figur
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=80
+target4.x=620
+target4.y=80
+target5.height=50
+target5.name=Text
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=80
+target5.x=720
+target5.y=60
+target6.height=50
+target6.name=Dreieck
+target6.showInterface=false
+target6.type=ClassTarget
+target6.width=80
+target6.x=290
+target6.y=140
+target7.height=50
+target7.name=Aufbau
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=80
+target7.x=610
+target7.y=330
+target8.height=50
+target8.name=RechteckBesser
+target8.showInterface=false
+target8.type=ClassTarget
+target8.width=120
+target8.x=140
+target8.y=270
+target9.height=50
+target9.name=Ereignisbehandlung
+target9.showInterface=false
+target9.type=ClassTarget
+target9.width=150
+target9.x=820
+target9.y=40