Changelog update

Ebene der Unterüberschrift auf h2 angepasst

CHANGELOG.md

@@ -6,6 +6,14 @@ und diese Projekt folgt [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+## Version 0.0.34
+
+### Added
+- `Faker`-Klasse zur Erzeugung von Fake-Daten hinzugefügt.
+- Dokumentation unter [zeichenmaschine.xyz](https://zeichenmaschine.xyz) mit 
+  [MkDocs](https://www.mkdocs.org) und [Material for MkDocs](https://squidfunk.github.io/mkdocs-material/).
+- Neue `image` methoden im `DrawingLayer`.
+
 ### Changed
 - `FilledShape` und `StrokedShape` durch `Fillable` und `Strokeable` Interfaces ersetzt.
 	- `Shape` erweitert nun `BasisDrawable` als abstrakte Grundlage.

build.gradle

@@ -4,7 +4,7 @@ plugins {
 }
 
 group 'schule.ngb'
-version '0.0.32-SNAPSHOT'
+version '0.0.34-SNAPSHOT'
 
 java {
 	withSourcesJar()
@@ -44,4 +44,5 @@ tasks.register('jarMP3SPI', Jar) {
 	from {
 		configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
 	}
+	with jar
 }

docs/einfuehrung.md

@@ -30,7 +30,7 @@ und für Schülerinnen und Schüler im Unterricht nutzbar machen.
 
 ## Dokumentation
 * [Schnellstart](quickstart.md)
-* [Installation](install.md)
+* [Installation](installation.md)
 * {{ javadoc_link() }}
 
 ## Über die Zeichenmaschine

docs/installation.md

@@ -42,3 +42,5 @@ Projekt in den Classpath aufgenommen werden:
 ### NetBeans
 
 > Coming soon
+
+## Unterstützung für MP3

docs/macros.py

@@ -50,7 +50,6 @@ def define_env(env):
             # _target = re.sub(r"([^(][^,]*?\.)*?([^)]+)", lambda m: m.group(2), target)
             _target = target
 
-            print(f'{_target.strip()=}')
             if m := re.match(r'^(.+?)\((.*)\)$', _target):
                 if strip_params and m.group(2):
                     params = m.group(2).split(',')

docs/quickstart.md

@@ -5,7 +5,7 @@ die [JAR-Datei der aktuellen Version](https://github.com/jneug/zeichenmaschine/r
 herunterzuladen und
 dem [Classpath](https://www.delftstack.com/de/howto/java/java-classpath-/)
 hinzuzufügen. Eine Beschreibung für verschiedene Entwicklungsumgebungen findet
-sich im Abschnitt [Installation](install.md).
+sich im Abschnitt [Installation](installation.md).
 
 ## Die Basisklasse
 

mkdocs.yml

@@ -37,9 +37,9 @@ extra_css:
     - assets/zmstyles.css
 
 nav:
-    - Einführung: index.md
+    -   Einführung: einfuehrung.md
-    - Schnellstart: quickstart.md
+    -   Schnellstart: schnellstart.md
-    - Installation: install.md
+    -   Installation: installation.md
     -   Tutorials:
             -   Aquarium: tutorials/aquarium/aquarium1.md
     -   Beispiele:

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

@@ -1,6 +1,9 @@
 package schule.ngb.zm;
 
-import java.awt.*;
+import java.awt.Graphics2D;
+import java.awt.MultipleGradientPaint;
+import java.awt.Paint;
+import java.awt.Stroke;
 
 /**
  * Basisimplementierung der {@link Strokeable} und {@link Fillable} APIs.
@@ -90,9 +93,6 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 
 	// Implementierung Fillable Interface
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setFill( Paint fill ) {
 		if( fill == null ) {
@@ -106,9 +106,6 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public Paint getFill() {
 		if( fill != null ) {
@@ -120,42 +117,27 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean hasFillColor() {
 		return fillColor != null;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean hasGradient() {
 		return fill != null;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public Color getFillColor() {
 		return fillColor;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setFillColor( Color color ) {
 		fillColor = color;
 		fill = null;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MultipleGradientPaint getGradient() {
 		return fill;
@@ -164,17 +146,11 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 
 	// Implementierung Strokeable Interface
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setStroke( Stroke stroke ) {
 		this.stroke = stroke;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public Stroke getStroke() {
 		if( stroke == null ) {
@@ -183,50 +159,32 @@ public abstract class BasicDrawable extends Constants implements Strokeable, Fil
 		return stroke;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public Color getStrokeColor() {
 		return strokeColor;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setStrokeColor( Color color ) {
 		strokeColor = color;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public double getStrokeWeight() {
 		return strokeWeight;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setStrokeWeight( double weight ) {
 		strokeWeight = weight;
 		this.stroke = null;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public Options.StrokeType getStrokeType() {
 		return strokeType;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setStrokeType( Options.StrokeType type ) {
 		strokeType = type;

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

@@ -88,7 +88,11 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 		} else {
 			createCanvas(width, height);
 		}
+	}
 
+	// TODO: prevent access to graphics context?
+	public Graphics2D getGraphics() {
+		return this.drawing;
 	}
 
 	/**
@@ -165,9 +169,6 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean isVisible() {
 		return visible;
@@ -197,16 +198,10 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 		visible = !visible;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void update( double delta ) {
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean isActive() {
 		return active;

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

@@ -57,9 +57,6 @@ public class ColorLayer extends Layer {
 		clear();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setSize( int width, int height ) {
 		super.setSize(width, height);

src/main/java/schule/ngb/zm/layers/DrawableLayer.java

@@ -87,9 +87,6 @@ public class DrawableLayer extends Layer {
 		this.clearBeforeDraw = pClearBeforeDraw;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void draw( Graphics2D graphics ) {
 		if( clearBeforeDraw ) {

src/main/java/schule/ngb/zm/layers/DrawingLayer.java

@@ -1,10 +1,7 @@
 package schule.ngb.zm.layers;
 
 import schule.ngb.zm.Color;
-import schule.ngb.zm.Layer;
+import schule.ngb.zm.*;
-import schule.ngb.zm.Options;
-import schule.ngb.zm.Fillable;
-import schule.ngb.zm.Strokeable;
 import schule.ngb.zm.shapes.Text;
 import schule.ngb.zm.util.io.ImageLoader;
 
@@ -418,9 +415,6 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 		shapeDelegate.setStrokeType(type);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public Stroke getStroke() {
 		return shapeDelegate.getStroke();
@@ -944,7 +938,7 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 
 	/**
 	 * Zeichnet das Bild von der angegebenen Quelle an der angegebenen Position
-	 * auf dei Zeichenebene.
+	 * auf die Zeichenebene.
 	 * <p>
 	 * Die Bildquelle wird mithilfe von {@link ImageLoader#loadImage(String)}
 	 * geladen. Schlägt dies fehl, wird nichts gezeichnet.
@@ -952,6 +946,7 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param imageSource Die Bildquelle.
 	 * @param x x-Koordinate des Ankerpunktes.
 	 * @param y y-Koordinate des Ankerpunktes.
+	 * @see ImageLoader#loadImage(String)
 	 */
 	public void image( String imageSource, double x, double y ) {
 		image(ImageLoader.loadImage(imageSource), x, y, 1.0, shapeDelegate.getAnchor());
@@ -959,7 +954,7 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 
 	/**
 	 * Zeichnet das Bild von der angegebenen Quelle an der angegebenen Position
-	 * auf dei Zeichenebene.
+	 * auf die Zeichenebene.
 	 * <p>
 	 * Die Bildquelle wird mithilfe von {@link ImageLoader#loadImage(String)}
 	 * geladen. Schlägt dies fehl, wird nichts gezeichnet.
@@ -967,47 +962,73 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param imageSource Die Bildquelle.
 	 * @param x x-Koordinate des Ankerpunktes.
 	 * @param y y-Koordinate des Ankerpunktes.
-	 * @param anchor
+	 * @param anchor Der Ankerpunkt.
+	 * @see ImageLoader#loadImage(String)
 	 */
 	public void image( String imageSource, double x, double y, Options.Direction anchor ) {
 		image(ImageLoader.loadImage(imageSource), x, y, 1.0, anchor);
 	}
 
 	/**
-	 * @param imageSource
+	 * Zeichnet das Bild von der angegebenen Quelle an den angegebenen
-	 * @param x
+	 * Koordinaten auf die Zeichenebene. Das Bild wird um den angegebenen Faktor
-	 * @param y
+	 * skaliert.
-	 * @param scale
+	 * <p>
+	 * Siehe {@link #image(Image, double, double, double, Options.Direction)}
+	 * für mehr Details.
+	 *
+	 * @param imageSource Die Bildquelle.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param scale Der Skalierungsfaktor des Bildes.
+	 * @see ImageLoader#loadImage(String)
 	 */
 	public void image( String imageSource, double x, double y, double scale ) {
 		image(ImageLoader.loadImage(imageSource), x, y, scale, shapeDelegate.getAnchor());
 	}
 
 	/**
-	 * @param imageSource
+	 * Zeichnet das Bild von der angegebenen Quelle an den angegebenen
-	 * @param x
+	 * Koordinaten auf die Zeichenebene. Das Bild wird um den angegebenen Faktor
-	 * @param y
+	 * skaliert und der angegebene Ankerpunkt verwendet.
-	 * @param scale
+	 * <p>
-	 * @param anchor
+	 * Siehe {@link #image(Image, double, double, double, Options.Direction)}
+	 * für mehr Details.
+	 *
+	 * @param imageSource Die Bildquelle.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param scale Der Skalierungsfaktor des Bildes.
+	 * @param anchor Der Ankerpunkt.
+	 * @see ImageLoader#loadImage(String)
 	 */
 	public void image( String imageSource, double x, double y, double scale, Options.Direction anchor ) {
 		image(ImageLoader.loadImage(imageSource), x, y, scale, anchor);
 	}
 
 	/**
-	 * @param image
+	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten auf die
-	 * @param x
+	 * Zeichenebene.
-	 * @param y
+	 *
+	 * @param image Das vorher geladene Bild.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
 	 */
 	public void image( Image image, double x, double y ) {
 		image(image, x, y, 1.0, shapeDelegate.getAnchor());
 	}
 
 	/**
-	 * @param image
+	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten auf die
-	 * @param x
+	 * Zeichenebene. Das Bild wird um den angegebenen Faktor skaliert.
-	 * @param y
+	 * <p>
-	 * @param scale
+	 * Siehe {@link #image(Image, double, double, double, Options.Direction)}
+	 * für mehr Details.
+	 *
+	 * @param image Das vorher geladene Bild.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param scale Der Skalierungsfaktor des Bildes.
 	 */
 	public void image( Image image, double x, double y, double scale ) {
 		image(image, x, y, scale, shapeDelegate.getAnchor());
@@ -1015,8 +1036,18 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 
 	/**
 	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten auf die
-	 * Zeichenebene. Das Bild wird skaliert und der angegebene Ankerpunkt
+	 * Zeichenebene. Das Bild wird um den angegebenen Faktor skaliert und der
-	 * verwendet.
+	 * angegebene Ankerpunkt verwendet.
+	 * <p>
+	 * Bei einem Faktor größer 0 wird das Bild vergrößert, bei einem Faktor
+	 * kleiner 0 verkleinert. Bei negativen Werten wird das Bild entlang der x-
+	 * bzw. y-Achse gespiegelt.
+	 * <p>
+	 * Das Seitenverhältnis wird immer beibehalten.
+	 * <p>
+	 * Soll das Bild innerhalb eines vorgegebenen Rechtecks liegen, sollte
+	 * {@link #image(Image, double, double, double, double, Options.Direction)}
+	 * verwendet werden.
 	 *
 	 * @param image Das vorher geladene Bild.
 	 * @param x x-Koordinate des Ankerpunktes.
@@ -1025,16 +1056,116 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 	 * @param anchor Der Ankerpunkt.
 	 */
 	public void image( Image image, double x, double y, double scale, Options.Direction anchor ) {
-		if( image != null ) {
+		/*if( image != null ) {
 			double neww = image.getWidth(null) * scale;
 			double newh = image.getHeight(null) * scale;
 			Point2D.Double anchorPoint = getOriginPoint(x, y, neww, newh, anchor);
 			drawing.drawImage(image, (int) anchorPoint.x, (int) anchorPoint.y, (int) neww, (int) newh, null);
+		}*/
+		double neww = image.getWidth(null) * scale;
+		double newh = image.getHeight(null) * scale;
+		image(image, x, y, neww, newh, anchor);
+	}
+
+	/**
+	 * Zeichnet das Bild von der angegebenen Quelle an den angegebenen
+	 * Koordinaten in der angegebenen Größe auf die Zeichenebene.
+	 * <p>
+	 * Siehe
+	 * {@link #image(Image, double, double, double, double, Options.Direction)}
+	 * für mehr Details.
+	 *
+	 * @param imageSource Die Bildquelle.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
+	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
+	 * @see ImageLoader#loadImage(String)
+	 */
+	public void image( String imageSource, double x, double y, double width, double height ) {
+		image(ImageLoader.loadImage(imageSource), x, y, width, height, shapeDelegate.getAnchor());
+	}
+
+	/**
+	 * Zeichnet das Bild von der angegebenen Quelle an den angegebenen
+	 * Koordinaten in der angegebenen Größe auf die Zeichenebene. Es wird der
+	 * angegebene Ankerpunkt verwendet.
+	 * <p>
+	 * Siehe
+	 * {@link #image(Image, double, double, double, double, Options.Direction)}
+	 * für mehr Details.
+	 *
+	 * @param imageSource Die Bildquelle.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
+	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
+	 * @param anchor Der Ankerpunkt.
+	 * @see ImageLoader#loadImage(String)
+	 */
+	public void image( String imageSource, double x, double y, double width, double height, Options.Direction anchor ) {
+		image(ImageLoader.loadImage(imageSource), x, y, width, height, anchor);
+	}
+
+	/**
+	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten in der
+	 * angegebenen Größe auf die Zeichenebene.
+	 * <p>
+	 * Siehe
+	 * {@link #image(Image, double, double, double, double, Options.Direction)}
+	 * für mehr Details.
+	 *
+	 * @param image Ein Bild-Objekt.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
+	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
+	 */
+	public void image( Image image, double x, double y, double width, double height ) {
+		image(image, x, y, width, height, shapeDelegate.getAnchor());
+	}
+
+	/**
+	 * Zeichnet das angegebene Bild an den angegebenen Koordinaten in der
+	 * angegebenen Größe auf die Zeichenebene. Der angegebene Ankerpunkt wird
+	 * verwendet.
+	 * <p>
+	 * Das Bild wird innerhalb eines Rechtecks mit der angegebenen Breite und
+	 * Höhe gezeichnet. Dabei wird das Abbild verzerrt, wenn beim Aufruf nicht
+	 * auf ein passendes Seitenverhältnis der Werte zueinander geachtet wird.
+	 * <p>
+	 * Um das Bild auf eine bestimmte Breite oder Höhe festzulegen und die
+	 * andere Größe passend zu skalieren, kann einer der Parameter auf 0 gesetzt
+	 * werden.
+	 * <p>
+	 * Soll die Bildgröße unter Beachtung der Abmessungen um einen Faktor
+	 * verändert werden, sollte
+	 * {@link #image(Image, double, double, double, Options.Direction)}
+	 * verwendet werden.
+	 *
+	 * @param image Ein Bild-Objekt.
+	 * @param x x-Koordinate des Ankerpunktes.
+	 * @param y y-Koordinate des Ankerpunktes.
+	 * @param width Breite des Bildes auf der Zeichenebene oder 0.
+	 * @param height Höhe des Bildes auf der Zeichenebene oder 0.
+	 * @param anchor Der Ankerpunkt.
+	 */
+	public void image( Image image, double x, double y, double width, double height, Options.Direction anchor ) {
+		// TODO: Use Validator or at least LOG a message if image == null?
+		if( image != null ) {
+			if( width == 0 ) {
+				width = (height / image.getHeight(null)) * image.getWidth(null);
+			} else if( height == 0 ) {
+				height = (width / image.getWidth(null)) * image.getHeight(null);
+			}
+
+			Point2D.Double anchorPoint = getOriginPoint(x, y, width, height, anchor);
+			drawing.drawImage(image, (int) anchorPoint.x, (int) anchorPoint.y, (int) width, (int) height, null);
 		}
 	}
 
 	/**
-	 * @return Git aktuelle verwendete Schriftart.
+	 * @return Die aktuell verwendete Schriftart.
 	 */
 	public Font getFont() {
 		return shapeDelegate.getFont();

src/main/java/schule/ngb/zm/media/Audio.java

@@ -1,10 +1,21 @@
 package schule.ngb.zm.media;
 
 /**
- * Interface für Audio-Medien.
+ * Schnittstelle für Audio-Medien.
+ *
+ * <h2>MP3-Dateien verwenden</h2>
+ * Java kann nativ nur Waveform ({@code .wav}) Dateien wiedergeben. Um auch
+ * MP3-Dateien zu nutzen, müssen die Bibliotheken <a href="#">jlayer</a>, <a
+ * href="#">tritonus-share</a> und <a href="#">mp3spi</a> eingebunden werden.
+ * Details zur Verwendung können in der <a
+ * href="https://zeichenmaschine.xyz/installation/#unterstutzung-fur-mp3">Dokumentation
+ * der Zeichenmaschine</a> nachgelesen werden.
  */
 public interface Audio {
 
+	/**
+	 * @return Die Quelle, aus der das Medium geladen wurde.
+	 */
 	String getSource();
 
 	/**
@@ -17,7 +28,7 @@ public interface Audio {
 
 	/**
 	 * Prüft, ob das Medium gerade in einer Schleife abgespielt wird. Wenn
-	 * {@code isLooping() == true}, dann muss auch immer
+	 * {@code isLooping() == true} gilt, dann muss auch immer
 	 * {@code isPlaying() == true} gelten.
 	 *
 	 * @return {@code true}, wenn das Medium in einer Schleife abgespielt wird,
@@ -30,7 +41,7 @@ public interface Audio {
 	 * <p>
 	 * Die Lautstärke wird auf einer linearen Skale festgelegt, wobei 0 kein Ton
 	 * und 1 volle Lautstärke bedeutet. Werte über 1 verstärken den Ton des
-	 * Mediums.
+	 * Mediums. Negative Werte setzen die Lautstärke aud 0.
 	 *
 	 * @param volume Die neue Lautstärke zwischen 0 und 1.
 	 * @see <a
@@ -39,7 +50,7 @@ public interface Audio {
 	void setVolume( double volume );
 
 	/**
-	 * Gibt die aktuelle Lautstärkeeinstellung dieses Mediums zurück.
+	 * Liefert die aktuelle Lautstärke dieses Mediums.
 	 * <p>
 	 * Die Lautstärke wird auf einer linearen Skale angegeben, wobei 0 kein Ton
 	 * und 1 volle Lautstärke bedeutet. Werte über 1 verstärken den Ton des
@@ -50,8 +61,16 @@ public interface Audio {
 	double getVolume();
 
 	/**
-	 * Startet die Wiedergabe des Mediums und beendet die Methode. Das
+	 * Startet die Wiedergabe des Mediums. Das Audio-Medium wird einmal
-	 * Audio-Medium wird einmal abgespielt und stoppt dann.
+	 * abgespielt und stoppt dann.
+	 * <p>
+	 * Die Methode beendet sofort und die Wiedergabe erfolgt im Hintergrund.
+	 * Soll die Programmausführung erst nach Wiedergabe des Mediums fortgesetzt
+	 * werden, sollte {@link #playAndWait()} verwendet werden.
+	 * <p>
+	 * Soll die Wiedergabe im Hintergrund ablaufen, aber dennoch auf das Ende
+	 * reagiert werden, kann ein
+	 * {@link #addAudioListener(AudioListener) AudioListener} verwendet werden.
 	 */
 	void play();
 
@@ -63,28 +82,28 @@ public interface Audio {
 
 	/**
 	 * Spielt das Medium in einer kontinuierlichen Schleife ab. Die Methode
-	 * startet die Wiedergabe und beendet dann direkt die Methode. Um die
+	 * startet die Wiedergabe im Hintergrund und beendet dann sofort. Um die
-	 * Wiedergabe zu stoppen muss {@link #stop()} aufgerufen werden.
+	 * Wiedergabe zu stoppen, muss {@link #stop()} aufgerufen werden.
 	 */
 	void loop();
 
 	/**
 	 * Stoppt die Wiedergabe. Wird das Medium gerade nicht abgespielt
-	 * {@code isPlaying() == false}, dann passiert nichts.
+	 * ({@code isPlaying() == false}), dann passiert nichts.
 	 */
 	void stop();
 
 	/**
-	 * Stoppt die Wiedergabe und gibt alle Resourcen, die für das Medium
+	 * Stoppt die Wiedergabe und gibt alle Ressourcen, die für das Medium
 	 * verwendet werden, frei.
 	 */
 	void dispose();
 
 	/**
-	 * Fügt dem Medium das angegbene Objekt als {@code AudioListener} hinzu, der
+	 * Fügt dem Medium das angegebene Objekt als {@code AudioListener} hinzu,
-	 * bei Start und Stopp der Wiedergabe informiert werden soll.
+	 * der bei Start und Stopp der Wiedergabe informiert wird.
 	 *
-	 * @param listener Das zu informierende Objekt.
+	 * @param listener Das Listener-Objekt.
 	 */
 	void addAudioListener( AudioListener listener );
 

src/main/java/schule/ngb/zm/media/AudioListener.java

@@ -14,20 +14,20 @@ import schule.ngb.zm.util.events.Listener;
 public interface AudioListener extends Listener<Audio> {
 
 	/**
-	 * Wird aufgerufen, sobald die Wiedergabe eines Audio-Objektes startet, dem
+	 * Wird aufgerufen, sobald die Wiedergabe eines Audio-Mediums startet, dem
 	 * dieses Objekt mittels {@link Audio#addAudioListener(AudioListener)}
 	 * hinzugefügt wurde.
 	 *
-	 * @param source Das Audio-Objekt, dessen Wiedergabe gestartet wurde.
+	 * @param source Das Audio-Medium, dessen Wiedergabe gestartet wurde.
 	 */
 	void playbackStarted( Audio source );
 
 	/**
-	 * Wird aufgerufen, sobald die Wiedergabe eines Audio-Objektes stoppt, dem
+	 * Wird aufgerufen, sobald die Wiedergabe eines Audio-Mediums stoppt, dem
 	 * dieses Objekt mittels {@link Audio#addAudioListener(AudioListener)}
 	 * hinzugefügt wurde.
 	 *
-	 * @param source Das Audio-Objekt, dessen Wiedergabe gestoppt wurde.
+	 * @param source Das Audio-Medium, dessen Wiedergabe gestoppt wurde.
 	 */
 	void playbackStopped( Audio source );
 

src/main/java/schule/ngb/zm/media/Mixer.java

@@ -98,50 +98,32 @@ public class Mixer implements Audio, AudioListener {
 		audios.clear();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean isPlaying() {
 		return audios.stream().anyMatch(aw -> aw.audio.isPlaying());
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean isLooping() {
 		return audios.stream().anyMatch(aw -> aw.audio.isLooping());
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
-	public void setVolume( double pVolume ) {
+	public void setVolume( double volume ) {
-		volume = (float) pVolume;
+		this.volume = volume < 0 ? 0f : (float) volume;
-		audios.stream().forEach(aw -> aw.audio.setVolume(aw.volumeFactor * pVolume));
+		audios.stream().forEach(aw -> aw.audio.setVolume(aw.volumeFactor * volume));
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public double getVolume() {
 		return volume;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void play() {
 		audios.stream().forEach(aw -> aw.audio.play());
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void playAndWait() {
 		audios.stream().forEach(aw -> aw.audio.play());
@@ -154,25 +136,16 @@ public class Mixer implements Audio, AudioListener {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void loop() {
 		audios.stream().forEach(aw -> aw.audio.loop());
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void stop() {
 		audios.stream().forEach(aw -> aw.audio.stop());
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void dispose() {
 		if( isPlaying() ) {
@@ -243,7 +216,8 @@ public class Mixer implements Audio, AudioListener {
 
 	/**
 	 * Interne Methode, um den Listener-Mechanismus zu initialisieren. Wird erst
-	 * aufgerufen, soblad sich auch ein Listener registrieren möchte.
+	 * aufgerufen, sobald sich auch ein Listener registrieren möchte.
+	 *
 	 * @return
 	 */
 	private EventDispatcher<Audio, AudioListener> initializeEventDispatcher() {

src/main/java/schule/ngb/zm/media/Music.java

@@ -1,84 +1,103 @@
 package schule.ngb.zm.media;
 
-import schule.ngb.zm.util.events.EventDispatcher;
-import schule.ngb.zm.util.tasks.TaskRunner;
 import schule.ngb.zm.util.Log;
-import schule.ngb.zm.util.io.ResourceStreamProvider;
 import schule.ngb.zm.util.Validator;
+import schule.ngb.zm.util.events.EventDispatcher;
+import schule.ngb.zm.util.io.ResourceStreamProvider;
+import schule.ngb.zm.util.tasks.TaskRunner;
 
 import javax.sound.sampled.*;
 import java.io.IOException;
 import java.net.URL;
 
 /**
- * Ein Musikstück, dass im Projekt abgespielt werden soll.
+ * Eine Musik, die abgespielt werden kann.
  * <p>
- * Im gegensatz zu einem {@link Sound} sind Musikstücke längere Audiodateien,
+ * Im Gegensatz zu einem {@link Sound} wird {@code Music} für längere
- * die zum Beispiel als Hintergrundmusik ablaufen sollen. Die Musik wird daher
+ * Audiodateien benutzt, die zum Beispiel als Hintergrundmusik gespielt werden.
- * nicht komplett in den Speicher geladen, sondern direkt aus der Audioquelle
+ * Die Audiodaten werden daher nicht vollständig in den Speicher geladen,
- * gestreamt und wiedergegeben.
+ * sondern direkt aus der Quelle gestreamt und direkt wiedergegeben.
+ * <p>
+ * Daher ist es nicht möglich, die länge der Musik im Vorfeld abzufragen oder zu
+ * einer bestimmten Stelle im Stream zu springen.
+ *
+ * <h2>MP3-Dateien verwenden</h2>
+ * Java kann nativ nur Waveform ({@code .wav}) Dateien wiedergeben. Um auch
+ * MP3-Dateien zu nutzen, müssen die Bibliotheken <a href="#">jlayer</a>, <a
+ * href="#">tritonus-share</a> und <a href="#">mp3spi</a> eingebunden werden.
+ * Details zur Verwendung können in der <a
+ * href="https://zeichenmaschine.xyz/installation/#unterstutzung-fur-mp3">Dokumentation
+ * der Zeichenmaschine</a> nachgelesen werden.
  */
-@SuppressWarnings("unused")
+// TODO: Wann sollten Listener beim Loopen informiert werden? Nach jedem Loop oder erst ganz am Ende?
+@SuppressWarnings( "unused" )
 public class Music implements Audio {
 
-	// size of the byte buffer used to read/write the audio stream
+	/**
+	 * Größe des verwendeten Input-Puffers für die Audiodaten.
+	 */
 	private static final int BUFFER_SIZE = 4096;
 
 
 	/**
-	 * Ob der Sound gerade abgespielt wird.
+	 * Ob der Sound aktuell abgespielt wird.
 	 */
 	private boolean playing = false;
 
 	/**
-	 * Ob der Sound gerade in einer Schleife abgespielt wird.
+	 * Ob der Sound aktuell in einer Schleife abgespielt wird.
 	 */
 	private boolean looping = false;
 
 	/**
-	 * Die Quelle des Musikstücks.
+	 * Die Quelle der Audiodaten.
 	 */
 	private String audioSource;
 
 	/**
-	 * Der AudioStream, um die AUdiosdaten zulsen, falls dieser schon geöffnet
+	 * Der {@link AudioInputStream}, um die Audiosdaten zu lesen. {@code null},
-	 * wurde. Sonst {@code null}.
+	 * falls noch kein Stream geöffnet wurde.
 	 */
 	private AudioInputStream audioStream;
 
 	/**
-	 * Die Line für die Ausgabe, falls diese schon geöffnet wurde. Sonst
+	 * Die {@link SourceDataLine} für die Ausgabe. {@code null}, falls die
-	 * {@code null}.
+	 * Audiodatei noch nicht geöffnet wurde.
 	 */
 	private SourceDataLine audioLine;
 
 	/**
-	 * Die Lautstärke der Musik.
+	 * Die aktuelle Lautstärke des Mediums.
 	 */
 	private float volume = 0.8f;
 
+	/**
+	 * Dispatcher für Audio-Events (start und stop).
+	 */
 	EventDispatcher<Audio, AudioListener> eventDispatcher;
 
-	public Music( String source ) {
+	/**
-		Validator.requireNotNull(source);
+	 * Erstellt eine Musik aus der angegebenen Audioquelle.
-		this.audioSource = source;
+	 *
+	 * @param audioSource Quelle der Audiodaten.
+	 * @throws NullPointerException Falls die Quelle {@code null} ist.
+	 * @see ResourceStreamProvider#getResourceURL(String)
+	 */
+	public Music( String audioSource ) {
+		Validator.requireNotNull(audioSource);
+		this.audioSource = audioSource;
 	}
 
+	@Override
 	public String getSource() {
 		return audioSource;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean isPlaying() {
 		return playing;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean isLooping() {
 		if( !playing ) {
@@ -87,28 +106,21 @@ public class Music implements Audio {
 		return looping;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setVolume( double volume ) {
-		this.volume = (float) volume;
+		this.volume = volume < 0 ? 0f : (float) volume;
 		if( audioLine != null ) {
 			applyVolume();
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public double getVolume() {
 		return volume;
 	}
 
 	/**
-	 * Interne Methode, um die gesetzte Lautstärke vor dem Abspielen
+	 * Wendet die Lautstärke vor dem Abspielen auf den Audiostream an.
-	 * anzuwenden.
 	 */
 	private void applyVolume() {
 		FloatControl gainControl =
@@ -119,24 +131,13 @@ public class Music implements Audio {
 		gainControl.setValue(vol);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void play() {
 		if( openLine() ) {
-			TaskRunner.run(new Runnable() {
+			TaskRunner.run(this::stream);
-				@Override
-				public void run() {
-					stream();
-				}
-			});
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void playAndWait() {
 		if( openLine() ) {
@@ -144,18 +145,12 @@ public class Music implements Audio {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void loop() {
 		looping = true;
 		play();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void stop() {
 		playing = false;
@@ -163,9 +158,6 @@ public class Music implements Audio {
 		dispose();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public synchronized void dispose() {
 		if( audioLine != null ) {
@@ -189,7 +181,17 @@ public class Music implements Audio {
 		audioStream = null;
 	}
 
+	/**
+	 * Startet den Stream der Audiodaten und damit die Wiedergabe.
+	 * <p>
+	 * Die {@link #audioLine} muss vorher mit {@link #openLine()} geöffnet
+	 * werden, ansonsten passiert nichts.
+	 */
 	private synchronized void stream() {
+		if( audioLine == null ) {
+			return;
+		}
+
 		audioLine.start();
 		playing = true;
 		if( eventDispatcher != null ) {
@@ -226,6 +228,14 @@ public class Music implements Audio {
 		}
 	}
 
+	/**
+	 * Öffnet eine {@link SourceDataLine} für die
+	 * {@link #audioSource Audioquelle} und bereitet die Wiedergabe vor. Es wird
+	 * noch nichts abgespielt.
+	 *
+	 * @return {@code true}, wenn die Line geöffnet werden konnte, {@code false}
+	 * 	sonst.
+	 */
 	private boolean openLine() {
 		if( audioLine != null ) {
 			return true;
@@ -262,6 +272,15 @@ public class Music implements Audio {
 		return false;
 	}
 
+	/**
+	 * Wird aufgerufen, wenn die Wiedergabe beendet wurde. Entweder durch einen
+	 * Aufruf von {@link #stop()} oder weil keine Audiodaten mehr vorhanden
+	 * sind.
+	 * <p>
+	 * Nach dem Ende des Streams wird {@link #dispose()} aufgerufen und, falls
+	 * das Musikstück in einer Schleife abgespielt wird, der Stream direkt
+	 * wieder gestartet.
+	 */
 	private void streamingStopped() {
 		dispose();
 
@@ -289,14 +308,15 @@ public class Music implements Audio {
 
 	/**
 	 * Interne Methode, um den Listener-Mechanismus zu initialisieren. Wird erst
-	 * aufgerufen, soblad sich auch ein Listener registrieren möchte.
+	 * aufgerufen, sobald sich der erste Listener anmelden möchte.
-	 * @return
+	 *
+	 * @return Der {@code EventDispatcher} für dieses Objekt.
 	 */
 	private EventDispatcher<Audio, AudioListener> initializeEventDispatcher() {
 		if( eventDispatcher == null ) {
 			eventDispatcher = new EventDispatcher<>();
-			eventDispatcher.registerEventType("start", (a,l) -> l.playbackStarted(a));
+			eventDispatcher.registerEventType("start", ( a, l ) -> l.playbackStarted(a));
-			eventDispatcher.registerEventType("stop", (a,l) -> l.playbackStopped(a));
+			eventDispatcher.registerEventType("stop", ( a, l ) -> l.playbackStopped(a));
 		}
 		return eventDispatcher;
 	}

src/main/java/schule/ngb/zm/media/Sound.java

@@ -10,80 +10,87 @@ import java.io.IOException;
 import java.net.URL;
 
 /**
- * Wiedergabe kurzer Soundclips, die mehrmals wiederverwendet werden.
+ * Ein kurzer Soundclip, der mehrmals wiederverwendet werden kann.
  * <p>
- * In Spielen und anderen Projekten gibt es oftmals eine Reihe kurzer Sounds,
+ * In Spielen und anderen Projekten gibt es oftmals eine Reihe kurzer
- * die zusammen mit bestimmten Aktionen wiedergegeben werden (zum Beispiel, wenn
+ * Soundclips, die zusammen mit bestimmten Aktionen wiedergegeben werden (zum
- * die Spielfigur springt, wenn zwei Objekte kollidieren, usw.). Sounds werden
+ * Beispiel, wenn die Spielfigur springt, wenn zwei Objekte kollidieren, usw.).
- * komplett in den Speicher geladen und können dadurch immer wieder, als
+ * Sounds werden vollständig in den Speicher geladen und können immer wieder,
- * Schleife oder auch nur Abschnittsweise abgespielt werden.
+ * als Schleife oder auch nur Abschnittsweise, abgespielt werden.
  * <p>
- * Für längre Musikstücke (beispielsweise Hintergrundmusik) bietet sich eher die
+ * Für längere Musikstücke (beispielsweise Hintergrundmusik) bietet sich eher
- * KLasse {@link Music} an.
+ * die Klasse {@link Music} an.
+ *
+ * <h2>MP3-Dateien verwenden</h2>
+ * Java kann nativ nur Waveform ({@code .wav}) Dateien wiedergeben. Um auch
+ * MP3-Dateien zu nutzen, müssen die Bibliotheken <a href="#">jlayer</a>, <a
+ * href="#">tritonus-share</a> und <a href="#">mp3spi</a> eingebunden werden.
+ * Details zur Verwendung können in der <a
+ * href="https://zeichenmaschine.xyz/installation/#unterstutzung-fur-mp3">Dokumentation
+ * der Zeichenmaschine</a> nachgelesen werden.
  */
 @SuppressWarnings( "unused" )
 public class Sound implements Audio {
 
 	/**
-	 * Ob der Sound gerade abgespielt wird.
+	 * Ob der Sound aktuell abgespielt wird.
 	 */
 	private boolean playing = false;
 
 	/**
-	 * Ob der Sound gerade in einer Schleife abgespielt wird.
+	 * Ob der Sound aktuell in einer Schleife abgespielt wird.
 	 */
 	private boolean looping = false;
 
 	/**
-	 * Die Quelle des Musikstücks.
+	 * Die Quelle der Audiodaten.
 	 */
 	private String audioSource;
 
 	/**
-	 * Der Clip, falls er schon geladen wurde, sonst {@code null}.
+	 * Der Clip, falls er schon geladen wurde. Ansonsten {@code null}.
 	 */
 	private Clip audioClip;
 
 	/**
-	 * Ob die Resourcen des Clips im Speicher nach dem nächsten Abspielen
+	 * Ob die Ressourcen des Clips im Speicher nach dem nächsten Abspielen
 	 * freigegeben werden sollen.
 	 */
 	private boolean disposeAfterPlay = false;
 
 	/**
-	 * Die Lautstärke des Clips.
+	 * Die aktuelle Lautstärke des Clips.
 	 */
 	private float volume = 0.8f;
 
+	/**
+	 * Dispatcher für Audio-Events (start und stop).
+	 */
 	EventDispatcher<Audio, AudioListener> eventDispatcher;
 
 	/**
 	 * Erstellt einen Sound aus der angegebene Quelle.
 	 *
-	 * @param source Ein Dateipfad oder eine Webadresse.
+	 * @param source Quelle der Audiodaten.
 	 * @throws NullPointerException Falls die Quelle {@code null} ist.
+	 * @see ResourceStreamProvider#getResourceURL(String)
 	 */
 	public Sound( String source ) {
 		Validator.requireNotNull(source);
 		this.audioSource = source;
 	}
 
+	@Override
 	public String getSource() {
 		return audioSource;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean isPlaying() {
 		// return audioClip != null && audioClip.isRunning();
 		return playing;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public boolean isLooping() {
 		if( !playing ) {
@@ -92,28 +99,21 @@ public class Sound implements Audio {
 		return looping;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setVolume( double volume ) {
-		this.volume = (float) volume;
+		this.volume = volume < 0 ? 0f : (float) volume;
 		if( audioClip != null ) {
 			applyVolume();
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public double getVolume() {
 		return volume;
 	}
 
 	/**
-	 * Interne Methode, um die gesetzte Lautstärke vor dem Abspielen
+	 * Wendet die Lautstärke vor dem Abspielen auf den Clip an.
-	 * anzuwenden.
 	 */
 	private void applyVolume() {
 		FloatControl gainControl =
@@ -124,9 +124,6 @@ public class Sound implements Audio {
 		gainControl.setValue(vol);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void stop() {
 		looping = false;
@@ -136,9 +133,6 @@ public class Sound implements Audio {
 		playing = false;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void play() {
 		if( this.openClip() ) {
@@ -147,9 +141,6 @@ public class Sound implements Audio {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void playAndWait() {
 		this.play();
@@ -168,7 +159,7 @@ public class Sound implements Audio {
 	}
 
 	/**
-	 * Spielt den Sound genau einmal ab und gibt danach alle Resourcen des Clips
+	 * Spielt den Sound einmal ab und gibt danach alle Ressourcen des Clips
 	 * frei.
 	 * <p>
 	 * Der Aufruf ist effektiv gleich zu
@@ -185,7 +176,7 @@ public class Sound implements Audio {
 	}
 
 	/**
-	 * Spielt den Sound genau einmal ab und gibt danach alle Resourcen des Clips
+	 * Spielt den Sound einmal ab und gibt danach alle Ressourcen des Clips
 	 * frei.
 	 * <p>
 	 * Der Aufruf entspricht
@@ -199,17 +190,18 @@ public class Sound implements Audio {
 		playAndWait();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void loop() {
 		loop(Clip.LOOP_CONTINUOUSLY);
 	}
 
 	/**
-	 * Wiederholt den Sound die angegebene Anzahl an Wiederholungen ab und
+	 * Wiederholt den Sound die angegebene Anzahl an Wiederholungen und stoppt
-	 * stoppt die Wiedergabe dann.
+	 * die Wiedergabe dann.
+	 * <p>
+	 * Wird {@code count} auf {@link Clip#LOOP_CONTINUOUSLY} gesetzt (-1), wird
+	 * der Clip unendlich oft wiederholt. Der Aufruf entspricht dann
+	 * {@link #loop()}.
 	 *
 	 * @param count Anzahl der Wiederholungen.
 	 */
@@ -231,9 +223,6 @@ public class Sound implements Audio {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public synchronized void dispose() {
 		if( audioClip != null ) {
@@ -245,6 +234,13 @@ public class Sound implements Audio {
 		}
 	}
 
+	/**
+	 * Lädt falls nötig den {@link Clip} für die
+	 * {@link #audioSource Audioquelle} und startet die Wiedergabe.
+	 *
+	 * @return {@code true}, wenn der Clip geöffnet werden konnte, {@code false}
+	 * 	sonst.
+	 */
 	private synchronized boolean openClip() {
 		if( audioClip != null ) {
 			audioClip.setFramePosition(0);
@@ -307,9 +303,12 @@ public class Sound implements Audio {
 	}*/
 
 	/**
-	 * Interne Methode, die aufgerufen wird, wenn die Wiedergabe gestoppt wird.
+	 * Wird aufgerufen, wenn die Wiedergabe beendet wurde. Entweder durch einen
-	 * Entweder durch einen Aufruf von {@link #stop()} oder, weil die Wiedergabe
+	 * Aufruf von {@link #stop()} oder, weil die Wiedergabe nach
-	 * nach {@link #playOnce()} beendet wurde.
+	 * {@link #playOnce()} beendet wurde.
+	 * <p>
+	 * Falls {@link #disposeAfterPlay} gesetzt ist, wird nach dem Ende der
+	 * Wiedergabe {@link #dispose()} aufgerufen.
 	 */
 	private void playbackStopped() {
 		playing = false;
@@ -332,14 +331,15 @@ public class Sound implements Audio {
 
 	/**
 	 * Interne Methode, um den Listener-Mechanismus zu initialisieren. Wird erst
-	 * aufgerufen, soblad sich auch ein Listener registrieren möchte.
+	 * aufgerufen, sobald sich der erste Listener anmelden möchte.
-	 * @return
+	 *
+	 * @return Der {@code EventDispatcher} für dieses Objekt.
 	 */
 	private EventDispatcher<Audio, AudioListener> initializeEventDispatcher() {
 		if( eventDispatcher == null ) {
 			eventDispatcher = new EventDispatcher<>();
-			eventDispatcher.registerEventType("start", (a,l) -> l.playbackStarted(a));
+			eventDispatcher.registerEventType("start", ( a, l ) -> l.playbackStarted(a));
-			eventDispatcher.registerEventType("stop", (a,l) -> l.playbackStopped(a));
+			eventDispatcher.registerEventType("stop", ( a, l ) -> l.playbackStopped(a));
 		}
 		return eventDispatcher;
 	}

src/main/java/schule/ngb/zm/ml/DoubleMatrix.java

@@ -93,32 +93,20 @@ public final class DoubleMatrix implements MLMatrix {
 			rows * columns);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public int columns() {
 		return columns;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public int rows() {
 		return rows;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	int idx( int r, int c ) {
 		return c * rows + r;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public double get( int row, int col ) {
 		try {
@@ -128,9 +116,6 @@ public final class DoubleMatrix implements MLMatrix {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix set( int row, int col, double value ) {
 		try {
@@ -141,52 +126,34 @@ public final class DoubleMatrix implements MLMatrix {
 		return this;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix initializeRandom() {
 		return initializeRandom(-1.0, 1.0);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix initializeRandom( double lower, double upper ) {
 		applyInPlace(( d ) -> ((upper - lower) * Constants.random()) + lower);
 		return this;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix initializeOne() {
 		applyInPlace(( d ) -> 1.0);
 		return this;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix initializeZero() {
 		applyInPlace(( d ) -> 0.0);
 		return this;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix duplicate() {
 		return new DoubleMatrix(this);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix multiplyTransposed( MLMatrix B ) {
 		/*return new DoubleMatrix(IntStream.range(0, rows).parallel().mapToObj(
@@ -208,9 +175,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return result;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix multiplyAddBias( final MLMatrix B, final MLMatrix C ) {
 		/*return new DoubleMatrix(IntStream.range(0, rows).parallel().mapToObj(
@@ -233,9 +197,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return result;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix transposedMultiplyAndScale( final MLMatrix B, final double scalar ) {
 		/*return new DoubleMatrix(IntStream.range(0, columns).parallel().mapToObj(
@@ -258,9 +219,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return result;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix add( MLMatrix B ) {
 		/*return new DoubleMatrix(IntStream.range(0, rows).parallel().mapToObj(
@@ -277,9 +235,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return sum;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix addInPlace( MLMatrix B ) {
 		for( int j = 0; j < columns; j++ ) {
@@ -290,9 +245,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return this;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix sub( MLMatrix B ) {
 		/*return new DoubleMatrix(IntStream.range(0, rows).parallel().mapToObj(
@@ -309,9 +261,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return diff;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix colSums() {
 		/*DoubleMatrix colSums = new DoubleMatrix(1, columns);
@@ -331,9 +280,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return colSums;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix scaleInPlace( final double scalar ) {
 		for( int i = 0; i < coefficients.length; i++ ) {
@@ -342,9 +288,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return this;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix scaleInPlace( final MLMatrix S ) {
 		for( int j = 0; j < columns; j++ ) {
@@ -355,9 +298,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return this;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix apply( DoubleUnaryOperator op ) {
 		DoubleMatrix result = new DoubleMatrix(rows, columns);
@@ -367,9 +307,6 @@ public final class DoubleMatrix implements MLMatrix {
 		return result;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public MLMatrix applyInPlace( DoubleUnaryOperator op ) {
 		for( int i = 0; i < coefficients.length; i++ ) {

src/main/java/schule/ngb/zm/shapes/Shape.java

@@ -1,6 +1,9 @@
 package schule.ngb.zm.shapes;
 
-import schule.ngb.zm.*;
+import schule.ngb.zm.BasicDrawable;
+import schule.ngb.zm.Fillable;
+import schule.ngb.zm.Options;
+import schule.ngb.zm.Strokeable;
 
 import java.awt.Graphics2D;
 import java.awt.geom.AffineTransform;
@@ -142,9 +145,6 @@ public abstract class Shape extends BasicDrawable {
 	 */
 	public abstract double getHeight();
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to, Options.Direction dir ) {
 		Point2D apDir = getAbsAnchorPoint(dir);
@@ -152,9 +152,6 @@ public abstract class Shape extends BasicDrawable {
 		setGradient(apInv.getX(), apInv.getY(), from, apDir.getX(), apDir.getY(), to);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to ) {
 		Point2D ap = getAbsAnchorPoint(CENTER);

src/main/java/schule/ngb/zm/shapes/charts/BasicChartValue.java

@@ -136,57 +136,36 @@ public class BasicChartValue implements ChartValue {
 		this.color = color;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public double getX() {
 		return xValue;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public double getValue() {
 		return value;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setValue( double pValue ) {
 		this.value = pValue;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public String getLabel() {
 		return label;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setLabel( String pLabel ) {
 		this.label = pLabel;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public Color getColor() {
 		return color;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setColor( Color pColor ) {
 		this.color = pColor;

src/main/java/schule/ngb/zm/util/Counter.java

@@ -5,7 +5,7 @@ import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
- * Eine Hilfsklasse um Dinge zu zählen.
+ * Eine Helferklasse, um Dinge zu zählen.
  * <p>
  * Im einfachsten Fall kann der Zähler als geteilte Zählvariable genutzt werden,
  * die mit {@link #inc()} und {@link #dec()} aus verschiedenen Objekten oder
@@ -13,11 +13,11 @@ import java.util.concurrent.atomic.AtomicInteger;
  * <p>
  * Der Zähler kann aber auch Objekte zählen, indem die Instanzen an
  * {@link #count(Object)} übergeben werden. Am Ende kann mit {@link #getCount()}
- * die Anzahl der Objkete abgerufen werden.
+ * die Anzahl der Objekte abgerufen werden.
  * <p>
- * Handelt es sich bei den Objekten um Zahlen, dann merkt sich ein Zähler auch
+ * Handelt es sich bei den Objekten um Zahlen, dann merkt sich ein
- * das Maximum, das Minimum, die Summe und den Durchschnitt der gezählten
+ * {@code Counter} auch das Maximum, das Minimum, die Summe und den Durchschnitt
- * Werte.
+ * der gezählten Werte.
  * <p>
  * Ein Zähler kann auch komplette Arrays oder Listen von Zahlen zählen und die
  * obigen Statistiken auswerten.
@@ -96,31 +96,42 @@ public final class Counter {
 	}
 
 	/**
-	 * Gibt die aktuelle Anzahl zurück.
 	 * @return Die aktuelle Anzahl.
 	 */
 	public int getCount() {
 		return count.get();
 	}
 
+	/**
+	 * @return Das Maxium der bisher gezählten Werte.
+	 */
 	public double getMax() {
 		synchronized( count ) {
 			return max;
 		}
 	}
 
+	/**
+	 * @return Das Minimum der bisher gezählten Werte.
+	 */
 	public double getMin() {
 		synchronized( count ) {
 			return min;
 		}
 	}
 
+	/**
+	 * @return Die Summe der bisher gezählten Werte.
+	 */
 	public double getSum() {
 		synchronized( count ) {
 			return sum;
 		}
 	}
 
+	/**
+	 * @return Der Mittelwert der bisher gezählten Werte.
+	 */
 	public double getAvg() {
 		if( Double.isNaN(sum) ) {
 			return Double.NaN;
@@ -129,13 +140,27 @@ public final class Counter {
 		}
 	}
 
-
+	/**
+	 * Setzt den Zähler auf den angegebenen Wert.
+	 * <p>
+	 * Die anderen Statistiken werden nicht verändert.
+	 *
+	 * @param count Der neue Wert des Zählers.
+	 * @return Dieser Zähler selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Counter setCount( int count ) {
 		this.count.set(count);
 		return this;
 	}
 
+	/**
+	 * Setzt den Zähler auf Null.
+	 * <p>
+	 * Die Statistiken werden auf {@link Double#NaN} gesetzt.
+	 *
+	 * @return Dieser Zähler selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Counter reset() {
 		count.set(0);
@@ -147,18 +172,40 @@ public final class Counter {
 		return this;
 	}
 
+	/**
+	 * Erhöht den Zähler um Eins.
+	 * <p>
+	 * Die anderen Statistiken werden nicht verändert.
+	 *
+	 * @return Dieser Zähler selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Counter inc() {
 		this.count.incrementAndGet();
 		return this;
 	}
 
+	/**
+	 * Verringert den Zähler um Eins.
+	 * <p>
+	 * Die anderen Statistiken werden nicht verändert.
+	 *
+	 * @return Dieser Zähler selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Counter dec() {
 		this.count.decrementAndGet();
 		return this;
 	}
 
+	/**
+	 * Zählt den angegebenen Wert.
+	 * <p>
+	 * Erhöht den Zähler um Eins und aktualisiert die Statistiken.
+	 *
+	 * @param value Der neue Wert.
+	 * @return Dieser Zähler selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Counter count( double value ) {
 		inc();
@@ -173,11 +220,27 @@ public final class Counter {
 		return this;
 	}
 
+	/**
+	 * Zählt die angegebene Zahl.
+	 * <p>
+	 * Erhöht den Zähler um Eins und aktualisiert die Statistiken.
+	 *
+	 * @param num Die neue Zahl.
+	 * @return Dieser Zähler selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Counter count( Number num ) {
 		return count(num.doubleValue());
 	}
 
+	/**
+	 * Zählt das angegebenen Objekt.
+	 * <p>
+	 * Erhöht den Zähler um Eins.
+	 *
+	 * @param obj Ein beliebiges Objekt.
+	 * @return Dieser Zähler selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Counter count( Object obj ) {
 		if( obj instanceof Number ) {
@@ -188,6 +251,13 @@ public final class Counter {
 		}
 	}
 
+	/**
+	 * Zöhlt alle Werte im angegebenen Array.
+	 *
+	 * @param values Das Array der neuen Werte.
+	 * @return Dieser Zähler selbst (method chaining).
+	 * @see #count(double)
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public synchronized Counter countAll( double[] values ) {
 		for( double value : values ) {
@@ -196,6 +266,13 @@ public final class Counter {
 		return this;
 	}
 
+	/**
+	 * Zöhlt alle Werte im angegebenen Array.
+	 *
+	 * @param values Das Array der neuen Werte.
+	 * @return Dieser Zähler selbst (method chaining).
+	 * @see #count(double)
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public synchronized Counter countAll( int[] values ) {
 		for( double value : values ) {
@@ -204,6 +281,13 @@ public final class Counter {
 		return this;
 	}
 
+	/**
+	 * Zöhlt alle Zahlen im angegebenen Array.
+	 *
+	 * @param values Das Array der neuen Zahlen.
+	 * @return Dieser Zähler selbst (method chaining).
+	 * @see #count(Number)
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public synchronized Counter countAll( Number[] values ) {
 		for( Number value : values ) {
@@ -212,6 +296,13 @@ public final class Counter {
 		return this;
 	}
 
+	/**
+	 * Zöhlt alle Zahlen in der angegebenen Sammlung.
+	 *
+	 * @param values Die Sammlung der neuen Zahlen.
+	 * @return Dieser Zähler selbst (method chaining).
+	 * @see #count(Number)
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public synchronized Counter countAll( Collection<Number> values ) {
 		for( Number value : values ) {

src/main/java/schule/ngb/zm/util/Faker.java

@@ -2,8 +2,6 @@ package schule.ngb.zm.util;
 
 import schule.ngb.zm.Color;
 import schule.ngb.zm.Constants;
-import schule.ngb.zm.Zeichenmaschine;
-import schule.ngb.zm.util.io.FileLoader;
 import schule.ngb.zm.util.io.ImageLoader;
 
 import java.awt.Font;
@@ -11,46 +9,69 @@ import java.awt.FontMetrics;
 import java.awt.Graphics2D;
 import java.awt.font.LineMetrics;
 import java.awt.image.BufferedImage;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.Array;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static java.lang.Math.exp;
+import static java.lang.Math.log;
+import static schule.ngb.zm.Constants.random;
 
 /**
  * Hilfsklasse, um zufällige Beispieldaten zu erzeugen.
  * <p>
  * Die Klasse kann verschiedene Arten realistischer Beispieldaten erzeugen,
- * unter anderem Namen, E-Mail-Adressen, Passwörter oder Platzhalterbilder.
+ * unter anderem Namen, E-Mail-Adressen, Passwörter oder Platzhalter-Bilder.
  */
+@SuppressWarnings( "unused" )
 public final class Faker {
 
 	public static final String FAKE_IMG_URL = "https://loremflickr.com/%d/%d";
 
+	public static void main( String[] args ) {
+		String text = Faker.fakeText(2000, 8);
+		System.out.println(text);
+	}
+
 	/**
-	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Nutzernamen.
+	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Benutzerdaten.
+	 * <p>
+	 * Jeder Datensatz besteht aus einem String-Array mit den folgenden Daten
+	 * <ul>
+	 * <li><code>fakeUser[i][0]</code>: Vorname</li>
+	 * <li><code>fakeUser[i][1]</code>: Nachname</li>
+	 * <li><code>fakeUser[i][2]</code>: Geschlecht</li>
+	 * <li><code>fakeUser[i][3]</code>: Nutzername</li>
+	 * <li><code>fakeUser[i][4]</code>: Passwort</li>
+	 * <li><code>fakeUser[i][5]</code>: E-Mail</li>
+	 * <li><code>fakeUser[i][6]</code>: Geburtsdatum</li>
+	 * </ul>
 	 *
-	 * @param n Anzahl der Beispieldaten.
+	 * @param count Anzahl der Beispieldaten.
 	 * @return Ein Array mit den Beispieldaten.
 	 */
-	public static String[][] fakeUsers( int n ) {
+	public static String[][] fakeUsers( int count ) {
-		String[][] data = loadMockfile("users");
+		return randomSample("users", count, ( line ) -> line.split(","), String[].class);
-		String[][] result = new String[n][];
-		for( int i = 0; i < n; i++ ) {
-			result[i] = Constants.choice(data);
-		}
-		return result;
 	}
 
 	/**
 	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Vornamen.
 	 *
-	 * @param n Anzahl der Beispieldaten.
+	 * @param count Anzahl der Beispieldaten.
 	 * @return Ein Array mit den Beispieldaten.
 	 */
-	public static String[] fakeNames( int n ) {
+	public static String[] fakeNames( int count ) {
-		String[][] data = loadMockfile("users");
+		return randomSample("users", count, ( line ) -> line.split(",")[0], String.class);
-		String[] result = new String[n];
-		for( int i = 0; i < n; i++ ) {
-			String[] row = Constants.choice(data);
-			result[i] = row[0];
-		}
-		return result;
 	}
 
 
@@ -58,65 +79,187 @@ public final class Faker {
 	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Namen (Vor- und
 	 * Nachname).
 	 *
-	 * @param n Anzahl der Beispieldaten.
+	 * @param count Anzahl der Beispieldaten.
 	 * @return Ein Array mit den Beispieldaten.
 	 */
-	public static String[] fakeFullnames( int n ) {
+	public static String[] fakeFullnames( int count ) {
-		String[][] data = loadMockfile("users");
+		return randomSample("users", count, ( line ) -> {
-		String[] result = new String[n];
+			String[] parts = line.split(",");
-		for( int i = 0; i < n; i++ ) {
+			return parts[0] + " " + parts[1];
-			String[] row = Constants.choice(data);
+		}, String.class);
-			result[i] = row[0] + " " + row[1];
-		}
-		return result;
 	}
 
 
 	/**
 	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Nutzernamen.
 	 *
-	 * @param n Anzahl der Beispieldaten.
+	 * @param count Anzahl der Beispieldaten.
 	 * @return Ein Array mit den Beispieldaten.
 	 */
-	public static String[] fakeUsernames( int n ) {
+	public static String[] fakeUsernames( int count ) {
-		String[][] data = loadMockfile("users");
+		return randomSample("users", count, ( line ) -> line.split(",")[3], String.class);
-		String[] result = new String[n];
-		for( int i = 0; i < n; i++ ) {
-			String[] row = Constants.choice(data);
-			result[i] = row[3];
-		}
-		return result;
 	}
 
 	/**
 	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Passwörter.
 	 *
-	 * @param n Anzahl der Beispieldaten.
+	 * @param count Anzahl der Beispieldaten.
 	 * @return Ein Array mit den Beispieldaten.
 	 */
-	public static String[] fakePasswords( int n ) {
+	public static String[] fakePasswords( int count ) {
-		String[][] data = loadMockfile("users");
+		return randomSample("users", count, ( line ) -> line.split(",")[4], String.class);
-		String[] result = new String[n];
-		for( int i = 0; i < n; i++ ) {
-			String[] row = Constants.choice(data);
-			result[i] = row[4];
-		}
-		return result;
 	}
 
 	/**
 	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger E-Mail-Adressen.
 	 *
-	 * @param n Anzahl der Beispieldaten.
+	 * @param count Anzahl der Beispieldaten.
 	 * @return Ein Array mit den Beispieldaten.
 	 */
-	public static String[] fakeEmails( int n ) {
+	public static String[] fakeEmails( int count ) {
-		String[][] data = loadMockfile("users");
+		return randomSample("users", count, ( line ) -> line.split(",")[5], String.class);
-		String[] result = new String[n];
-		for( int i = 0; i < n; i++ ) {
-			String[] row = Constants.choice(data);
-			result[i] = row[5];
 	}
+
+	/**
+	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger deutscher
+	 * Wörter.
+	 *
+	 * @param count Anzahl der Beispieldaten.
+	 * @return Ein Array mit den Beispieldaten.
+	 */
+	public static String[] fakeStrings( int count ) {
+		return randomSample("words", count, ( line ) -> line, String.class);
+	}
+
+	/**
+	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger
+	 * {@code Date}-Objekte.
+	 *
+	 * @param count Anzahl der Beispieldaten.
+	 * @return Ein Array mit den Beispieldaten.
+	 */
+	public static LocalDate[] fakeDates( int count ) {
+		long nowEpoch = LocalDate.now().toEpochDay();
+		long from = LocalDate.ofEpochDay(nowEpoch - 18 * 365).toEpochDay();
+		long to = LocalDate.ofEpochDay(nowEpoch - 14 * 365).toEpochDay();
+
+		LocalDate[] result = new LocalDate[count];
+		for( int i = 0; i < count; i++ ) {
+			result[i] = LocalDate.ofEpochDay((int) Constants.interpolate(from, to, random()));
+		}
+
+		return result;
+	}
+
+	public static LocalDateTime[] fakeDatetimes( int count ) {
+		long nowEpoch = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
+		long from = LocalDateTime.ofEpochSecond(nowEpoch - 18 * 365, 0, ZoneOffset.UTC).toEpochSecond(ZoneOffset.UTC);
+		long to = LocalDateTime.ofEpochSecond(nowEpoch - 14 * 365, 0, ZoneOffset.UTC).toEpochSecond(ZoneOffset.UTC);
+
+		LocalDateTime[] result = new LocalDateTime[count];
+		for( int i = 0; i < count; i++ ) {
+			result[i] = LocalDateTime.ofEpochSecond((int) Constants.interpolate(from, to, random()), 0, ZoneOffset.UTC);
+		}
+
+		return result;
+	}
+
+	public static String fakeText( int words, int paragraphs ) {
+		String basetext = "";
+		try(
+			InputStream in = Faker.class.getResourceAsStream("mock-text.txt");
+			BufferedReader reader = new BufferedReader(new InputStreamReader(in))
+		) {
+			basetext = reader.readLine();
+		} catch( IOException ex ) {
+			LOG.error(ex, "Error generating fake blindtext: " + ex.getMessage());
+		}
+
+		String result = basetext.repeat(words / 283);
+
+		int w = (words % 283);
+		if( w > 0 ) {
+			Matcher m = Pattern.compile("([a-zA-Z_0-9\\u00C0-\\u017F]+\\W+){" + w + "}").matcher(basetext);
+			if( m.find() ) {
+				result += m.group().stripTrailing();
+			}
+		}
+
+		if( paragraphs > 1 ) {
+			int half = words / paragraphs;
+			final int maxLength = result.length();
+			Matcher m = Pattern.compile("([a-zA-Z_0-9\\u00C0-\\u017F]+\\W+){" + (half - 10) + "," + (half + 10) + "}([a-zA-Z_0-9\\u00C0-\\u017F]+)\\.").matcher(result);
+			if( m.find() ) {
+				result = m.replaceAll(( mr ) -> mr.end() == maxLength ? mr.group().trim() : mr.group().trim() + "\n\n");
+			}
+		}
+
+		return result;
+	}
+
+	public static int[] fakeIntArray( int count, int min, int max ) {
+		int[] arr = new int[count];
+		for( int i = 0; i < count; i++ ) {
+			arr[i] = random(min, max);
+		}
+		return arr;
+	}
+
+	public static List<Integer> fakeIntegerList( int count, int min, int max, List<Integer> list ) {
+		if( list == null ) {
+			list = new ArrayList<>(count);
+		}
+		for( int i = 0; i < count; i++ ) {
+			list.add(random(min, max));
+		}
+		return list;
+	}
+
+	@SuppressWarnings( "unchecked" )
+	private static <T> T[] randomSample( String filename, int count, Function<String, T> transformer, Class<T> type ) {
+		T[] result = (T[]) Array.newInstance(type, count);
+
+		int i = 0;
+		double k = count; // cast to double
+
+		double W = exp(log(random()) / k);
+
+		try(
+			InputStream in = Faker.class.getResourceAsStream("mock-" + filename + ".csv");
+			BufferedReader reader = new BufferedReader(new InputStreamReader(in))
+		) {
+			String line;
+			while( (line = reader.readLine()) != null ) {
+				if( i < count ) {
+					result[i] = transformer.apply(line);
+					i += 1;
+				} else {
+					int j = (int) (log(random()) / log(1 - W)) + 1;
+					while( j > 0 ) {
+						line = reader.readLine();
+						j -= 1;
+					}
+
+					if( line != null ) {
+						result[random(0, count - 1)] = transformer.apply(line);
+						i += 1;
+					} else {
+						break;
+					}
+
+					W *= exp(log(random()) / k);
+				}
+			}
+
+			// Fill remaining array
+			while( i < count ) {
+				result[i] = result[random(0, i - 1)];
+				i += 1;
+			}
+		} catch( IOException ex ) {
+			LOG.error(ex, "Error loading mock data file: " + ex.getMessage());
+		}
+
 		return result;
 	}
 
@@ -165,7 +308,7 @@ public final class Faker {
 			FontMetrics fontMerics = graphics.getFontMetrics();
 			LineMetrics lineMetrics = fontMerics.getLineMetrics(text, graphics);
 			graphics.drawString(text,
-				(int) ((width - fontMerics.stringWidth(text)) / 2),
+				(width - fontMerics.stringWidth(text)) / 2,
 				(int) (height / 2 - lineMetrics.getDescent() + lineMetrics.getAscent() / 2)
 			);
 			graphics.dispose();
@@ -176,15 +319,9 @@ public final class Faker {
 		}
 	}
 
-	public static String fakeText( int words, int paragraphs ) {
-		return "";
-	}
-
-	private static String[][] loadMockfile( String name ) {
-		return FileLoader.loadCsv("schule/ngb/zm/util/mock-" + name + ".csv", true);
-	}
-
 	private Faker() {
 	}
 
+	private static final Log LOG = Log.getLogger(Faker.class);
+
 }

src/main/java/schule/ngb/zm/util/Noise.java

@@ -3,7 +3,7 @@ package schule.ngb.zm.util;
 import java.util.Random;
 
 /**
- * Zufallsgenerator für Perlin-Noise.
+ * Generator für Perlin-Noise.
  * <p>
  * Die Implementierung basiert auf dem von Ken Perlin entwickelten Algorithmus
  * und wurde anhand der <a
@@ -18,7 +18,7 @@ public class Noise {
 	private static final int M = N - 1;
 
 	/**
-	 * Interne Permutationstabelle für diesen Generator
+	 * Interne Permutationstabelle für diesen Generator.
 	 */
 	private int[] p;
 

src/main/java/schule/ngb/zm/util/Timer.java

@@ -3,13 +3,13 @@ package schule.ngb.zm.util;
 import java.util.concurrent.TimeUnit;
 
 /**
- * Eine Hilfsklasse zur Zeitmessung im Nanosekundenbereich.
+ * Helferklasse zur Zeitmessung im Nanosekundenbereich.
  * <p>
- * Die Klasse kann zum Beispiel genutzt werden, um die Laufzeit eines
+ * Mit einem {@code Timer} kann zum Beispiel die Laufzeit eines Algorithmus
- * Quelltextes zu messen. Wie eine echte Stoppuhr läuft der {@code Timer}
+ * gemessen werden. Wie eine echte Stoppuhr läuft der {@code Timer} weiter, wenn
- * weiter, wenn nach einem {@link #stop()} wieder {@link #start()} aufgerufen
+ * nach einem {@link #stop()} wieder {@link #start()} aufgerufen wird. Soll die
- * wird. Soll die Zeitmessung wieder bei null beginnen, muss vorher
+ * Zeitmessung wieder bei null beginnen, muss vorher {@link #reset()} genutzt
- * {@link #reset()} genutzt werden.
+ * werden.
  * <p>
  * Die gemessene Zeit kann in {@link #getMillis() Millisekunden} oder
  * {@link #getSeconds() Sekunden} abgerufen werden. Wird eine noch größere
@@ -100,7 +100,7 @@ public final class Timer {
 	}
 
 	/**
-	 * Stoppt den {@code Timer}, wenn er derzeit läuft. Die gemessene Zeit wird
+	 * Stoppt den {@code Timer}, wenn er derzeit läuft. Die gemessene Dauer wird
 	 * zur Summe aller gemessenen Zeiten hinzuaddiert.
 	 *
 	 * @return Dieser {@code Timer} selbst (method chaining).
@@ -116,8 +116,8 @@ public final class Timer {
 
 	/**
 	 * Setzt den {@code Timer} auf den Startzustand und löscht alle bisher
-	 * gemessenen Zeiten. Falls die Zeitmessung gerade läuft, wird sie nicht
+	 * gemessenen Zeiten. Falls die Zeitmessung gerade läuft, stoppt sie nicht,
-	 * gestoppt, sondern läuft vom Zeitpunkt des Aufrufs weiter.
+	 * sondern startet vom Zeitpunkt des Aufrufs neu.
 	 *
 	 * @return Dieser {@code Timer} selbst (method chaining).
 	 */

src/main/java/schule/ngb/zm/util/Validator.java

@@ -3,6 +3,9 @@ package schule.ngb.zm.util;
 import java.util.Objects;
 import java.util.function.Supplier;
 
+/**
+ * Statische Methoden, um Methodenparameter auf Gültigkeit zu prüfen.
+ */
 @SuppressWarnings( "UnusedReturnValue" )
 public class Validator {
 

src/main/java/schule/ngb/zm/util/events/EventDispatcher.java

@@ -7,6 +7,60 @@ import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CopyOnWriteArraySet;
 import java.util.function.BiConsumer;
 
+/**
+ * Implementierung einer EventListener-API basierend auf dem Artikel
+ * <a href="https://org.coloradomesa.edu/~wmacevoy/listen/paper.html">Skilled
+ * Listening in Java</a> von Dr. Warren D. MacEvoy.
+ * <p>
+ * Der {@code EventDispatcher} verwaltet eine Liste von angemeldeten Listenern
+ * in einem {@link CopyOnWriteArraySet}, dass besonders für Situationen geeignet
+ * ist, in denen in der Regel wenige Objekte verwaltet werden müssen, auf die
+ * schnell zugegriffen werden soll und die sich selten ändern. Das trifft in den
+ * meisten Fällen auf die Listener eines Objekts zu.
+ * <p>
+ * Um einen {@code EventDispatcher} zu nutzen, muss eine Schnittstelle als
+ * Unterinterface von {@link Listener} erstellt werden, die Methoden für die
+ * einzelnen Events definiert. In der Regel wird eine Methode pro Event
+ * angelegt, aber dies ist nicht unbedingt notwendig.
+ * <p>
+ * Ein Objekt, dass Events für diese Art von Listener erzeugt, erstellt einen
+ * {@code EventDispatcher} und
+ * {@link #registerEventType(String, BiConsumer) registriert} die notwendigen
+ * Events.
+ *
+ * <pre><code>
+ * EventDispatcher&lt;MyEvent, MyEventListener&gt; dispatcher = new EventDispatcher&lt;&gt;();
+ * dispatcher.registerEventType("start", (evt, listener) -> listener.started(evt));
+ * dispatcher.registerEventType("stop", (evt, listener) -> listener.stopped(evt));
+ * </code></pre>
+ * <p>
+ * Hier werden zwei Events registriert "start" und "stop". Die Bezeichnung der
+ * Events wird nut intern verwendet. Jedes Event registriert eine Funktion, die
+ * den Aufruf der Listener-Schnittstelle umsetzt. In der Regel ist dies ein
+ * Lambda-Ausdruck von zwei Parametern: dem Event-Objekt vom Typ {@code E} und
+ * der Listener, der aufgerufen werden soll, vom Typ {@code L}.
+ * <p>
+ * Nun können {@code MyEventListener} angemeldet und Events ausgelöst werden.
+ *
+ * <pre><code>
+ * public void addEventListener( MyEventListener listener ) {
+ *     dispatcher.addListener(listener);
+ * }
+ *
+ * public void removeEventListener( MyEventListener listener ) {
+ *     dispatcher.removeListener(listener);
+ * }
+ *
+ * public void methodThatCreatesEvents() {
+ *     dispatcher.dispatchEvent("start", new MyEvent());
+ *     // Do something
+ *     dispatcher.dispatchEvent("stop", new MyEvent());
+ * }
+ * </code></pre>
+ *
+ * @param <E> Typ der Event-Objekte.
+ * @param <L> Typ der verwendeten Listener-Schnittstelle.
+ */
 public class EventDispatcher<E, L extends Listener<E>> {
 
 	private final CopyOnWriteArraySet<L> listeners;
@@ -35,6 +89,7 @@ public class EventDispatcher<E, L extends Listener<E>> {
 		listeners.remove(listener);
 	}
 
+	@SuppressWarnings("unused")
 	public boolean hasListeners() {
 		return !listeners.isEmpty();
 	}

src/main/java/schule/ngb/zm/util/events/Listener.java

@@ -1,5 +1,11 @@
 package schule.ngb.zm.util.events;
 
+/**
+ * Generische Basisschnittstelle für die Implementierung von EventListenern.
+ *
+ * @param <E> Typ der Event-Objekte, die von diesem Listener empfangen werden.
+ * @see EventDispatcher
+ */
 public interface Listener<E> {
 
 }

src/main/java/schule/ngb/zm/util/io/FileLoader.java

@@ -4,37 +4,63 @@ import schule.ngb.zm.util.Log;
 
 import java.io.BufferedReader;
 import java.io.IOException;
-import java.net.URISyntaxException;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.stream.Stream;
+import java.util.function.Function;
 
+/**
+ * Helferklasse, um Textdateien in verschiedenen Formaten einzulesen.
+ */
+@SuppressWarnings( "unused" )
 public final class FileLoader {
 
+	/**
+	 * Charset: ASCII
+	 */
 	public static final Charset ASCII = StandardCharsets.US_ASCII;
 
+	/**
+	 * Charset: UTF-8
+	 */
 	public static final Charset UTF8 = StandardCharsets.UTF_8;
 
+	/**
+	 * Charset: UTF-16
+	 */
 	public static final Charset UTF16 = StandardCharsets.UTF_16;
 
+	/**
+	 * Charset: ISO-8859-1
+	 */
 	public static final Charset ISO_8859_1 = StandardCharsets.ISO_8859_1;
 
+	/**
+	 * Lädt die angegebene Textdatei zeilenweise in eine Liste.
+	 * <p>
+	 * Als {@link Charset} wird {@link #UTF8} verwendet.
+	 *
+	 * @param source Die Quelle der Textdatei.
+	 * @return Eine Liste mit den Zeilen der Textdatei.
+	 * @see #loadLines(String, Charset)
+	 */
 	public static List<String> loadLines( String source ) {
 		return loadLines(source, UTF8);
 	}
 
 	/**
-	 * Lädt die angegebene Datei Zeilenweise in eine Liste.
+	 * Lädt die angegebene Textdatei mit dem angegebenen Charset zeilenweise in
+	 * eine Liste.
+	 * <p>
+	 * Am Ende jeder Zeile wird das Symbol für einen Zeilenumbruch ({@code \n})
+	 * entfernt.
 	 *
-	 * @param source
+	 * @param source Die Quelle der Textdatei.
-	 * @param charset
+	 * @param charset Das zu verwendene {@code Charset}.
-	 * @return
+	 * @return Eine Liste mit den Zeilen der Textdatei.
 	 */
 	public static List<String> loadLines( String source, Charset charset ) {
 		try( BufferedReader reader = ResourceStreamProvider.getReader(source, charset) ) {
@@ -52,10 +78,28 @@ public final class FileLoader {
 		}
 	}
 
+	/**
+	 * Lädt den Inhalt der angegebenen Textdatei vollständig in einen String.
+	 * <p>
+	 * Als {@link Charset} wird {@link #UTF8} verwendet.
+	 *
+	 * @param source Eine Quelle für die Textdatei (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath oder Netzwerkressource)
+	 * @return Der Inhalt der Textdatei.
+	 */
 	public static String loadText( String source ) {
 		return loadText(source, UTF8);
 	}
 
+	/**
+	 * Lädt den Inhalt der angegebenen Textdatei mit dem angegebenen
+	 * {@code Charset} vollständig in einen String.
+	 *
+	 * @param source Eine Quelle für die Textdatei (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath oder Netzwerkressource)
+	 * @param charset Der {@code Charset} der Textdatei.
+	 * @return Der Inhalt der Textdatei.
+	 */
 	public static String loadText( String source, Charset charset ) {
 		try( BufferedReader reader = ResourceStreamProvider.getReader(source, charset) ) {
 			StringBuilder result = new StringBuilder();
@@ -73,15 +117,16 @@ public final class FileLoader {
 	}
 
 	/**
-	 * Lädt die Daten aus einer CSV Datei in ein zweidimensionales
+	 * Lädt die Daten aus einer CSV-Datei in ein zweidimensionales
 	 * String-Array.
 	 * <p>
-	 * Der Aufruf entspricht dem Aufruf von
+	 * Der Aufruf entspricht
 	 * <pre><code>
 	 * FileLoader.loadCsv(source, ',', skipFirst, UTF8);
 	 * </code></pre>
 	 *
-	 * @param source Die Quelle der CSV-Daten.
+	 * @param source Eine Quelle für die CSV-Datei (Absoluter Dateipfad,
+	 * 	 * 	Dateipfad im Classpath oder Netzwerkressource)
 	 * @param skipFirst Ob die erste Zeile übersprungen werden soll.
 	 * @return Ein Array mit den Daten als {@code String}s.
 	 * @see #loadCsv(String, char, boolean, Charset)
@@ -91,12 +136,12 @@ public final class FileLoader {
 	}
 
 	/**
-	 * Lädt die Daten aus einer CSV Datei in ein zweidimensionales
+	 * Lädt die Daten aus einer CSV-Datei in ein zweidimensionales
 	 * String-Array.
 	 * <p>
 	 * Die Methode ist nicht in der Lage, komplexe CSV-Dateien zu verarbeiten.
-	 * Insbesondere können Inhalte, die das Trennzeichen {@code separator}
+	 * Insbesondere werden Inhalte, die das Trennzeichen {@code separator}
-	 * enthalten, nicht korrekt erkannt werden. Das Trennzeichen wird unabhängig
+	 * enthalten, nicht korrekt erkannt. Das Trennzeichen wird unabhängig
 	 * vom Kontext immer als Zelltrenner erkannt. (Im Normalfall kann das
 	 * Trennzeichen durch die Verwendung doppelter Anführungszeichen in der Art
 	 * {@code Inhalt,"Inhalt, der Komma enthält",Inhalt} maskiert werden.)

src/main/java/schule/ngb/zm/util/io/ResourceStreamProvider.java

@@ -13,39 +13,38 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 
 /**
- * Helferklasse, um {@link InputStream}s für Resourcen zu erhalten.
+ * Helferklasse, um {@link InputStream}s für Ressourcen zu erhalten.
  */
+@SuppressWarnings("unused")
 public class ResourceStreamProvider {
 
-
 	/**
 	 * Ermittelt zur angegebenen Quelle einen passenden {@link URL} (<em>Unified
-	 * Resource Locator</em>). Eine passende Datei-Resource wird wie folgt
+	 * Resource Locator</em>). Eine passende Datei-Ressource wird wie folgt
 	 * ermittelt:
 	 * <ol>
 	 * <li>Ist {@code source} eine existierende Datei
 	 *    ({@code new File(source}.isFile() == true})?</li>
-	 * <li>Ist {@code source} ein relativer Pfad im Projekt ({@code getResource(source) != null})?.</li>
+	 * <li>Ist {@code source} ein relativer Pfad im Projekt ({@code getResource(source) != null})?</li>
 	 * <li>Ist {@code source} im Classpath enthalten ({@code getClassLoader().getResource(source) != null})?</li>
-	 * <li>Ansonten erstellt ein {@link URL}-Objekt.</li>
+	 * <li>Ansonsten erstelle ein {@link URL}-Objekt.</li>
 	 * </ol>
 	 * <p>
 	 * Ein {@code URL} für die erste gefundene Resource wird zurückgegeben.
-	 * Auftretende Exceptions
-	 * werden als {@link IOException} geworfen.
 	 * <p>
-	 * Bei einer Exception werden die folgenden Quellen nicht mehr abgefragt.
+	 * Auftretende Exceptions werden als {@link IOException} geworfen.
+	 * Bei einer Exception werden die nachfolgenden Quellen nicht mehr abgefragt.
 	 * Eine {@link java.net.MalformedURLException} beim Konstruieren des {@code URL}
 	 * zu einer Datei verhindert daher, dass noch im Classpath gesucht wird.
 	 *
-	 * @param source Eine Quelle für die Resource (Absoluter Dateipfad,
+	 * @param source Eine Quelle für die Ressource (Absoluter Dateipfad,
-	 * 	Dateipfad im Classpath oder Netzwerkresource)
+	 * 	Dateipfad im Classpath oder Netzwerkressource)
-	 * @return Ein {@code InputStream} für die Resource
+	 * @return Ein {@code InputStream} für die Ressource
 	 * @throws NullPointerException     Falls {@code source} {@code null} ist.
 	 * @throws IllegalArgumentException Falls {@code source} ein leerer String
 	 *                                  ist.
 	 * @throws IOException              Geworfen beim Erzeugen einer URL zu
-	 *                                  einer bestehenden Resource.
+	 *                                  einer bestehenden Ressource.
 	 */
 	public static URL getResourceURL( String source ) throws NullPointerException, IllegalArgumentException, IOException {
 		Validator.requireNotNull(source, "Resource source may not be null");
@@ -66,12 +65,12 @@ public class ResourceStreamProvider {
 	}
 
 	/**
-	 * Sucht eine zur angegebenen Quelle passende Resource und öffnet einen
+	 * Sucht eine zur angegebenen Quelle passende Ressource und öffnet einen
 	 * passenden {@link InputStream}. Die konkrete Art des Streams hängt davon
-	 * ab, welche Art an Resource gefunden wird:
+	 * ab, welche Art an Ressource gefunden wird:
 	 * <ol>
 	 * <li>Ist {@code source} eine existierende Datei
-	 *    {@code new File(source}.isFile() == true}, dann wird ein
+	 *    {@code new File(source).isFile() == true}, dann wird ein
 	 *    {@link FileInputStream} erstellt.</li>
 	 * <li>Ist {@code source} ein relativer Pfad im Projekt, wird ein passender
 	 * 	Stream mit {@link Class#getResourceAsStream(String)} geöffnet.</li>
@@ -81,35 +80,44 @@ public class ResourceStreamProvider {
 	 *    {@link URL#openStream() Netwerkstream} geöffnet.</li>
 	 * </ol>
 	 * <p>
-	 * Die Möglichen Resourcen werden in der gelisteten Reihenfolge durchprobiert
+	 * Die Möglichen Ressourcen werden in der gelisteten Reihenfolge durchprobiert
 	 * und der erste gefundene Stream zurückgegeben. Auftretende Exceptions
 	 * werden als {@link IOException} geworfen. Das bedeutet, falls für {@code source}
-	 * keine gültige Resource gefunden werden kann, wird am Ende die
+	 * keine gültige Ressource gefunden werden kann, wird am Ende die
 	 * von {@link URL#openStream()} erzeugte {@code IOException} geworfen.
 	 * <p>
-	 * Bei einer Exception werden die folgenden Quellen nicht mehr abgefragt.
+	 * Bei einer Exception werden die nachfolgenden Quellen nicht mehr abgefragt.
 	 * Eine {@link SecurityException} beim Öffnen des {@code FileInputStream}
 	 * (zum Beispiel, weil auf eine existierende Datei keine Leserechte bestehen)
 	 * verhindert daher, dass noch im Classpath gesucht wird.
 	 *
-	 * @param source Eine Quelle für die Resource (Absoluter Dateipfad,
+	 * @param source Eine Quelle für die Ressource (Absoluter Dateipfad,
-	 * 	Dateipfad im Classpath oder Netzwerkresource)
+	 * 	Dateipfad im Classpath oder Netzwerkresource).
-	 * @return Ein {@code InputStream} für die Resource
+	 * @return Ein {@code InputStream} für die Ressource.
 	 * @throws NullPointerException     Falls {@code source} {@code null} ist.
 	 * @throws IllegalArgumentException Falls {@code source} ein leerer String
 	 *                                  ist.
 	 * @throws IOException              Geworfen beim Öffnen des Streams zu
-	 *                                  einer bestehenden Resource oder falls
+	 *                                  einer bestehenden Ressource oder falls
-	 *                                  keine passende Resource gefunden wurde.
+	 *                                  keine passende Ressource gefunden
+	 *                                  wurde.
 	 */
 	public static InputStream getInputStream( String source ) throws NullPointerException, IllegalArgumentException, IOException {
 		return getResourceURL(source).openStream();
 	}
 
 	/**
-	 * @param source
+	 * Sucht eine zur angegebenen Quelle passende Ressource und öffnet einen
-	 * @return
+	 * passenden {@link OutputStream}.
-	 * @throws IOException
+	 * <p>
+	 * Es wird davon ausgegangen, dass die Quelle auf eine Datei verweist, auf
+	 * die Schreibrechte bestehen. Ist dies nicht der Fall, wird eine
+	 * {@link IOException} geworfen.
+	 *
+	 * @param source Eine Quelle für die Ressource (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath).
+	 * @return {@code OutputStream} für die Ressource.
+	 * @throws IOException Falls die Quelle kein gültiges Ziel beschreibt.
 	 */
 	public static OutputStream getOutputStream( String source ) throws IOException {
 		try {
@@ -119,22 +127,83 @@ public class ResourceStreamProvider {
 		}
 	}
 
+	/**
+	 * Sucht eine zur angegebenen Quelle passende Ressource und öffnet einen
+	 * {@link BufferedReader}.
+	 * <p>
+	 * Die Suche erfolgt, wie bei {@link #getInputStream(String)} beschrieben.
+	 * <p>
+	 * Als {@link Charset} wird {@link StandardCharsets#UTF_8 UTF-8} verwendet.
+	 *
+	 * @param source Eine Quelle für die Ressource (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath oder Netzwerkresource).
+	 * @return Ein {@code BufferedReader} für die Quelle.
+	 * @throws IOException Falls die Quelle nicht exisitert oder nicht geöffnet
+	 *                     werden kann.
+	 * @see #getInputStream(String)
+	 */
 	public static BufferedReader getReader( String source ) throws IOException {
 		return getReader(source, StandardCharsets.UTF_8);
 	}
 
+	/**
+	 * Sucht eine zur angegebenen Quelle passende Ressource und öffnet einen
+	 * {@link BufferedReader} mit dem angegebenen Charset.
+	 * <p>
+	 * Die Suche erfolgt wie bei {@link #getInputStream(String)} beschrieben.
+	 *
+	 * @param source Eine Quelle für die Ressource (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath oder Netzwerkresource).
+	 * @param charset Der zu verwendende Charset.
+	 * @return Ein {@code BufferedReader} für die Quelle.
+	 * @throws IOException Falls die Quelle nicht exisitert oder nicht geöffnet
+	 *                     werden kann.
+	 * @see #getInputStream(String)
+	 */
 	public static BufferedReader getReader( String source, Charset charset ) throws IOException {
 		return new BufferedReader(new InputStreamReader(getInputStream(source), charset.newDecoder()));
 	}
 
+	/**
+	 * Sucht eine zur angegebenen Quelle passende Datei und öffnet einen
+	 * {@link BufferedWriter}.
+	 * <p>
+	 * Die Suche erfolgt wie bei {@link #getOutputStream(String)} beschrieben.
+	 * <p>
+	 * Als {@link Charset} wird {@link StandardCharsets#UTF_8 UTF-8} verwendet.
+	 *
+	 * @param source Eine Quelle für die Ressource (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath oder Netzwerkresource).
+	 * @return Ein {@code BufferedWriter} für die Quelle.
+	 * @throws IOException Falls die Quelle nicht exisitert oder nicht geöffnet
+	 *                     werden kann.
+	 * @see #getOutputStream(String)
+	 */
 	public static BufferedWriter getWriter( String source ) throws IOException {
 		return getWriter(source, StandardCharsets.UTF_8);
 	}
 
+	/**
+	 * Sucht eine zur angegebenen Quelle passende Datei und öffnet einen
+	 * {@link BufferedWriter}.
+	 * <p>
+	 * Die Suche erfolgt wie bei {@link #getOutputStream(String)} beschrieben.
+	 * <p>
+	 * Als {@link Charset} wird {@link StandardCharsets#UTF_8 UTF-8} verwendet.
+	 *
+	 * @param source Eine Quelle für die Ressource (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath oder Netzwerkresource).
+	 * @return Ein {@code BufferedWriter} für die Quelle.
+	 * @param charset Der zu verwendende Charset.
+	 * @throws IOException Falls die Quelle nicht exisitert oder nicht geöffnet
+	 *                     werden kann.
+	 * @see #getOutputStream(String)
+	 */
 	public static BufferedWriter getWriter( String source, Charset charset ) throws IOException {
 		return new BufferedWriter(new OutputStreamWriter(getOutputStream(source), charset.newEncoder()));
 	}
 
+	// Privater C'tor
 	private ResourceStreamProvider() {
 	}
 

src/main/resources/schule/ngb/zm/util/mock-text.txt

@@ -0,0 +1 @@
+Weit hinten, hinter den Wortbergen, fern der Länder Vokalien und Konsonantien leben die Blindtexte. Abgeschieden wohnen Sie in Buchstabhausen an der Küste des Semantik, eines großen Sprachozeans. Ein kleines Bächlein namens Duden fließt durch ihren Ort und versorgt sie mit den nötigen Regelialien. Es ist ein paradiesmatisches Land, in dem einem gebratene Satzteile in den Mund fliegen. Nicht einmal von der allmächtigen Interpunktion werden die Blindtexte beherrscht - ein geradezu unorthographisches Leben. Eines Tages aber beschloß eine kleine Zeile Blindtext, ihr Name war Lorem Ipsum, hinaus zu gehen in die weite Grammatik. Der große Oxmox riet ihr davon ab, da es dort wimmele von bösen Kommata, wilden Fragezeichen und hinterhältigen Semikoli, doch das Blindtextchen ließ sich nicht beirren. Es packte seine sieben Versalien, schob sich sein Initial in den Gürtel und machte sich auf den Weg. Als es die ersten Hügel des Kursivgebirges erklommen hatte, warf es einen letzten Blick zurück auf die Skyline seiner Heimatstadt Buchstabhausen, die Headline von Alphabetdorf und die Subline seiner eigenen Straße, der Zeilengasse. Wehmütig lief ihm eine rethorische Frage über die Wange, dann setzte es seinen Weg fort. Unterwegs traf es eine Copy. Die Copy warnte das Blindtextchen, da, wo sie herkäme wäre sie zigmal umgeschrieben worden und alles, was von ihrem Ursprung noch übrig wäre, sei das Wort "und" und das Blindtextchen solle umkehren und wieder in sein eigenes, sicheres Land zurückkehren. Doch alles Gutzureden konnte es nicht überzeugen und so dauerte es nicht lange, bis ihm ein paar heimtückische Werbetexter auflauerten, es mit Longe und Parole betrunken machten und es dann in ihre Agentur schleppten, wo sie es für ihre Projekte wieder und wieder mißbrauchten. Und wenn es nicht umgeschrieben wurde, dann benutzen Sie es immernoch.

src/main/resources/schule/ngb/zm/util/mock-words.csv

@@ -0,0 +1,949 @@
+Abbau
+Abend
+Abzug
+Adler
+Adolf
+Agent
+Akten
+Aktie
+Alarm
+Album
+Allee
+Alpen
+Ampel
+Amtes
+Anbau
+Angst
+Anruf
+Anton
+Anzug
+Apple
+April
+Areal
+Arena
+Armee
+Armut
+Arten
+Asien
+Athen
+Augen
+Autor
+Autos
+Baden
+Bande
+Bands
+Basel
+Basis
+Bauch
+Bauer
+Bayer
+Beate
+Beide
+Beine
+Beleg
+Bernd
+Beruf
+Beste
+Beton
+Beute
+Bevor
+Bezug
+Bibel
+Bitte
+Blatt
+Blick
+Block
+Blues
+Bogen
+Bombe
+Boris
+Brand
+Braun
+Brief
+Bruch
+Bruno
+Brust
+Buben
+Buche
+Busse
+Bäume
+Böden
+Börse
+Bühne
+Büros
+Chaos
+Chefs
+Chile
+China
+Clubs
+Coach
+Daher
+Damen
+Daran
+Darum
+Datei
+Daten
+Datum
+Dauer
+David
+Davon
+Decke
+Deren
+Diana
+Dinge
+Donau
+Doris
+Drama
+Dreck
+Druck
+Duell
+Durch
+Ecken
+Edith
+Eiern
+Eisen
+Elite
+Engel
+Enkel
+Erbin
+Erich
+Erika
+Erlös
+Ernst
+Erste
+Erwin
+Essen
+Ethik
+Fahne
+Fahrt
+Falls
+Farbe
+Faust
+Fazit
+Feier
+Feind
+Felix
+Ferne
+Feuer
+Figur
+Filme
+Films
+Firma
+Fisch
+Flüge
+Focus
+Folge
+Fonds
+Forum
+Fotos
+Foyer
+Franc
+Frank
+Franz
+Frist
+Fritz
+Front
+Frust
+Fuchs
+Fulda
+Fälle
+Fülle
+Füßen
+Geben
+Gebot
+Gehen
+Gehör
+Geist
+Georg
+Gerda
+Gerät
+Geste
+Glanz
+Glück
+Gnade
+Gramm
+Griff
+Group
+Grund
+Grüne
+Gunst
+Gutes
+Gäste
+Güter
+Haare
+Haars
+Hafen
+Halle
+Hanau
+Handy
+Harry
+Hauch
+Hause
+Hebel
+Heike
+Heims
+Heinz
+Helga
+Henry
+Herrn
+Hilfe
+Hitze
+Horst
+Hosen
+Hotel
+Huber
+Humor
+Hunde
+Hände
+Härte
+Hätte
+Höhen
+Hölle
+Hörer
+Hügel
+Hürde
+Hütte
+Ideen
+Image
+Index
+Indiz
+Infos
+Insel
+Intel
+Irene
+Islam
+Jahre
+Jakob
+James
+Japan
+Jeans
+Jesus
+Josef
+Jubel
+Juden
+Julia
+Jungs
+Jutta
+Jäger
+Kabel
+Kabul
+Kader
+Kairo
+Kampf
+Kanal
+Karin
+Karte
+Kasse
+Kenia
+Kette
+Kinos
+Kirch
+Klage
+Klaus
+Klima
+Klubs
+Kohle
+Kohls
+Konto
+Kopie
+Korea
+Kraft
+Krebs
+Kreis
+Kreml
+Kreuz
+Krieg
+Kripo
+Krise
+Krone
+Krupp
+Kugel
+Kunde
+Kunst
+Kurse
+Kurve
+König
+Köpfe
+Küche
+Kürze
+Küste
+Labor
+Lager
+Laien
+Lande
+Lange
+Laufe
+Laune
+Leder
+Legen
+Lehre
+Leser
+Leute
+Licht
+Linie
+Linke
+Liste
+Liter
+Logik
+Lokal
+Luxus
+Lyrik
+Löhne
+Löwen
+Lücke
+Macht
+Mafia
+Magen
+Mainz
+Major
+Maler
+Maria
+Marie
+Mario
+Marke
+Markt
+Maske
+Masse
+Match
+Mauer
+Media
+Meist
+Menge
+Meter
+Metro
+Meyer
+Miami
+Milch
+Minen
+Mitte
+Monat
+Moral
+Motiv
+Motor
+Motto
+Musik
+Möbel
+Nacht
+Nagel
+Namen
+Natur
+Nazis
+Nebel
+Netze
+Noten
+Ohren
+Onkel
+Opfer
+Orden
+Organ
+Orten
+Oskar
+Osten
+Paare
+Paket
+Panik
+Papst
+Paris
+Parks
+Party
+Pause
+Pence
+Peter
+Petra
+Pferd
+Pfund
+Phase
+Pilot
+Platz
+Polen
+Preis
+Prinz
+Probe
+Profi
+Prosa
+Punkt
+Quote
+Rache
+Radio
+Rande
+Rasen
+Ratte
+Rauch
+Regel
+Regen
+Regie
+Reihe
+Rente
+Reste
+Rhein
+Rolle
+Roman
+Route
+Rover
+Rubel
+Russe
+Räder
+Römer
+Sache
+Sauna
+Schau
+Schoß
+Seele
+Segen
+Seite
+Sekte
+Senat
+Seoul
+Serie
+Shell
+Sicht
+Simon
+Sinne
+Smith
+Songs
+Sonne
+Sound
+Spiel
+Sport
+Spree
+Staat
+Stadt
+Stamm
+Stars
+Start
+Stasi
+Staub
+Staus
+Stein
+Stern
+Stirn
+Stock
+Stoff
+Story
+Strom
+Stufe
+Stuhl
+Sturm
+Sturz
+Stück
+Summe
+Szene
+Sätze
+Söhne
+Süden
+Tagen
+Tages
+Tante
+Tarif
+Teams
+Tempo
+Tenor
+Tests
+Texas
+Texte
+Thema
+These
+Thron
+Tiefs
+Tiere
+Tiger
+Tisch
+Titel
+Todes
+Tokio
+Tonne
+Toren
+Traum
+Treff
+Trend
+Trick
+Trios
+Trost
+Typen
+Täter
+Tönen
+Türen
+Türke
+UdSSR
+Uhren
+Ulmer
+Umbau
+Umzug
+Union
+Unmut
+Vater
+Vetos
+Video
+Villa
+Viren
+Virus
+Vogts
+Votum
+Vögel
+Waffe
+Weber
+Weile
+Welle
+Werke
+Werks
+Wesen
+Wiese
+Wille
+Willi
+Wirte
+Wirts
+Witwe
+Witze
+Woche
+Wolke
+World
+Worte
+Wände
+Wüste
+Zaire
+Zeile
+Zelle
+Zeugs
+Ziels
+Zitat
+Zorns
+Zunge
+Zweck
+Zähne
+Zügen
+ahnen
+ahnst
+aktiv
+allem
+allen
+aller
+alles
+allzu
+altem
+alten
+altes
+angab
+armen
+außen
+außer
+bauen
+baute
+bekam
+berge
+berät
+besaß
+bezog
+biete
+birgt
+blaue
+blieb
+blind
+bloße
+boten
+brach
+breit
+bunte
+bösen
+dabei
+dafür
+dahin
+damit
+darin
+davor
+deine
+denen
+denke
+denkt
+derer
+desto
+dicht
+dicke
+dient
+diese
+drauf
+dreht
+drohe
+droht
+dürfe
+ebene
+echte
+ehren
+eigen
+einem
+einen
+einer
+eines
+einig
+einst
+eisig
+elend
+enden
+endet
+engem
+engen
+enger
+enges
+enorm
+erben
+ergab
+erhob
+ernte
+etwas
+ewige
+exakt
+extra
+fehle
+fehlt
+feine
+feste
+finde
+folgt
+frage
+fragt
+freie
+fremd
+freut
+frühe
+fähig
+fällt
+fängt
+fügte
+fühle
+fühlt
+führe
+führt
+füllt
+gaben
+ganze
+gegen
+gelbe
+gelte
+gemäß
+genau
+genug
+gerne
+getan
+geübt
+ginge
+gingt
+glatt
+graue
+große
+gutem
+guten
+haben
+halbe
+halte
+heben
+hebst
+hefte
+heiße
+heißt
+helle
+heran
+herum
+heuer
+heute
+hielt
+hilft
+hinzu
+hoffe
+hofft
+hohem
+hohes
+holen
+holte
+hängt
+höher
+hören
+hörte
+ideal
+ihnen
+ihrem
+ihren
+ihrer
+ihres
+immer
+indem
+indes
+innen
+jedem
+jeden
+jeder
+jedes
+jeher
+jenem
+jenen
+jener
+jenes
+jetzt
+junge
+kalte
+kauft
+kehrt
+keine
+kenne
+kennt
+klagt
+klang
+klare
+klein
+knapp
+komme
+kommt
+krank
+kämen
+könne
+lacht
+laden
+lagen
+lasse
+leben
+lebte
+leere
+legte
+lehnt
+lehrt
+leise
+lernt
+lesen
+liebe
+liebt
+liege
+liegt
+liest
+ließe
+links
+lobte
+lockt
+lohnt
+lässt
+läuft
+lösen
+löste
+mache
+manch
+meine
+meint
+merkt
+messe
+miete
+minus
+morde
+mögen
+müsse
+nahen
+neben
+nebst
+nehme
+nennt
+nette
+neuem
+neuen
+neuer
+neues
+nicht
+nimmt
+näher
+nötig
+nützt
+obere
+offen
+ordne
+packe
+packt
+parat
+passe
+passt
+plane
+plant
+prüfe
+prüft
+quasi
+rasch
+raten
+reale
+recht
+reden
+redet
+reich
+reine
+reise
+reist
+rollt
+rotem
+roten
+roter
+rotes
+rufen
+ruhen
+ruhig
+runde
+räume
+räumt
+rückt
+sagen
+sagte
+sahen
+sanft
+satte
+sauer
+saßen
+schuf
+schön
+sechs
+sehen
+seien
+seine
+sende
+setze
+setzt
+siege
+siehe
+sieht
+singt
+sinkt
+sitze
+sitzt
+sogar
+solch
+solle
+sollt
+somit
+sonst
+sorge
+sorgt
+sowie
+spare
+spart
+spitz
+späte
+spürt
+stahl
+stand
+starb
+stark
+statt
+stehe
+steht
+stets
+stich
+stieg
+stieß
+still
+stolz
+stoße
+stört
+stößt
+suche
+sucht
+tanze
+tanzt
+taten
+teile
+teils
+teilt
+teuer
+teure
+tiefe
+tolle
+total
+totem
+toter
+totes
+traue
+traut
+treue
+trieb
+trink
+tritt
+trotz
+träge
+trägt
+tätig
+töten
+tötet
+unser
+unten
+unter
+vagem
+vagen
+vager
+vages
+viele
+volle
+vorab
+voran
+vorne
+wagen
+wahre
+waren
+warnt
+warst
+warte
+warum
+wecke
+weckt
+weder
+wegen
+wehre
+wehrt
+weich
+weist
+weite
+weiße
+welch
+wende
+wenig
+werbe
+werde
+werte
+wider
+widme
+wiegt
+wilde
+wirbt
+wirft
+wirke
+wirkt
+wisse
+wobei
+wofür
+woher
+wohin
+wohne
+wohnt
+wolle
+womit
+wovon
+wuchs
+wunde
+wurde
+wähle
+wählt
+wärme
+zahle
+zeige
+zeigt
+zeuge
+zieht
+ziele
+zielt
+zivil
+zogen
+zudem
+zumal
+zuvor
+zwang
+zwölf
+zählt
+zügig
+Ämter
+Ärger
+Ärzte
+Übung
+älter
+öffne
+öfter
+übrig
+übten

src/test/java/schule/ngb/zm/ConstantsTest.java

@@ -25,10 +25,28 @@ class ConstantsTest {
 		assertEquals(5.0, Constants.max(new double[]{ 5.0, 5.0, 5.0, 5.0, 5.0 }), 0.000001);
 		assertEquals(5.0, Constants.max(new double[]{ 5.0 }), 0.000001);
 
-		assertThrows(IllegalArgumentException.class, () -> Constants.max(null));
+		double[] doubleArr = null;
+		assertThrows(IllegalArgumentException.class, () -> Constants.max(doubleArr));
 		assertThrows(IllegalArgumentException.class, () -> Constants.max(new double[]{}));
 	}
 
+	@Test
+	void maxInt() {
+		assertEquals(5, Constants.max(5, 0));
+		assertEquals(5, Constants.max(5, 4));
+		assertEquals(5, Constants.max(5, 5));
+		assertEquals(100, Constants.max(100, -100));
+		assertEquals(0, Constants.max(0, 0));
+
+		assertEquals(5, Constants.max(new double[]{ 0, 1, 2, 3, 4, 5 }));
+		assertEquals(5, Constants.max(new double[]{ 5, 5, 5, 5, 5 }));
+		assertEquals(5, Constants.max(new double[]{ 5 }));
+
+		int[] intArr = null;
+		assertThrows(IllegalArgumentException.class, () -> Constants.max(intArr));
+		assertThrows(IllegalArgumentException.class, () -> Constants.max(new int[]{}));
+	}
+
 	@Test
 	void abs() {
 		assertEquals(5.0, Constants.abs(5.0), 0.000001);

src/test/java/schule/ngb/zm/util/FileLoaderTest.java

@@ -5,7 +5,8 @@ import schule.ngb.zm.util.io.FileLoader;
 
 import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class FileLoaderTest {