# Grafik 2d Objekte farblich ausfüllen



## arxior (14. Dez 2008)

Halli Hallo, 
ich bin grade dabei mit Grafik 2d zu experimentieren und zu lernen, und versuche dies anhand eines Beispiels, bzw durch die erweiterung eines gegebenen beispieles. Ich möchte hinzufügen, dass ich durch eine methode oder auch schon bei der konstruktion das Rechteck farblich ausfüllen kann.
ich benutze bluej!

Hier mein bisheriger code. ich habe es schon mit befehlen wie: 

g2.setPaint(Color.red),
 g2.fill(p); 

versucht, jedoch wusste ich nicht was ich für g2 und p einsetzen sollte. hab dementsprechend rumprobiert, einmal als methode und bei gibAktuelleFigur(); und hab sämtliche variablen die passen könnten eingesetzt.

hoffentlich kann mir jemand helfen, 
lg arxi


```
import java.awt.Shape;
import java.awt.geom.GeneralPath;
import java.awt.geom.Rectangle2D;
import java.awt.geom.Line2D;
import java.awt.geom.AffineTransform;
import java.awt.*;


public class Bett
{
    private int xPosition;
    private int yPosition;
    private int orientierung;
    private String farbe;
    private boolean istSichtbar;
    private int breite;
    private int tiefe;


    /**
     * Erzeuge ein neues Bett mit einer Standardfarbe und Standardgroesse
     * an einer Standardposition. (Standardkonstruktor)
     */
    public Bett() {
        xPosition = 60;
        yPosition = 20;
        farbe = "schwarz";
        orientierung = 0;
        istSichtbar = false;
        breite = 140;
        tiefe  = 200;
    }
    
    /**
     * Berechnet das zu zeichnende Shape anhand der gegebenen Daten
     * [ Zum Anzeigen der Attributwerte über Inspect muss hier die Sichtbarkeit 
     *  auf public gesetzt werden. ]
     */
    private Shape gibAktuelleFigur() {
        // einen GeneralPath definieren
        GeneralPath bett = new GeneralPath();
        Rectangle2D rahmen = new Rectangle2D.Double(0, 0, breite, tiefe);
       bett.append(rahmen,false);

         // transformieren:
        AffineTransform t = new AffineTransform();
        t.translate(xPosition, yPosition);
        Rectangle2D umriss = bett.getBounds2D();
        t.rotate(Math.toRadians(orientierung),umriss.getX()+umriss.getWidth()/2,umriss.getY()+umriss.getHeight()/2);
        return  t.createTransformedShape(bett);

    }
    
    /**
     * Mache dieses Objekt sichtbar. Wenn es bereits sichtbar ist, tue nichts.
     */
    public void zeige() {
        if (!istSichtbar) {
            istSichtbar = true;
            zeichne();
        }
    }
    
    /**
     * Mache dieses Objekt unsichtbar. Wenn es bereits unsichtbar ist, tue nichts.
     */
    public void verberge() {
        loesche(); // "tue nichts" wird in loesche() abgefangen.
        istSichtbar = false;
    }
    
    /**
     * Drehe auf den angegebenen Winkel
     */
    public void dreheAuf(int neuerWinkel) {
        loesche();
        orientierung = neuerWinkel;
        zeichne();
    }
    
    /**
     * Bewege dieses Objekt horizontal um 'entfernung' Bildschirmpunkte.
     */
    public void bewegeHorizontal(int entfernung) {
        loesche();
        xPosition += entfernung;
        zeichne();
    }
    
    /**
     * Bewege dieses objekt vertikal um 'entfernung' Bildschirmpunkte.
     */
    public void bewegeVertikal(int entfernung) {
        loesche();
        yPosition += entfernung;
        zeichne();
    }
    
    
    /**
     * Aendere die Farbe dieses Objektes in 'neueFarbe'.
     * Gueltige Angaben sind "rot", "gelb", "blau", "gruen",
     * "lila" und "schwarz".
     */
    public void aendereFarbe(String neueFarbe) {
        loesche();
        farbe = neueFarbe;
        zeichne();
    }
    
    /**
     * Zeichne dieses Objekt mit seinen aktuellen Werten auf den Bildschirm.
     */
    private void zeichne() {
        if (istSichtbar) {
            Shape figur = gibAktuelleFigur();
            Leinwand leinwand = Leinwand.gibLeinwand();
            leinwand.zeichne (
              this,           // leinwand kennt das Objekt
              farbe,          // definiert seine Zeichenfarbe
              figur);         // definiert seinen grafischen Aspekt
            leinwand.warte(10);
        }
    }

    /**
     * Loesche dieses Objekt vom Bildschirm.
     */
    private void loesche() {
        if (istSichtbar){
            Leinwand leinwand = Leinwand.gibLeinwand();
            leinwand.entferne(this);
        }
    }
}
```



