Javadoc

src/main/java/schule/ngb/zm/ColorLayer.java

@@ -28,12 +28,22 @@ public class ColorLayer extends Layer {
 	 */
 	private Paint background;
 
+	/**
+	 * Erstellt eine neue Farbebene mit der angegebenen Farbe.
+	 * @param color Die Hintergrundfarbe.
+	 */
 	public ColorLayer( Color color ) {
 		this.color = color;
 		this.background = color.getJavaColor();
 		clear();
 	}
 
+	/**
+	 * Erstellt eine neue Farbebene mit der angegebenen Größe und Farbe.
+	 * @param width Breite der Ebene.
+	 * @param height Höhe der Ebene.
+	 * @param color Die Hintergrundfarbe.
+	 */
 	public ColorLayer( int width, int height, Color color ) {
 		super(width, height);
 		this.color = color;
@@ -41,16 +51,27 @@ public class ColorLayer extends Layer {
 		clear();
 	}
 
+	/**
+	 * {@inheritDoc}
+	 */
 	@Override
 	public void setSize( int width, int height ) {
 		super.setSize(width, height);
 		clear();
 	}
 
+	/**
+	 * Gibt die Hintergrundfarbe der Ebene zurück.
+	 * @return Die aktuelle Hintergrundfarbe.
+	 */
 	public Color getColor() {
 		return color;
 	}
 
+	/**
+	 * Setzt die Farbe der Ebene neu.
+	 * @param color Die neue Hintergrundfarbe.
+	 */
 	public void setColor( Color color ) {
 		this.color = color;
 		this.background = color.getJavaColor();

src/main/java/schule/ngb/zm/Drawable.java

@@ -3,14 +3,29 @@ package schule.ngb.zm;
 import java.awt.*;
 
 /**
- * Zeichenbare Objekte können auf eine Zeichenfläche gezeichnet werden.
+ * {@code Drawable} Objekte können auf eine Zeichenfläche gezeichnet werden. In
- * In der Regel werden sie einmal pro Frame gezeichnet.
+ * der Regel werden sie einmal pro Frame gezeichnet.
  */
 public interface Drawable {
 
 	/**
 	 * Gibt an, ob das Objekt derzeit sichtbar ist (also gezeichnet werden
 	 * muss).
+	 * <p>
+	 * Wie mit dieser Information umgegangen wird, ist nicht weiter festgelegt.
+	 * In der Regel sollte eine aufrufende Instanz zunächst prüfen, ob das
+	 * Objekt aktiv ist, und nur dann{@link #draw(Graphics2D)} aufrufen. Für
+	 * implementierende Klassen ist es aber gegebenenfalls auch sinnvoll, bei
+	 * Inaktivität den Aufruf von {@code draw(Graphics2D)} schnell abzubrechen:
+	 * <pre><code>
+	 * void draw( Graphics2D graphics ) {
+	 *     if( !isVisible() ) {
+	 *         return;
+	 *     }
+	 *
+	 *     // Objekt zeichnen..
+	 * }
+	 * </code></pre>
 	 *
 	 * @return {@code true}, wenn das Objekt sichtbar ist.
 	 */

src/main/java/schule/ngb/zm/Layer.java

@@ -6,14 +6,40 @@ import java.awt.Graphics2D;
 import java.awt.RenderingHints;
 import java.awt.image.BufferedImage;
 
+/**
+ * Basisklasse für Ebenen der {@link Zeichenleinwand}.
+ * <p>
+ * Die {@code Zeichenleinwand} besteht aus einer Reihe von Ebenen, die
+ * übereinandergelegt und von "unten" nach "oben" gezeichnet werden. Die Inhalte
+ * der oberen Ebenen können also Inhalte der darunterliegenden verdecken.
+ *
+ * Ebenen sind ein zentraler Bestandteil bei der Implementierung einer {@link Zeichenmaschine}.
+ * Es werden
+ * Sie erben von {@code Constants}, damit sie beim
+ */
 public abstract class Layer extends Constants implements Drawable, Updatable {
 
+	/**
+	 * Interner Puffer für die Ebene, der einmal pro Frame auf die
+	 * Zeichenleinwand übertragen wird.
+	 */
 	protected BufferedImage buffer;
 
+	/**
+	 * Der Grafikkontext der Ebene, der zum Zeichnen der Inhalte verwendet
+	 * wird.
+	 */
 	protected Graphics2D drawing;
 
+	/**
+	 * Ob die Ebene derzeit sichtbar ist.
+	 */
 	protected boolean visible = true;
 
+	/**
+	 * Ob die Ebene aktiv ist, also {@link #update(double) Updates} empfangen
+	 * soll.
+	 */
 	protected boolean active = true;
 
 
@@ -33,6 +59,12 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 		return buffer.getHeight();
 	}
 
+	/**
+	 * Ändert die Größe der Ebene auf die angegebene Größe.
+	 *
+	 * @param width Die neue Breite.
+	 * @param height Die neue Höhe.
+	 */
 	public void setSize( int width, int height ) {
 		if( buffer != null ) {
 			if( buffer.getWidth() != width || buffer.getHeight() != height ) {
@@ -44,8 +76,13 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 
 	}
 
+	/**
+	 * Gibt die Resourcen der Ebene frei.
+	 */
 	public void dispose() {
 		drawing.dispose();
+		drawing = null;
+		buffer = null;
 	}
 
 	/**

src/main/java/schule/ngb/zm/Updatable.java

@@ -1,21 +1,42 @@
 package schule.ngb.zm;
 
 /**
- * Aktualisierbare Objekte können in regelmäßigen Intervallen (meist einmal
+ * {@code Updatable} Objekte können in regelmäßigen Intervallen (meist einmal
- * pro Frame) ihren Zustand update. Diese Änderung kann abhängig vom
+ * pro Frame) ihren Zustand aktualisieren. Diese Änderung kann abhängig vom
  * Zeitintervall (in Sekunden) zum letzten Aufruf passieren.
  */
 public interface Updatable {
 
 	/**
 	 * Gibt an, ob das Objekt gerade auf Aktualisierungen reagiert.
-	 * @return {@code true}, wenn das Objekt aktiv ist.
+	 * <p>
+	 * Wie mit dieser Information umgegangen wird, ist nicht weiter festgelegt.
+	 * In der Regel sollte eine aufrufende Instanz zunächst prüfen, ob das
+	 * Objekt aktiv ist, und nur dann{@link #update(double)} aufrufen. Für
+	 * implementierende Klassen ist es aber gegebenenfalls auch sinnvoll, bei
+	 * Inaktivität den Aufruf von {@code update(double)} schnell abzubrechen:
+	 * <pre><code>
+	 * void update( double delta ) {
+	 *     if( !isActive() ) {
+	 *         return;
+	 *     }
+	 *
+	 *     // Aktualisierung ausführen..
+	 * }
+	 * </code></pre>
+	 *
+	 * @return {@code true}, wenn das Objekt aktiv ist, {@code false}
+	 * 	andernfalls.
 	 */
 	public boolean isActive();
 
 	/**
 	 * Änderung des Zustandes des Objekts abhängig vom Zeitintervall
-	 * <var>delta</var> in Sekunden.
+	 * {@code delta} in Sekunden.
+	 * <p>
+	 * Die kann, muss aber nicht, die Rückgabe von {@link #isActive()}
+	 * berücksichtigen.
+	 *
 	 * @param delta Zeitintervall seit dem letzten Aufruf (in Sekunden).
 	 */
 	public void update( double delta );