Update#1

im irc habe ich mit Xandro geschnackt, welcher mir folgenden code empfahl:

```
public void paint(Graphics g) {
        Graphics2D graphics2 = (Graphics2D) g;
        Rectangle2D rectangle = new Rectangle2D.Float(100, 100, 240, 160);
        graphics2.draw(rectangle);
        graphics2.setPaint(Color.RED);
        graphics2.fill(rectangle);
    }
```

wenn ich die methode jetzt einsetze und ausführe verlangt er( das programm, bluej), dass ich einen wert eingebe.
ich weiß nicht weiter, weil das was er mir gegeben hat sollte eigtl klappen
[/code]


----------



## Marco13 (14. Dez 2008)

"verlangt er( das programm, bluej), dass ich einen wert eingebe. "

Beschreib' das mal etwas genauer.

Man müßte die Klasse "Leinwand" kennen. Das "g2" ist eigentlich das Graphics2D-Objekt, das zum zeichnen verwendet wird......


----------



## arxior (14. Dez 2008)

```
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Shape;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * Leinwand ist eine Klasse, die einfache Zeichenoperationen auf einer
 * leinwandartigen Zeichenfläche ermöglicht.
 * Sie ist eine vereinfachte Version der Klasse Canvas (englisch für 
 * Leinwand) des JDK und wurde speziell für das Projekt "Figuren"
 * geschrieben.
 * 
 *
 * @author: Bruce Quig
 * @author: Michael Kölling (mik)
 * @author: Axel Schmolitzky
 * 
 * @author: Änderungen von
 * @Java-MS Groupies
 * @hier: Uwe Debacher
 *
 * @version: 1.7 (5.12.2003)
 */
public class Leinwand
{
  // Hinweis: Die Implementierung dieser Klasse (insbesondere die
  // Verwaltung der Farben und Identitäten der Figuren) ist etwas
  // komplizierter als notwendig. Dies ist absichtlich so, weil damit 
  // die Schnittstellen und Exemplarvariablen der Figuren-Klassen
  // für den Lernanspruch dieses Projekts einfacher und klarer
  // sein können.

  private static Leinwand leinwandSingleton;

  /**
   * Fabrikmethode, die eine Referenz auf das einzige Exemplar
   * dieser Klasse zurückliefert. Wenn es von einer Klasse nur
   * genau ein Exemplar gibt, wird dieses als 'Singleton'
   * bezeichnet.
   */
  public static Leinwand gibLeinwand()
  {
    if (leinwandSingleton == null)
    {
      leinwandSingleton =
        new Leinwand("Möbelprojekt Grafik", 400, 400, Color.white);
    }
    leinwandSingleton.setzeSichtbarkeit(true);
    return leinwandSingleton;
  }

  //  ----- Exemplarvariablen -----

  private JFrame fenster;
  private Zeichenflaeche zeichenflaeche;
  private Graphics2D graphic;
  private Color hintergrundfarbe;
  private Image leinwandImage;
  private List figuren;
  private Map figurZuShape; // Abbildung von Figuren zu Shapes

  /**
   * Erzeuge eine Leinwand.
   * @param titel  Titel, der im Rahmen der Leinwand angezeigt wird
   * @param breite  die gewünschte Breite der Leinwand
   * @param hoehe  die gewünschte Höhe der Leinwand
   * @param grundfarbe die Hintergrundfarbe der Leinwand
   */
  private Leinwand(String titel, int breite, int hoehe, Color grundfarbe)
  {
    fenster = new JFrame();
    zeichenflaeche = new Zeichenflaeche();
    fenster.setContentPane(zeichenflaeche);
    fenster.setTitle(titel);
    zeichenflaeche.setPreferredSize(new Dimension(breite, hoehe));
    hintergrundfarbe = grundfarbe;
    fenster.pack();
    figuren = new ArrayList();
    figurZuShape = new HashMap();

}


  /**
   * Setze, ob diese Leinwand sichtbar sein soll oder nicht. Wenn die
   * Leinwand sichtbar gemacht wird, wird ihr Fenster in den
   * Vordergrund geholt. Diese Operation kann auch benutzt werden, um 
   * ein bereits sichtbares Leinwandfenster in den Vordergrund (vor
   * andere Fenster) zu holen.
   * @param sichtbar boolean für die gewünschte Sichtbarkeit: 
   * true für sichtbar, false für nicht sichtbar.
   */
  public void setzeSichtbarkeit(boolean sichtbar)
  {
    if (graphic == null)
    {
      // erstmaliger Aufruf: erzeuge das Bildschirm-Image und fülle
      // es mit der Hintergrundfarbe
      Dimension size = zeichenflaeche.getSize();
      leinwandImage = zeichenflaeche.createImage(size.width, size.height);
      graphic = (Graphics2D) leinwandImage.getGraphics();
      graphic.setColor(hintergrundfarbe);
      graphic.fillRect(0, 0, size.width, size.height);
      graphic.setColor(Color.black);
    }
    fenster.setVisible(sichtbar);
  }

  /**
   * Zeichne für das gegebene Figur-Objekt eine Java-Figur (einen Shape)
   * auf die Leinwand.
   * @param  figur  das Figur-Objekt, für das ein Shape gezeichnet
   *                 werden soll
   * @param  farbe  die Farbe der Figur
   * @param  shape  ein Objekt der Klasse Shape, das tatsächlich
   *                 gezeichnet wird
   */
  public void zeichne(Object figur, String farbe, Shape shape)
  {
    figuren.remove(figur); // entfernen, falls schon eingetragen
    figuren.add(figur); // am Ende hinzufügen
    figurZuShape.put(figur, new ShapeMitFarbe(shape, farbe));
    erneutZeichnen();
  }

  /**
   * Entferne die gegebene Figur von der Leinwand.
   * @param  figur  die Figur, deren Shape entfernt werden soll
   */
  public void entferne(Object figur)
  {
    figuren.remove(figur); // entfernen,falls schon eingetragen
    figurZuShape.remove(figur);
    erneutZeichnen();
  }

  /**
   * Setze die Zeichenfarbe der Leinwand.
   * @param  farbname der Name der neuen Zeichenfarbe.
   */
  public void setzeZeichenfarbe(String farbname)
  {
    if (farbname.equals("rot"))
      graphic.setColor(Color.red);
    else if (farbname.equals("schwarz"))
      graphic.setColor(Color.black);
    else if (farbname.equals("blau"))
      graphic.setColor(Color.blue);
    else if (farbname.equals("gelb"))
      graphic.setColor(Color.yellow);
    else if (farbname.equals("gruen"))
      graphic.setColor(Color.green);
    else if (farbname.equals("lila"))
      graphic.setColor(Color.magenta);
    else if (farbname.equals("weiss"))
      graphic.setColor(Color.white);
    else
      graphic.setColor(Color.black);
  }

  /**
   * Warte für die angegebenen Millisekunden.
   * Mit dieser Operation wird eine Verzögerung definiert, die
   * für animierte Zeichnungen benutzt werden kann.
   * @param  millisekunden die zu wartenden Millisekunden
   */
  public void warte(int millisekunden)
  {
    try
    {
      Thread.sleep(millisekunden);
    }
    catch (Exception e)
    {
      // Exception ignorieren
    }
  }

  /**
   * Zeichne erneut alle Figuren auf der Leinwand.
   */
  private void erneutZeichnen()
  {
    loeschen();
    for (Iterator i = figuren.iterator(); i.hasNext();)
    {
      ((ShapeMitFarbe) figurZuShape.get(i.next())).draw(graphic);
    }
    zeichenflaeche.repaint();
  }

  /**
   * Lösche die gesamte Leinwand.
   */
  private void loeschen()
  {
    Color original = graphic.getColor();
    graphic.setColor(hintergrundfarbe);
    Dimension size = zeichenflaeche.getSize();
    graphic.fill(new Rectangle(0, 0, size.width, size.height));
    graphic.setColor(original);
  }

  /************************************************************************
   * Interne Klasse Zeichenflaeche - die Klasse für die GUI-Komponente,
   * die tatsächlich im Leinwand-Fenster angezeigt wird. Diese Klasse
   * definiert ein JPanel mit der zusätzlichen Möglichkeit, das auf ihm
   * gezeichnet Image aufzufrischen (erneut zu zeichnen).
   */
  private class Zeichenflaeche extends JPanel
  {
    public void paint(Graphics g)
    {
      g.drawImage(leinwandImage, 0, 0, null);
    }
  }

  /************************************************************************
   * Interne Klasse ShapeMitFarbe - Da die Klasse Shape des JDK nicht auch
   * eine Farbe mitverwalten kann, muss mit dieser Klasse die Verknüpfung
   * modelliert werden.
   * graphic.fill() durch graphic.draw() ersetzt von Uwe Debacher am 5.12.2003
   */
  private class ShapeMitFarbe
  {
    private Shape shape;
    private String farbe;

    public ShapeMitFarbe(Shape shape, String farbe)
    {
      this.shape = shape;
      this.farbe = farbe;
    }

    public void draw(Graphics2D graphic)
    {
      setzeZeichenfarbe(farbe);
      graphic.draw(shape);
    }
  }

}
```
wobei ich muss sagen, dass ich die leinwand nicht unbedingt benutzen will, sondern auch gern ne andere nehme 
hatte halt keine andere.
hier screenshot 






danke für die hilfe


----------



## Marco13 (15. Dez 2008)

Weiß irgendjemand, der BlueJ kennt, was diese Eingabeaufforderung bedeuten soll  ???:L


----------



## andre111 (15. Dez 2008)

durch benutzerauswahl wird die methode paint aufgerufen und bluej frägt den benutzer nun nach den nötigen parametern.
muss mit der sch**** in der schule auch arbeiten... -.-


----------



## Marco13 (15. Dez 2008)

Ja, aber was soll man da eintiippen? Eine Serialisierte version eines "Graphics"-Objektes?  :lol:  ???:L


----------



## arxior (15. Dez 2008)

ich bin auch ratlos, deswegen frag ich ja :/


----------



## Marco13 (15. Dez 2008)

Ja moment mal - wenn du "die Methode ausführst"...?! Also, ich weiß nicht, welche Möglichkeiten dieses BlueJ da bietet, aber... normalerweise solltest du doch irgendwo eine main-Methode haben - und DIE solltest du zum starten verwenden!?


----------



## Landei (15. Dez 2008)

Nee, das hat BlueJ nicht - man will ja die Kinderchen nicht mit static und ähnlichem Nicht-OO-BähBäh belasten...


----------



## arxior (15. Dez 2008)

Landei hat gesagt.:
			
		

> Nee, das hat BlueJ nicht - man will ja die Kinderchen nicht mit static und ähnlichem Nicht-OO-BähBäh belasten...


und wie führe ich das nun aus? :O

und um auf meine ursprüngliche frage zurück zu kommen, wie fülle ich die "konturen" die ich sonst nur mit grafik 2d gezeichnet habe farblich aus, wenn oben gezeigtes nicht funktioniert :/


----------



## Landei (15. Dez 2008)

Sorry, ich hatte irgendwann mal einen kurzen Blick auf BlueJ geworfen und mich dann angewidert und entsetzt abgewandt...

Traurig, dass man so ein Verkrüppelungstool auf euch losläßt.


----------



## Marco13 (15. Dez 2008)

Ja, was auch immer: Nimm' das "paint" wieder raus. Der Leinwand-Klasse nach zu urteilen müsst du nur in deiner ursprünglichen Klasse
aendereFarbe("rot");
oder so aufrufen - WO du das aufrufen musst ... schwer zu sagen... kannst's mal als erste Zeile von gibAktuelleFigur einfügen....


----------



## arxior (15. Dez 2008)

aendereFarbe ändert nur die farbe des umrisses des Rechtecks und bringt dementsprechend nichts :/
vielen dank für die hilfe schonmal


----------



## Marco13 (15. Dez 2008)

Aaahhsooo... OK, es gibt ja diese "ShapeMitFarbe", wo irgendwo
graphic.draw(shape); 
aufgerufen wird.
Wenn man das durch
graphic.*fill*(shape); 
ersetzen würde, wäre das ganze schon gefüllt. Wenn du auswählen willst, ob gefüllt oder nicht, musst du ein "boolean filled"-Flag ähnlich .... weiterreichen wie jetzt schon die "farbe".


----------



## arxior (15. Dez 2008)

woah du bist so ein schlaui ^__^ 
danke

ich werd mal gucken ob ich das mit dem boolean hinbekomme, sonst melde ich mich nochmal 

vielen dank  :applaus:


----------



## arxior (15. Dez 2008)

okay klappt, vielen dank!!!
hier die Lösung:


```
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Shape;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * Leinwand ist eine Klasse, die einfache Zeichenoperationen auf einer
 * leinwandartigen Zeichenfläche ermöglicht.
 * Sie ist eine vereinfachte Version der Klasse Canvas (englisch für 
 * Leinwand) des JDK und wurde speziell für das Projekt "Figuren"
 * geschrieben.
 * 
 *
 * @author: Bruce Quig
 * @author: Michael Kölling (mik)
 * @author: Axel Schmolitzky
 * 
 * @author: Änderungen von
 * @Java-MS Groupies
 * @hier: Uwe Debacher
 *
 * @version: 1.7 (5.12.2003)
 */
public class Leinwand
{
  // Hinweis: Die Implementierung dieser Klasse (insbesondere die
  // Verwaltung der Farben und Identitäten der Figuren) ist etwas
  // komplizierter als notwendig. Dies ist absichtlich so, weil damit 
  // die Schnittstellen und Exemplarvariablen der Figuren-Klassen
  // für den Lernanspruch dieses Projekts einfacher und klarer
  // sein können.

  private static Leinwand leinwandSingleton;

  /**
   * Fabrikmethode, die eine Referenz auf das einzige Exemplar
   * dieser Klasse zurückliefert. Wenn es von einer Klasse nur
   * genau ein Exemplar gibt, wird dieses als 'Singleton'
   * bezeichnet.
   */
  public static Leinwand gibLeinwand()
  {
    if (leinwandSingleton == null)
    {
      leinwandSingleton =
        new Leinwand("Möbelprojekt Grafik", 400, 400, Color.white);
    }
    leinwandSingleton.setzeSichtbarkeit(true);
    return leinwandSingleton;
  }

  //  ----- Exemplarvariablen -----

  private JFrame fenster;
  private Zeichenflaeche zeichenflaeche;
  private Graphics2D graphic;
  private Color hintergrundfarbe;
  private Image leinwandImage;
  private List figuren;
  private Map figurZuShape; // Abbildung von Figuren zu Shapes

  /**
   * Erzeuge eine Leinwand.
   * @param titel  Titel, der im Rahmen der Leinwand angezeigt wird
   * @param breite  die gewünschte Breite der Leinwand
   * @param hoehe  die gewünschte Höhe der Leinwand
   * @param grundfarbe die Hintergrundfarbe der Leinwand
   */
  private Leinwand(String titel, int breite, int hoehe, Color grundfarbe)
  {
    fenster = new JFrame();
    zeichenflaeche = new Zeichenflaeche();
    fenster.setContentPane(zeichenflaeche);
    fenster.setTitle(titel);
    zeichenflaeche.setPreferredSize(new Dimension(breite, hoehe));
    hintergrundfarbe = grundfarbe;
    fenster.pack();
    figuren = new ArrayList();
    figurZuShape = new HashMap();

}


  /**
   * Setze, ob diese Leinwand sichtbar sein soll oder nicht. Wenn die
   * Leinwand sichtbar gemacht wird, wird ihr Fenster in den
   * Vordergrund geholt. Diese Operation kann auch benutzt werden, um 
   * ein bereits sichtbares Leinwandfenster in den Vordergrund (vor
   * andere Fenster) zu holen.
   * @param sichtbar boolean für die gewünschte Sichtbarkeit: 
   * true für sichtbar, false für nicht sichtbar.
   */
  public void setzeSichtbarkeit(boolean sichtbar)
  {
    if (graphic == null)
    {
      // erstmaliger Aufruf: erzeuge das Bildschirm-Image und fülle
      // es mit der Hintergrundfarbe
      Dimension size = zeichenflaeche.getSize();
      leinwandImage = zeichenflaeche.createImage(size.width, size.height);
      graphic = (Graphics2D) leinwandImage.getGraphics();
      graphic.setColor(hintergrundfarbe);
      graphic.fillRect(0, 0, size.width, size.height);
      graphic.setColor(Color.black);
    }
    fenster.setVisible(sichtbar);
  }

  /**
   * Zeichne für das gegebene Figur-Objekt eine Java-Figur (einen Shape)
   * auf die Leinwand.
   * @param  figur  das Figur-Objekt, für das ein Shape gezeichnet
   *                 werden soll
   * @param  farbe  die Farbe der Figur
   * @param  shape  ein Objekt der Klasse Shape, das tatsächlich
   *                 gezeichnet wird
   */
  public void zeichne(Object figur, String farbe, Shape shape, boolean filled)
  {
    figuren.remove(figur); // entfernen, falls schon eingetragen
    figuren.add(figur); // am Ende hinzufügen
    figurZuShape.put(figur, new ShapeMitFarbe(shape, farbe, filled));
    erneutZeichnen();
  }

  /**
   * Entferne die gegebene Figur von der Leinwand.
   * @param  figur  die Figur, deren Shape entfernt werden soll
   */
  public void entferne(Object figur)
  {
    figuren.remove(figur); // entfernen,falls schon eingetragen
    figurZuShape.remove(figur);
    erneutZeichnen();
  }

  /**
   * Setze die Zeichenfarbe der Leinwand.
   * @param  farbname der Name der neuen Zeichenfarbe.
   */
  public void setzeZeichenfarbe(String farbname)
  {
    if (farbname.equals("rot"))
      graphic.setColor(Color.red);
    else if (farbname.equals("schwarz"))
      graphic.setColor(Color.black);
    else if (farbname.equals("blau"))
      graphic.setColor(Color.blue);
    else if (farbname.equals("gelb"))
      graphic.setColor(Color.yellow);
    else if (farbname.equals("gruen"))
      graphic.setColor(Color.green);
    else if (farbname.equals("lila"))
      graphic.setColor(Color.magenta);
    else if (farbname.equals("weiss"))
      graphic.setColor(Color.white);
    else
      graphic.setColor(Color.black);
  }

  /**
   * Warte für die angegebenen Millisekunden.
   * Mit dieser Operation wird eine Verzögerung definiert, die
   * für animierte Zeichnungen benutzt werden kann.
   * @param  millisekunden die zu wartenden Millisekunden
   */
  public void warte(int millisekunden)
  {
    try
    {
      Thread.sleep(millisekunden);
    }
    catch (Exception e)
    {
      // Exception ignorieren
    }
  }

  /**
   * Zeichne erneut alle Figuren auf der Leinwand.
   */
  private void erneutZeichnen()
  {
    loeschen();
    for (Iterator i = figuren.iterator(); i.hasNext();)
    {
      ((ShapeMitFarbe) figurZuShape.get(i.next())).draw(graphic);
    }
    zeichenflaeche.repaint();
  }

  /**
   * Lösche die gesamte Leinwand.
   */
  private void loeschen()
  {
    Color original = graphic.getColor();
    graphic.setColor(hintergrundfarbe);
    Dimension size = zeichenflaeche.getSize();
    graphic.fill(new Rectangle(0, 0, size.width, size.height));
    graphic.setColor(original);
  }

  /************************************************************************
   * Interne Klasse Zeichenflaeche - die Klasse für die GUI-Komponente,
   * die tatsächlich im Leinwand-Fenster angezeigt wird. Diese Klasse
   * definiert ein JPanel mit der zusätzlichen Möglichkeit, das auf ihm
   * gezeichnet Image aufzufrischen (erneut zu zeichnen).
   */
  private class Zeichenflaeche extends JPanel
  {
    public void paint(Graphics g)
    {
      g.drawImage(leinwandImage, 0, 0, null);
    }
  }

  /************************************************************************
   * Interne Klasse ShapeMitFarbe - Da die Klasse Shape des JDK nicht auch
   * eine Farbe mitverwalten kann, muss mit dieser Klasse die Verknüpfung
   * modelliert werden.
   * graphic.fill() durch graphic.draw() ersetzt von Uwe Debacher am 5.12.2003
   */
  private class ShapeMitFarbe
  {
    private Shape shape;
    private String farbe;
    private boolean filled;
    
    public ShapeMitFarbe(Shape shape, String farbe, boolean filled)
    {
      this.shape = shape;
      this.farbe = farbe;
      this.filled = filled;
    }

    public void draw(Graphics2D graphic)
    {
      setzeZeichenfarbe(farbe);
      if (filled==true)
      {
      graphic.fill(shape);
    }
    else {
    graphic.draw(shape);
          }
    }
  }

}
```


----------

