Changelog update

Ebene der Unterüberschrift auf h2 angepasst

.gitignore

@@ -48,3 +48,11 @@ gradle-app.setting
 
 # Cache of project
 .gradletasknamecache
+
+# Python mkdocs
+.venv
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class

CHANGELOG.md

@@ -6,6 +6,22 @@ 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.
+- `io` Klassen nutzen nun mehr der `java.nio` Funktionen.
+- Package-Struktur angepasst.
+
+## Version 0.0.23
+
 ### Added
 - System für EventListener.
   - `AudioListener` und `AnimationListener` als erste Anwendungsfälle.

build.gradle

@@ -3,17 +3,13 @@ plugins {
     id 'java-library'
 }
 
-/*properties {
-	zmVersion {
-		major = 0;
-		minor = 0;
-		rev = 21;
-	}
-}*/
-
 group 'schule.ngb'
-version '0.0.22-SNAPSHOT'
-//version '{$zmVersion.major}.{$zmVersion.minor}.{$zmVersion.rev}-SNAPSHOT'
+version '0.0.34-SNAPSHOT'
+
+java {
+	withSourcesJar()
+	withJavadocJar()
+}
 
 compileJava {
     options.release = 11
@@ -48,4 +44,5 @@ tasks.register('jarMP3SPI', Jar) {
 	from {
 		configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
 	}
+	with jar
 }

docs/assets/quickstart/AblaufMoleActive.excalidraw

@@ -0,0 +1,634 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    {
+      "type": "rectangle",
+      "version": 152,
+      "versionNonce": 1288225375,
+      "isDeleted": false,
+      "id": "fxk8rHocjpTteICJMa6n8",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 619.9963325816416,
+      "y": 186.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "#fab005",
+      "width": 150,
+      "height": 46,
+      "seed": 1339263918,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "JmEBjNProPAgJQZUvMGGa"
+        },
+        {
+          "id": "eryKwAzIMcBMQP0Ybl1Mm",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1670307372550,
+      "link": null,
+      "locked": false
+    },
+    {
+      "type": "rectangle",
+      "version": 264,
+      "versionNonce": 1267158257,
+      "isDeleted": false,
+      "id": "wZLPkORf755_2Vp0J6I0V",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 566.9963325816416,
+      "y": 289.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "#fab005",
+      "width": 248,
+      "height": 50,
+      "seed": 359801906,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "9TujIdwDvtinylO3z50y6"
+        },
+        {
+          "id": "eryKwAzIMcBMQP0Ybl1Mm",
+          "type": "arrow"
+        },
+        {
+          "id": "Zc9GOJ8DsIQYo4WaGvvHy",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1670307379131,
+      "link": null,
+      "locked": false
+    },
+    {
+      "type": "rectangle",
+      "version": 376,
+      "versionNonce": 1807861489,
+      "isDeleted": false,
+      "id": "290mWFx31fA5smc5FqPUr",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 607.9963325816416,
+      "y": 392.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "#228be6",
+      "width": 143,
+      "height": 50,
+      "seed": 1948766318,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "_ISR-LCZm2Hu2G57R_uxN"
+        },
+        {
+          "id": "Zc9GOJ8DsIQYo4WaGvvHy",
+          "type": "arrow"
+        },
+        {
+          "id": "hUUqTCXva-vZjnBeM-PR3",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1670307888001,
+      "link": null,
+      "locked": false
+    },
+    {
+      "type": "rectangle",
+      "version": 518,
+      "versionNonce": 2136415391,
+      "isDeleted": false,
+      "id": "kbEG_cCZadugfCPxYedhf",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 614.9963325816416,
+      "y": 589.9758066195944,
+      "strokeColor": "#000000",
+      "backgroundColor": "#228be6",
+      "width": 131,
+      "height": 50,
+      "seed": 97599794,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "6KjVrNy_dxGXJtntdqrjY"
+        },
+        {
+          "id": "hUUqTCXva-vZjnBeM-PR3",
+          "type": "arrow"
+        },
+        {
+          "id": "bplSSGA4kyy-Av7nKNK1B",
+          "type": "arrow"
+        },
+        {
+          "id": "qukSk_W6enSdwERPEPkhZ",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1670307888001,
+      "link": null,
+      "locked": false
+    },
+    {
+      "type": "text",
+      "version": 110,
+      "versionNonce": 1350901746,
+      "isDeleted": false,
+      "id": "JmEBjNProPAgJQZUvMGGa",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 643.9963325816416,
+      "y": 199.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "transparent",
+      "width": 102,
+      "height": 20,
+      "seed": 1889147762,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [],
+      "updated": 1670164406970,
+      "link": null,
+      "locked": false,
+      "fontSize": 16,
+      "fontFamily": 1,
+      "text": "new Shapes()",
+      "baseline": 14,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "fxk8rHocjpTteICJMa6n8",
+      "originalText": "new Shapes()"
+    },
+    {
+      "type": "text",
+      "version": 245,
+      "versionNonce": 1536101230,
+      "isDeleted": false,
+      "id": "9TujIdwDvtinylO3z50y6",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 584.9963325816416,
+      "y": 304.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "transparent",
+      "width": 212,
+      "height": 20,
+      "seed": 1297543150,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [],
+      "updated": 1670164433291,
+      "link": null,
+      "locked": false,
+      "fontSize": 16,
+      "fontFamily": 1,
+      "text": "super(800, 800, \"Shapes\")",
+      "baseline": 14,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "wZLPkORf755_2Vp0J6I0V",
+      "originalText": "super(800, 800, \"Shapes\")"
+    },
+    {
+      "type": "text",
+      "version": 362,
+      "versionNonce": 2069822514,
+      "isDeleted": false,
+      "id": "_ISR-LCZm2Hu2G57R_uxN",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 650.4963325816416,
+      "y": 407.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "transparent",
+      "width": 58,
+      "height": 20,
+      "seed": 525219186,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [],
+      "updated": 1670164509204,
+      "link": null,
+      "locked": false,
+      "fontSize": 16,
+      "fontFamily": 1,
+      "text": "setup()",
+      "baseline": 14,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "290mWFx31fA5smc5FqPUr",
+      "originalText": "setup()"
+    },
+    {
+      "type": "text",
+      "version": 502,
+      "versionNonce": 747611665,
+      "isDeleted": false,
+      "id": "6KjVrNy_dxGXJtntdqrjY",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 655.4963325816416,
+      "y": 604.9758066195944,
+      "strokeColor": "#000000",
+      "backgroundColor": "transparent",
+      "width": 50,
+      "height": 20,
+      "seed": 1808016110,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [],
+      "updated": 1670307245844,
+      "link": null,
+      "locked": false,
+      "fontSize": 16,
+      "fontFamily": 1,
+      "text": "draw()",
+      "baseline": 14,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "kbEG_cCZadugfCPxYedhf",
+      "originalText": "draw()"
+    },
+    {
+      "type": "arrow",
+      "version": 31,
+      "versionNonce": 101778865,
+      "isDeleted": false,
+      "id": "eryKwAzIMcBMQP0Ybl1Mm",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 694.9963325816416,
+      "y": 242.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "#12b886",
+      "width": 0,
+      "height": 38,
+      "seed": 1130444978,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "boundElements": [],
+      "updated": 1670307364549,
+      "link": null,
+      "locked": false,
+      "startBinding": {
+        "elementId": "fxk8rHocjpTteICJMa6n8",
+        "focus": 0,
+        "gap": 10
+      },
+      "endBinding": {
+        "elementId": "wZLPkORf755_2Vp0J6I0V",
+        "focus": 0.03225806451612903,
+        "gap": 9
+      },
+      "lastCommittedPoint": null,
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          0,
+          38
+        ]
+      ]
+    },
+    {
+      "type": "arrow",
+      "version": 160,
+      "versionNonce": 1672489439,
+      "isDeleted": false,
+      "id": "Zc9GOJ8DsIQYo4WaGvvHy",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 686.7253597961584,
+      "y": 347.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "#12b886",
+      "width": 0.3256260532492661,
+      "height": 36,
+      "seed": 1138446962,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "boundElements": [],
+      "updated": 1670307364549,
+      "link": null,
+      "locked": false,
+      "startBinding": {
+        "elementId": "wZLPkORf755_2Vp0J6I0V",
+        "gap": 8,
+        "focus": 0.03595554587056003
+      },
+      "endBinding": {
+        "elementId": "290mWFx31fA5smc5FqPUr",
+        "gap": 9,
+        "focus": 0.09195903246894747
+      },
+      "lastCommittedPoint": null,
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -0.3256260532492661,
+          36
+        ]
+      ]
+    },
+    {
+      "type": "arrow",
+      "version": 616,
+      "versionNonce": 447594705,
+      "isDeleted": false,
+      "id": "hUUqTCXva-vZjnBeM-PR3",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 684.6524492354905,
+      "y": 452.97580661959455,
+      "strokeColor": "#000000",
+      "backgroundColor": "#228be6",
+      "width": 1.5815106831711319,
+      "height": 29.000000000000114,
+      "seed": 1169930546,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "boundElements": [],
+      "updated": 1670307888001,
+      "link": null,
+      "locked": false,
+      "startBinding": {
+        "elementId": "290mWFx31fA5smc5FqPUr",
+        "focus": -0.044553538542618336,
+        "gap": 10
+      },
+      "endBinding": {
+        "elementId": "5cG3FjQlYuIGPZMsIMgJU",
+        "focus": 0.08947713014192164,
+        "gap": 6.999999999999915
+      },
+      "lastCommittedPoint": null,
+      "startArrowhead": null,
+      "endArrowhead": "arrow",
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          1.5815106831711319,
+          29.000000000000114
+        ]
+      ]
+    },
+    {
+      "type": "rectangle",
+      "version": 560,
+      "versionNonce": 11022527,
+      "isDeleted": false,
+      "id": "5cG3FjQlYuIGPZMsIMgJU",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 616.4963325816416,
+      "y": 488.9758066195945,
+      "strokeColor": "#000000",
+      "backgroundColor": "#228be6",
+      "width": 131,
+      "height": 50,
+      "seed": 609895569,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": [
+        {
+          "type": "text",
+          "id": "-Fl205ZvyGaxHAHt7C3r3"
+        },
+        {
+          "id": "hUUqTCXva-vZjnBeM-PR3",
+          "type": "arrow"
+        },
+        {
+          "id": "bplSSGA4kyy-Av7nKNK1B",
+          "type": "arrow"
+        },
+        {
+          "id": "qukSk_W6enSdwERPEPkhZ",
+          "type": "arrow"
+        }
+      ],
+      "updated": 1670307888001,
+      "link": null,
+      "locked": false
+    },
+    {
+      "type": "text",
+      "version": 551,
+      "versionNonce": 685087263,
+      "isDeleted": false,
+      "id": "-Fl205ZvyGaxHAHt7C3r3",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "angle": 0,
+      "x": 647.4963325816416,
+      "y": 503.97580661959455,
+      "strokeColor": "#000000",
+      "backgroundColor": "transparent",
+      "width": 69,
+      "height": 20,
+      "seed": 415680767,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "boundElements": null,
+      "updated": 1670307260196,
+      "link": null,
+      "locked": false,
+      "fontSize": 16,
+      "fontFamily": 1,
+      "text": "update()",
+      "baseline": 14,
+      "textAlign": "center",
+      "verticalAlign": "middle",
+      "containerId": "5cG3FjQlYuIGPZMsIMgJU",
+      "originalText": "update()"
+    },
+    {
+      "id": "bplSSGA4kyy-Av7nKNK1B",
+      "type": "arrow",
+      "x": 683.9963325816416,
+      "y": 546.9758066195944,
+      "width": 1,
+      "height": 34,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#228be6",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 1937189809,
+      "version": 33,
+      "versionNonce": 1639939761,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670307888001,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -1,
+          34
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "5cG3FjQlYuIGPZMsIMgJU",
+        "focus": -0.044849023090586096,
+        "gap": 7.999999999999858
+      },
+      "endBinding": {
+        "elementId": "kbEG_cCZadugfCPxYedhf",
+        "focus": 0.022646536412078155,
+        "gap": 9
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow"
+    },
+    {
+      "id": "qukSk_W6enSdwERPEPkhZ",
+      "type": "arrow",
+      "x": 758.9963325816416,
+      "y": 615.9758066195944,
+      "width": 87,
+      "height": 107.99999999999994,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "transparent",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 677436529,
+      "version": 170,
+      "versionNonce": 377207327,
+      "isDeleted": false,
+      "boundElements": [],
+      "updated": 1670307315516,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          86,
+          0
+        ],
+        [
+          83,
+          -106.99999999999994
+        ],
+        [
+          -1,
+          -107.99999999999994
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": {
+        "elementId": "kbEG_cCZadugfCPxYedhf",
+        "focus": 0.04,
+        "gap": 13
+      },
+      "endBinding": {
+        "elementId": "5cG3FjQlYuIGPZMsIMgJU",
+        "focus": -0.26783652736088875,
+        "gap": 10.5
+      },
+      "startArrowhead": null,
+      "endArrowhead": "arrow"
+    }
+  ],
+  "appState": {
+    "gridSize": null,
+    "viewBackgroundColor": "#ffffff"
+  },
+  "files": {}
+}

docs/assets/quickstart/CircleMouseCollision.excalidraw

@@ -0,0 +1,375 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    {
+      "id": "Mhp-wQ2wZxCI4BYWvTvV2",
+      "type": "ellipse",
+      "x": 420,
+      "y": 233,
+      "width": 385.99999999999994,
+      "height": 385.99999999999994,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#ffdf22",
+      "fillStyle": "cross-hatch",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 474299186,
+      "version": 149,
+      "versionNonce": 2072559726,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158627399,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "SqZRA75ACKHo0lB799wpS",
+      "type": "line",
+      "x": 605,
+      "y": 426,
+      "width": 173.02018127597637,
+      "height": 99.89324823492274,
+      "angle": 0,
+      "strokeColor": "#087f5b",
+      "backgroundColor": "#ffdf22",
+      "fillStyle": "cross-hatch",
+      "strokeWidth": 2,
+      "strokeStyle": "dashed",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 484805038,
+      "version": 286,
+      "versionNonce": 1603007154,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670159044301,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          173.02018127597637,
+          -99.89324823492274
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": null,
+      "endBinding": null,
+      "startArrowhead": null,
+      "endArrowhead": null
+    },
+    {
+      "id": "7XVC5Wqiy62pN9Vc92bgl",
+      "type": "text",
+      "x": 645.7358370304399,
+      "y": 356.14958623820286,
+      "width": 86,
+      "height": 20,
+      "angle": 5.766085793504818,
+      "strokeColor": "#087f5b",
+      "backgroundColor": "#ffdf22",
+      "fillStyle": "cross-hatch",
+      "strokeWidth": 2,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 1883808110,
+      "version": 228,
+      "versionNonce": 627525998,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670159044301,
+      "link": null,
+      "locked": false,
+      "text": "moleRadius",
+      "fontSize": 16,
+      "fontFamily": 1,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "baseline": 14,
+      "containerId": null,
+      "originalText": "moleRadius"
+    },
+    {
+      "id": "zp9JMFpfOA6ZEWCCiqwW0",
+      "type": "line",
+      "x": 606,
+      "y": 427,
+      "width": 128.012747010704,
+      "height": 208.02230726873202,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#fa5252",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "dashed",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 224372978,
+      "version": 81,
+      "versionNonce": 563971630,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158772553,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -128.012747010704,
+          -208.02230726873202
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": null,
+      "endBinding": null,
+      "startArrowhead": null,
+      "endArrowhead": null
+    },
+    {
+      "id": "LIDFlKBUhkbZdzTUFT1qp",
+      "type": "line",
+      "x": 604.8240237554426,
+      "y": 425.10629955596494,
+      "width": 127.71248741178238,
+      "height": 4.628286654564533,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#fa5252",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "dashed",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 34525358,
+      "version": 124,
+      "versionNonce": 1131380590,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158787752,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          -127.71248741178238,
+          -4.628286654564533
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": null,
+      "endBinding": null,
+      "startArrowhead": null,
+      "endArrowhead": null
+    },
+    {
+      "id": "-Of3RfHAvJDq0qHIwjm2U",
+      "type": "ellipse",
+      "x": 471.96813247323996,
+      "y": 413.60866976111646,
+      "width": 12,
+      "height": 12,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#4c6ef5",
+      "fillStyle": "solid",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 1050702514,
+      "version": 384,
+      "versionNonce": 1957432558,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158970885,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "NB4WGe-lT7XqLrsKX8jN8",
+      "type": "ellipse",
+      "x": 472,
+      "y": 212,
+      "width": 12,
+      "height": 12,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#fa5252",
+      "fillStyle": "solid",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 2059751730,
+      "version": 277,
+      "versionNonce": 756441010,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158769939,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "T1vEWEHV-1FM4A7Q7dTzy",
+      "type": "ellipse",
+      "x": 601.6117120882632,
+      "y": 422.28007605476614,
+      "width": 6.436664554034337,
+      "height": 6.436664554034337,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#000000",
+      "fillStyle": "solid",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 0,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 1983845742,
+      "version": 376,
+      "versionNonce": 1202556466,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158984089,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "eEMIGJ2Ag5HqWZLPmjXMM",
+      "type": "text",
+      "x": 551.4695946462369,
+      "y": 432.8553279772536,
+      "width": 108,
+      "height": 20,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#000000",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "dashed",
+      "roughness": 0,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 817794290,
+      "version": 97,
+      "versionNonce": 1438641266,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158980419,
+      "link": null,
+      "locked": false,
+      "text": "(moleX, moleY)",
+      "fontSize": 16,
+      "fontFamily": 1,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "baseline": 14,
+      "containerId": null,
+      "originalText": "(moleX, moleY)"
+    },
+    {
+      "id": "6cMmrU3lcJbub8sEKnVWe",
+      "type": "text",
+      "x": 409.80838527586974,
+      "y": 186.48331271464983,
+      "width": 135,
+      "height": 20,
+      "angle": 0,
+      "strokeColor": "#c92a2a",
+      "backgroundColor": "#000000",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "dashed",
+      "roughness": 0,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 399694958,
+      "version": 166,
+      "versionNonce": 1571185842,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158939920,
+      "link": null,
+      "locked": false,
+      "text": "(mouseX, mouseY)",
+      "fontSize": 16,
+      "fontFamily": 1,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "baseline": 14,
+      "containerId": null,
+      "originalText": "(mouseX, mouseY)"
+    },
+    {
+      "id": "0idmv_zLtEYyctHB4lSWV",
+      "type": "text",
+      "x": 406.7568976895149,
+      "y": 390.3911282833501,
+      "width": 135,
+      "height": 20,
+      "angle": 0,
+      "strokeColor": "#364fc7",
+      "backgroundColor": "#000000",
+      "fillStyle": "solid",
+      "strokeWidth": 2,
+      "strokeStyle": "dashed",
+      "roughness": 0,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "sharp",
+      "seed": 1008210350,
+      "version": 224,
+      "versionNonce": 968376110,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670158975919,
+      "link": null,
+      "locked": false,
+      "text": "(mouseX, mouseY)",
+      "fontSize": 16,
+      "fontFamily": 1,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "baseline": 14,
+      "containerId": null,
+      "originalText": "(mouseX, mouseY)"
+    }
+  ],
+  "appState": {
+    "gridSize": null,
+    "viewBackgroundColor": "#ffffff"
+  },
+  "files": {}
+}

docs/assets/quickstart/Layers.excalidraw

@@ -0,0 +1,375 @@
+{
+  "type": "excalidraw",
+  "version": 2,
+  "source": "https://excalidraw.com",
+  "elements": [
+    {
+      "id": "HPGP8tbAPy0aGI3_MCE3D",
+      "type": "diamond",
+      "x": 491.42779164474496,
+      "y": 479.56091158550765,
+      "width": 432.03244941244884,
+      "height": 55.325188818463005,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#868e96",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 1103578030,
+      "version": 138,
+      "versionNonce": 1150893294,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "vhIFJN3-91oJXV-RfFsBf",
+      "type": "diamond",
+      "x": 491.42779164474496,
+      "y": 435.8942449188411,
+      "width": 432.03244941244884,
+      "height": 55.325188818463005,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#fab005",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 618886834,
+      "version": 198,
+      "versionNonce": 1515704562,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "B2pM-4m_3Dk2w_6dY-hVJ",
+      "type": "diamond",
+      "x": 491.42779164474496,
+      "y": 392.2275782521744,
+      "width": 432.03244941244884,
+      "height": 55.325188818463005,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#228be6",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 844345582,
+      "version": 231,
+      "versionNonce": 1954508590,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "Ge28XC9PqD26hknNaFXKP",
+      "type": "diamond",
+      "x": 491.42779164474496,
+      "y": 348.5609115855077,
+      "width": 432.03244941244884,
+      "height": 55.325188818463005,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#40c057",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "solid",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 1326657902,
+      "version": 249,
+      "versionNonce": 685040306,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false
+    },
+    {
+      "id": "PLU80s2TkyMEAOVgolwJx",
+      "type": "line",
+      "x": 506.9963325816415,
+      "y": 507.9758066195945,
+      "width": 0,
+      "height": 132.00000000000006,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#40c057",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 1246804466,
+      "version": 39,
+      "versionNonce": 627399022,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          0,
+          -132.00000000000006
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": null,
+      "endBinding": null,
+      "startArrowhead": null,
+      "endArrowhead": null
+    },
+    {
+      "id": "xDdJ5FnbMLIbN95FE3Iyc",
+      "type": "line",
+      "x": 910.9963325816416,
+      "y": 506.9758066195945,
+      "width": 0,
+      "height": 132,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#40c057",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 1034568050,
+      "version": 77,
+      "versionNonce": 1363786866,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          0,
+          -132
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": null,
+      "endBinding": null,
+      "startArrowhead": null,
+      "endArrowhead": null
+    },
+    {
+      "id": "clYu5Q9GzKbAfohBEsGwn",
+      "type": "line",
+      "x": 709.9963325816416,
+      "y": 532.9758066195944,
+      "width": 0,
+      "height": 129.99999999999994,
+      "angle": 0,
+      "strokeColor": "#000000",
+      "backgroundColor": "#40c057",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 1798035246,
+      "version": 42,
+      "versionNonce": 244579246,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false,
+      "points": [
+        [
+          0,
+          0
+        ],
+        [
+          0,
+          -129.99999999999994
+        ]
+      ],
+      "lastCommittedPoint": null,
+      "startBinding": null,
+      "endBinding": null,
+      "startArrowhead": null,
+      "endArrowhead": null
+    },
+    {
+      "id": "v2nD7_bvWJYHqs82XDWO2",
+      "type": "text",
+      "x": 935.9963325816416,
+      "y": 497.2235059947391,
+      "width": 159,
+      "height": 20,
+      "angle": 0,
+      "strokeColor": "#343a40",
+      "backgroundColor": "#40c057",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 1323260978,
+      "version": 111,
+      "versionNonce": 372528622,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false,
+      "text": "Ebene 0: ColorLayer",
+      "fontSize": 16,
+      "fontFamily": 1,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "baseline": 14,
+      "containerId": null,
+      "originalText": "Ebene 0: ColorLayer"
+    },
+    {
+      "id": "c6T2j8hozL3RZcNYGMgRl",
+      "type": "text",
+      "x": 935.9963325816416,
+      "y": 453.55683932807256,
+      "width": 172,
+      "height": 20,
+      "angle": 0,
+      "strokeColor": "#e67700",
+      "backgroundColor": "#40c057",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 1949746930,
+      "version": 111,
+      "versionNonce": 1448527858,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false,
+      "text": "Ebene 1: DrawingLayer",
+      "fontSize": 16,
+      "fontFamily": 1,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "baseline": 14,
+      "containerId": null,
+      "originalText": "Ebene 1: DrawingLayer"
+    },
+    {
+      "id": "bAmGMg2i4Hvv7t_obXSKn",
+      "type": "text",
+      "x": 935.9963325816416,
+      "y": 409.8901726614059,
+      "width": 174,
+      "height": 20,
+      "angle": 0,
+      "strokeColor": "#1864ab",
+      "backgroundColor": "#40c057",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 706529710,
+      "version": 144,
+      "versionNonce": 1968138286,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163691142,
+      "link": null,
+      "locked": false,
+      "text": "Ebene 2: ShapesLayer",
+      "fontSize": 16,
+      "fontFamily": 1,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "baseline": 14,
+      "containerId": null,
+      "originalText": "Ebene 2: ShapesLayer"
+    },
+    {
+      "id": "9-QieQt-nVqGCe5D4r15j",
+      "type": "text",
+      "x": 935.9963325816416,
+      "y": 366.2235059947392,
+      "width": 65,
+      "height": 20,
+      "angle": 0,
+      "strokeColor": "#2b8a3e",
+      "backgroundColor": "#40c057",
+      "fillStyle": "hachure",
+      "strokeWidth": 1,
+      "strokeStyle": "dotted",
+      "roughness": 1,
+      "opacity": 100,
+      "groupIds": [],
+      "strokeSharpness": "round",
+      "seed": 2100742126,
+      "version": 179,
+      "versionNonce": 289074606,
+      "isDeleted": false,
+      "boundElements": null,
+      "updated": 1670163697684,
+      "link": null,
+      "locked": false,
+      "text": "Ebene 3",
+      "fontSize": 16,
+      "fontFamily": 1,
+      "textAlign": "left",
+      "verticalAlign": "top",
+      "baseline": 14,
+      "containerId": null,
+      "originalText": "Ebene 3"
+    }
+  ],
+  "appState": {
+    "gridSize": null,
+    "viewBackgroundColor": "#ffffff"
+  },
+  "files": {}
+}

docs/assets/zmstyles.css

@@ -0,0 +1,12 @@
+h1.title {
+	text-align: center;
+	color: #363636;
+	margin-bottom: .25rem;
+}
+h2.subtitle {
+	text-align: center;
+	font-size: 1rem;
+	color: #4a4a4a;
+	margin-top: -.25rem;
+	margin-bottom: -1.25rem;
+}

docs/einfuehrung.md

@@ -0,0 +1,43 @@
+
+<figure markdown>
+  ![Zeichenmaschine.xyz](assets/icon_512.png){ width=128 }
+</figure>
+
+<h1 class="title">Zeichenmaschine.xyz</h1>
+<h2 class="subtitle">Eine kleine Java-Bibliothek für grafische Programmierung im 
+Informatikunterricht.</h2>
+
+## Projektidee
+
+Die **Zeichenmaschine** ist eine für den Informatikunterricht entwickelte Bibliothek, 
+die unter anderem an [Processing](https://processing.org/) angelehnt ist. Die 
+Bibliothek soll einige der üblichen Anfängerschwierigkeiten mit Java vereinfachen 
+und für Schülerinnen und Schüler im Unterricht nutzbar machen.
+
+!!! warning
+
+	Das Projekt befindet sich noch in der Entwicklungsphase und auch wenn die 
+	aktuelle Version schon funktionsfähig ist und einen Großteil der angestrebten 
+	Funktionen enthält, ist noch keine stabile Version 1.0 erreicht. Vor allem 
+	am Umfang und konsistenten Design der APIs gilt es noch zu arbeiten und es 
+	können sich Änderungen ergeben.
+
+	Feedback und Vorschläge zu diesem Prozess (oder auch eine Beteiligung an der 
+	Entwicklung) können sehr gerne über [Github](https://github.com/jneug) oder 
+	[Mastodon](https://bildung.social/@ngb) an mich kommuniziert werden.
+	
+	(Gleiches gilt für diese Webseite zum Projekt.)
+
+## Dokumentation
+* [Schnellstart](quickstart.md)
+* [Installation](installation.md)
+* {{ javadoc_link() }}
+
+## Über die Zeichenmaschine
+
+!!! info
+
+	In der Zeichenmaschine werden bewusst nur englischsprachige Bezeichner für 
+	Klassen, Methoden und Variablen verwendet. Ausnahme sind einzelne Klassen,
+	die im Zusammnehang mit dem Namen der Bibliothek stehen, wie die
+	Hauptklasse `Zeichenmaschine`.

docs/home_override/home.html

@@ -0,0 +1,7 @@
+{% extends "base.html" %}
+
+{% block tabs %}
+{{ super() }}
+{% endblock %}
+{% block content %}{% endblock %}
+{% block footer %}{% endblock %}

docs/installation.md

@@ -0,0 +1,46 @@
+# Installation
+
+Um ein einfaches Projekt mit der **Zeichenmaschine** aufzusetzen ist nicht mehr
+nötig, als
+die [JAR-Datei der aktuellen Version](https://github.com/jneug/zeichenmaschine/release/latest)
+herunterzuladen und dem *Classpath* des Projekts hinzuzufügen. Beschreibungen
+für
+verschiedene Entwicklungsumgebungen sind hier aufgelistet.
+
+## Integration in Entwicklungsumgebungen
+
+### BlueJ
+
+[BlueJ](https://bluej.org) sucht an drei Orten nach Bibliotheken, die für ein
+Projekt in den Classpath aufgenommen werden:
+
+- Für ein einzelnes Projekt im Projektordner im Unterordner `+libs`.
+- Im Reiter "Bibliotheken" der BlueJ-Einstellungen.
+
+    Hier können Programmbibliotheken hinzugefügt werden, die dann allen Projekten
+    zur Verfügung stehen.
+
+- Für alle Projekte und alle Nutzer dieser BlueJ-Version im
+  Unterordner `userlib` des Programmordners.
+
+	Auf Windows-Systemen ist dieser im Order `lib` des Installationsordners von BlueJ zu finden.
+
+	Auf macos-Systemen muss via Rechtsklick auf die Programmdatei `BlueJ.app` über den Menüpunkt "Paketinhalt zeigen" in den Ordner `Contents/Resources/Java/` navigiert werden.
+
+### VSCode / VSCodium
+
+> Coming soon
+
+### IntelliJ
+
+> Coming soon
+
+### Eclipse
+
+> Coming soon
+
+### NetBeans
+
+> Coming soon
+
+## Unterstützung für MP3

docs/macros.py

@@ -0,0 +1,128 @@
+import re
+from typing import List
+
+
+def define_env(env):
+    @env.macro
+    def javadoc(clazz: str = None, target: str = None) -> str:
+        if not "javadoc_url" in env.variables:
+            return clazz
+
+        if not clazz:
+            return f"{env.variables['javadoc_url'].rstrip('/')}/index.html"
+        else:
+            if "javadoc_default_package" in env.variables and not clazz.startswith(env.variables['javadoc_default_package']):
+                clazz = f"{env.variables['javadoc_default_package'].rstrip('.')}.{clazz}"
+            javadoc_url = env.variables["javadoc_url"].rstrip("/")
+
+            path = list()
+            name = list()
+
+            for p in clazz.split('.'):
+                if p[0].islower():
+                    path.append(p)
+                else:
+                    name.append(p)
+
+            path = '/'.join(path) + '/' + '.'.join(name) + ".html"
+            if target:
+                path = f"{path}#{target}"
+            return f"{javadoc_url}/{path}"
+
+    @env.macro
+    def jd(cl: str = None, t: str = None) -> str:
+        return javadoc(cl, t)
+
+    @env.macro
+    def javadoc_link(
+        clazz: str = None,
+        target: str = None,
+        strip_package: bool = True,
+        strip_clazz: bool = False,
+        strip_params: bool = True,
+        title: str = None
+    ) -> str:
+        name = clazz or "Javadoc"
+        if strip_package:
+            if clazz and clazz.rfind(".") > -1:
+                name = clazz[clazz.rfind(".") + 1 :]
+        if target:
+            # _target = re.sub(r"([^(][^,]*?\.)*?([^)]+)", lambda m: m.group(2), target)
+            _target = target
+
+            if m := re.match(r'^(.+?)\((.*)\)$', _target):
+                if strip_params and m.group(2):
+                    params = m.group(2).split(',')
+                    for i, param in enumerate(params):
+                        dot = param.rfind('.')
+                        if dot >= 0:
+                            params[i] = param[dot+1:].strip()
+                    params = ", ".join(params)
+                    _target = f'{m.group(1)}({params})'
+
+            if strip_clazz:
+                name = _target
+            else:
+                name = f"{name}.{_target}"
+        if title:
+            name = title
+
+        return f"[`{name}`]({javadoc(clazz, target)})"
+
+    @env.macro
+    def jdl(
+        cl: str = None,
+        t: str = None,
+        p: bool = False,
+        c: bool = True,
+        title: str = None
+    ) -> str:
+        return javadoc_link(cl, t, strip_package=not p, strip_clazz=not c, strip_params=True, title=title)
+
+    @env.macro
+    def jdc(
+        cl: str,
+        p: bool = False
+    ) -> str:
+        return javadoc_link(cl, strip_package=not p)
+
+    @env.macro
+    def jdm(
+        cl: str,
+        t: str,
+        p: bool = False,
+        c: bool = False
+    ) -> str:
+        return javadoc_link(cl, t, strip_package=not p, strip_clazz=not c)
+
+    @env.macro
+    def javadoc_signature(
+        clazz: str = None,
+        member: str = None,
+        package: str = None,
+        params: List[str] = list(),
+    ) -> str:
+        sig = clazz or ""
+        if clazz and package:
+            sig = f"{package}.{sig}"
+        if member:
+            sig = f"{sig}#{member}"
+
+        pparams = ",".join(params)
+        sig = f"{sig}({pparams})"
+
+        return sig
+
+    @env.macro
+    def jds(
+        cl: str = None,
+        m: str = None,
+        pkg: str = None,
+        params: List[str] = list(),
+    ) -> str:
+        javadoc_signature(cl, m, pkg, params)
+
+
+# schule/ngb/zm/Zeichenmaschine.html#setCursor(java.awt.Image,int,int)
+# schule/ngb/zm/Zeichenmaschine.html#getLayer(java.lang.Class)
+# schule/ngb/zm/DrawableLayer.html#add(schule.ngb.zm.Drawable...)

docs/quickstart.md

@@ -0,0 +1,606 @@
+# Schnellstart mit der Zeichenmaschine
+
+Um die **Zeichenmaschine** in einem Projekt zu nutzen ist nicht mehr nötig, als
+die [JAR-Datei der aktuellen Version](https://github.com/jneug/zeichenmaschine/release/latest)
+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](installation.md).
+
+## Die Basisklasse
+
+Eine _Zeichenmaschine_ wird immer als Unterklasse von {{ javadoc_link("
+schule.ngb.zm.Zeichenmaschine") }} erstellt.
+
+```java
+public class Shapes extends Zeichenmaschine {
+
+}
+```
+
+Die gezeigte Klasse ist schon eine lauffähige Zeichenmaschine und kann gestartet
+werden.
+
+!!! note "main Methode"
+
+	Bei einigen Entwicklungsumgebungen muss noch eine `main` Methode erstellt 
+	werden, um die Zeichenmaschine zu starten:
+
+	```java
+	public static void main(String[] args) {
+		new Shapes();
+	}
+	```
+
+Es öffnet sich ein Zeichenfenster in einer vordefinierten Größe. Um die
+Abmessungen und den Titel des Fensters zu ändern, legen wir einen Konstruktor
+an.
+
+???+ example "Quelltext"
+
+	```java
+	public class Shapes extends Zeichenmaschine {
+	
+		public Shapes() {
+			super(800, 800, "Shapes");
+		}
+	
+	}
+	```
+
+Starten wir das Projekt, wird eine Zeichenfläche in der Größe 800-mal-800 Pixel
+erstellt und in einem Fenster mit dem Titel „Shapes“ angezeigt.
+
+<figure markdown>
+![Shapes 2](assets/quickstart/shapes_2.png){ width=400 }
+</figure>
+
+### Formen zeichnen
+
+Eine Zeichenmaschine hat verschiedene Möglichkeiten, Inhalte in das
+Zeichenfenster zu zeichnen. Um ein einfaches statisches Bild zu erzeugen,
+überschreiben wir die {{ jdl("schule.ngb.zm.Zeichenmaschine", "draw()",
+c=False) }} Methode.
+
+???+ example "Quelltext"
+
+	```java
+	public class Shapes extends Zeichenmaschine {
+	
+		public Shapes() {
+			super(800, 800, "Shapes");
+		}
+	
+		@Override
+		public void draw() {
+			background.setColor(BLUE);
+	
+			drawing.setFillColor(255, 223, 34);
+			drawing.noStroke();
+			drawing.circle(400, 400, 100);
+		}
+	
+	}
+	```
+
+Wir sehen einen gelben Kreis (ohne Konturlinie) auf einem blauen Hintergrund.
+
+<figure markdown>
+![Shapes 3](assets/quickstart/shapes_3.png){ width=400 }
+</figure>
+
+### Vorbereitung der Zeichenfläche
+
+Im Beispiel oben setzen wir die Hintergrundfarbe auf Blau, die Füllfarbe auf
+Gelb und deaktivieren die Konturlinie. Wenn diese Einstellungen für alle
+Zeichenobjekte gleich bleiben, können wir sie statt in `draw()` auch in die {{
+jdl('Zeichenmaschine', 'setup()', c=False) }} Methode schreiben. Diese bereitet
+die Zeichenfläche vor dem ersten Zeichnen vor.
+
+???+ example "Quelltext"
+
+	```java
+	public class Shapes extends Zeichenmaschine {
+	
+		public Shapes() {
+			super(800, 800, "Shapes");
+		}
+	
+		@Override
+		public void setup() {
+			background.setColor(BLUE);
+	
+			drawing.setFillColor(255, 223, 34);
+			drawing.noStroke();
+		}
+	
+		@Override
+		public void draw() {
+			for( int i = 0; i < 10; i++ ) {
+				drawing.circle(
+					random(0, canvasWidth),
+					random(0, canvasHeight),
+					random(50, 200)
+				);
+			}
+		}
+	
+	}
+	```
+
+Im Beispiel setzen wir nun die Grundeinstellungen in der `setup()` Methode. In
+`draw()` werden zehn gelbe Kreise an Zufallskoordinaten gezeichnet.
+
+<figure markdown>
+![Shapes 4](assets/quickstart/shapes_4.1.png){ width=400 }
+</figure>
+
+!!! tip ""
+
+	Mit {{ jdm("Constants", "canvasWidth") }} und 
+	{{ jdm("Constants", "canvasHeight") }} kannst du in der Zeichenmaschine 
+	auf die aktuelle Größe der Zeichenfläche zugreifen.
+	{{ jdm("Constants", "random(int,int)") }} erzeugt eine Zufallszahl 
+	innerhalb der angegebenen Grenzen.
+
+## Interaktionen mit der Maus: Whack-a-mole
+
+Mit der Zeichenmaschine lassen sich Interaktionen mit der Maus leicht umsetzen.
+Wor wollen das Beispielprogramm zu einem
+[Whac-A-Mole](https://de.wikipedia.org/wiki/Whac-A-Mole) Spiel erweitern.
+
+Auf der Zeichenfläche wird nur noch ein gelber Kreis an einer zufälligen Stelle
+angezeigt. Sobald die Spieler:in auf den Kreis klickt, soll dieser an eine neue
+Position springen.
+
+Damit wir den Kreis an eine neue Position springen lassen können, müssen wir
+zufällige `x`- und `y`-Koordinaten generieren. Dazu erstellen wir zunächst zwei
+_Objektvariablen_ für die Koordinaten, die in der `setup()` Methode mit
+zufälligen Werte initialisiert werden. Diese benutzen wir, um die `draw
+()` Methode anzupassen.
+
+??? example "Quelltext"
+
+	```Java
+	public class Shapes extends Zeichenmaschine {
+
+		private int moleRadius = 20;
+
+		private int moleX;
+
+		private int moleY;
+	
+		public Shapes() {
+			super(800, 800, "Shapes");
+		}
+	
+		@Override
+		public void setup() {
+			background.setColor(BLUE);
+	
+			drawing.setFillColor(255, 223, 34);
+			drawing.noStroke();
+
+			moleX = random(50, canvasWidth - 50);
+			moleY = random(50, canvasHeight - 50);
+		}
+	
+		@Override
+		public void draw() {
+			drawing.clear();
+			drawing.circle(moleX, moleY, moleRadius);
+		}
+	
+	}
+	```
+
+<figure markdown>
+![Shapes 5](assets/quickstart/shapes_5.1.png){ width=600 }
+</figure>
+
+Als Nächstes prüfen wir bei jedem Mausklick, ob die Mauskoordinaten innerhalb
+des gelben Kreises (des Maulwurfs) liegen. Die Mauskoordinaten sind jederzeit
+über die Variablen `mouseX` und `mouseY` abrufbar. Um zu prüfen, ob diese
+Koordinaten innerhalb des Kreises liegen, vergleichen wir den Abstand zwischen
+Kreismittelpunkt `(moleX, moleY)` und den Mauskoordinaten
+`(mouseX, mouseY)` mit dem Radius des Kreises (im Bild grün). Ist die Entfernung
+kleiner als der Radius (blauer Kreis), wurde innerhalb des Kreises geklickt.
+Sonst außerhalb (roter Kreis).
+
+<figure markdown>
+![Kollision Maus mit Kreis](assets/quickstart/CircleMouseCollision.png){ width=400 }
+</figure>
+
+Den Abstand vom Mittelpunkt zur Maus lässt sich mithilfe des Satzes des
+Pythagoras leicht selber berechnen. Die Zeichenmaschine kann uns diese Arbeit
+aber auch abnehmen und stellt eine Methode dafür bereit
+({{ jdm("Constants", "distance(double,double,double,double)") }}).
+
+Um auf einen Mausklick zu reagieren, ergänzen wir die 
+{{ jdm("Zeichenmaschine", "mouseClicked()") }} Methode:
+
+```
+@Override
+public void mouseClicked() {
+	if( distance(moleX, moleY, mouseX, mouseY) < moleRadius ) {
+		moleX = random(50, canvasWidth - 50);
+		moleY = random(50, canvasHeight - 50);
+		redraw();
+	}
+}
+```
+
+??? example "Quelltext"
+
+	```Java
+	public class Shapes extends Zeichenmaschine {
+
+		private int moleRadius = 20;
+
+		private int moleX;
+
+		private int moleY;
+	
+		public Shapes() {
+			super(800, 800, "Shapes");
+		}
+	
+		@Override
+		public void setup() {
+			background.setColor(BLUE);
+	
+			drawing.setFillColor(255, 223, 34);
+			drawing.noStroke();
+
+			moleX = random(50, canvasWidth - 50);
+			moleY = random(50, canvasHeight - 50);
+		}
+	
+		@Override
+		public void draw() {
+			drawing.clear();
+			drawing.circle(moleX, moleY, moleRadius);
+		}
+
+		@Override
+		public void mouseClicked() {
+			if( distance(moleX, moleY, mouseX, mouseY) < moleRadius ) {
+				moleX = random(50, canvasWidth - 50);
+				moleY = random(50, canvasHeight - 50);
+				redraw();
+			}
+		}
+	
+	}
+	```
+
+!!! warning ""
+
+	Der Aufruf von {{ jdm("Zeichenmaschine", "redraw()") }} zeichnet 
+	die Zeichenfläche neu, indem die `draw()` Methode erneut aufgerufen wird.
+	Du solltest `draw()` niemals direkt aufrufen.
+
+Nun springt der Kreis an eine andere Stelle, wenn er direkt mit der Maus
+angeklickt wird.
+
+<figure markdown>
+![Whack-a-mole](assets/quickstart/shapes_5.3.gif){ width=400 }
+</figure>
+
+## Ein paar Details zur Zeichenmaschine
+
+Die _Zeichenmaschine_ wurde stark von der kreativen Programmierumgebung
+[Processing](https://processing.org) inspiriert. Wenn Du Processing schon
+kennst, dann werden Dir einige der Konzepte der _Zeichenmaschine_ schon bekannt
+vorkommen.
+
+### Farben
+
+Farben können auf verschiedene Weisen angegeben werden. Unser Beispiel nutzt
+bisher zwei Arten:
+
+1. Die einfachste Möglichkeit sind die _Farbkonstanten_
+   wie {{ jdm('Constants', 'BLUE') }} oder {{ jdm('Constants', 'RED') }}. Im 
+   Beispiel setzen wir den Hintergrund auf die Farbe `BLUE`.
+2. Farben werden häufig im RGB-Farbraum definiert. Dazu wird jeweils der Rot-,
+   Grün- und Blauanteil der Farbe als Wert zwischen 0 und 255 angegeben. Im
+   Beispiel setzen wir die Farbe der Kreise auf `255, 223, 34`, also viel Rot
+   und Grün und nur ein wenig Blau.
+
+### Ebenen
+
+Die Zeichenfläche besteht aus einzelnen {{ jdl("Layer", title="Ebenen") }}, die
+auf übereinander liegen. Bis auf die unterste Ebene sind die Ebenen zunächst
+durchsichtig, wodurch die Zeichnungen unterer Ebenen durchscheinen.
+
+<figure markdown>
+![Whack-a-mole](assets/quickstart/Layers.png){ width=600 }
+</figure>
+
+Eine _Zeichenmaschine_ besitzt zu Beginn drei Ebenen:
+
+1. Die unterste Ebene ist ein {{ jdc("layers.ColorLayer") }}, die nur aus einer
+   Farbe (oder einem Farbverlauf) besteht und keine durchsichtigen Bereiche
+   besitzt. Im Beispiel setzen wir diese Ebene auf die Farbe `BLUE`.
+2. Die nächste Ebene ist ein {{ jdc("layers.DrawingLayer") }}, auf die wir
+   unsere Formen zeichnen können. Die Ebene ist zunächst komplett durchsichtig.
+3. Die oberste Ebene ist ein {{ jdc("layers.ShapesLayer") }}, die zur
+   Darstellung von Form-Objekten der Klasse {{ jdc("shapes.Shape") }} genutzt
+   werden kann.
+
+Du kannst einer Zeichenfläche aber auch beliebige neue oder selbst programmierte
+Ebenen hinzufügen.
+
+### Ablauf
+
+Die _Zeichenmaschine_ ruft nach dem Start die Methoden in einem festen Ablauf
+auf.
+
+<figure markdown>
+![Whack-a-mole](assets/quickstart/AblaufMoleStatic.png){ width=500 }
+</figure>
+
+Erstellst Du eine _Zeichenmaschine_ (beziehungsweise ein Objekt einer
+Unterklasse), dann wird zuerst die {{ jdm('Zeichenmaschine', 'setup()') }} 
+Methode ausgeführt. Danach folgt einmalig die 
+{{ jdm('Zeichenmaschine', 'draw()') }} Methode und dann endet das Hauptprogramm.
+
+Die Eingaben der Maus werden in einem parallelen Ablauf (einem _Thread_)
+abgefangen und daraufhin die {{ jdm('Zeichenmaschine', 'mouseClicked()') }} 
+Methode aufgerufen. In unserem Programm prüfen wir, ob mit der Maus
+innerhalb des Kreises geklickt wurde und rufen dann 
+{{ jdm('Zeichenmaschine', 'redraw()') }} auf, woraufhin ein weiteres Mal 
+`draw()` ausgeführt wird.
+
+In _Processing_ wird dies der "statische" Modus genannt, weil das Programm nur
+einmal abläuft und dann stoppt. "Statisch" trifft es nicht ganz, da das Programm
+ja zum Beispiel durch Mauseingaben auch verändert werden kann. Wichtig ist aber,
+dass mit `redraw()` die Zeichenfläche manuell neu gezeichnet werden muss, damit
+sich der Inhalt ändert.
+
+## Dynamische Programme
+
+Wir wollen unser kleines Spiel dynamischer machen, indem die Kreise nur drei
+Sekunden angezeigt werden und dann von selbst an einen neuen Ort springen.
+Schafft man es, den Kreis in dieser Zeit anzuklicken, bekommt man einen Punkt.
+
+Als zusätzliche Herausforderung lassen wir jeden Kreis in den drei Sekunden
+immer kleiner werden.
+
+### Die Update-Draw-Schleifen
+
+![Whack-a-mole](assets/quickstart/AblaufMoleActive.png){ width=200 align=right }
+
+Bisher hat die _Zeichenmaschine_ einmalig `draw()` aufgerufen und dann nur noch
+auf Benutzereingaben mit der Maus reagiert. Nun wollen wir das gezeichnete Bild
+aber laufend anpassen. Der Kreis soll schrumpfen und nach 3 Sekunden
+verschwinden.
+
+Dazu ergänzen wir ein {{ jdl('Zeichenmaschine', 'update(double)', c=False) }}
+Methode in unserem Programm. Nun schaltet die _Zeichenmaschine_ in einen
+dynamischen Modus und startet die _Update-Draw-Schleife_. Das beduetet, nach
+Aufruf von `setup()` wird fortlaufend immer wieder zuerst `update()` und dann
+`draw()` aufgerufen.
+
+Jeder Aufruf der `draw()` Methode zeichnet nun die Zeichenfläche neu. Jedes
+Bild, das gezeichnet wird (auch, wenn es genauso aussieht, wie das davor), nennt
+man ein _Frame_. Von Videospielen kennst Du vielleicht schon den Begriff "
+_Frames per second_" (Fps, dt. Bilder pro Sekunde). Er bedeutet, wie oft das
+Spiel neue Frames zeichnet, oder in der _Zeichenmaschine_, wie oft `draw()` pro
+Sekunde aufgerufen wird. Normalerweise passiert dies genau 60-mal pro Sekunde.
+
+### Lebenszeit eines Kreises
+
+Jeder Kreis soll drei Sekunden zu sehen sein. Daher fügen wir eine neue
+Objektvariable namens `moleTime` ein, die zunächst auf drei steht. Da wir auch
+Bruchteile von Skeunden abziehen wollen, wählen wir als Datentyp `double`:
+
+```Java
+private double moleTime=3.0;
+```
+
+Der Parameter `delta`, der `update()` Methode ist der Zeitraum in Sekunden, seit
+dem letzten Frame. Subtrahieren wir diesen Wert bei jedem Frame von `moleTime`,
+wird der Wert immer kleiner. Dann müssen wir nur noch prüfen, ob er kleiner Null
+ist und in dem Fall den Kreis auf eine neue Position springen lassen.
+
+Die Größe des Kreises passen wir so an, dass der Anteil der vergangenen Zeit die
+Größe des Kreises bestimmt:
+
+```Java
+drawing.circle(moleX,moleY,moleRadius*(moleTime/3.0));
+```
+
+??? example "Quelltext"
+
+	```Java
+	import schule.ngb.zm.Zeichenmaschine;
+	
+	public class Shapes extends Zeichenmaschine {
+	
+		private int moleRadius = 20;
+	
+		private int moleX;
+	
+		private int moleY;
+	
+		private double moleTime;
+	
+		public Shapes() {
+			super(800, 800, "Shapes");
+		}
+	
+		@Override
+		public void setup() {
+			background.setColor(BLUE);
+	
+			drawing.setFillColor(255, 223, 34);
+			drawing.noStroke();
+	
+			randomizeMole();
+		}
+	
+		private void randomizeMole() {
+			moleX = random(moleRadius*2, canvasWidth - moleRadius*2);
+			moleY = random(moleRadius*2, canvasHeight - moleRadius*2);
+			moleTime = 3.0;
+		}
+	
+		@Override
+		public void update( double delta ) {
+			moleTime -= delta;
+	
+			if( moleTime <= 0 ) {
+				randomizeMole();
+			}
+		}
+	
+		@Override
+		public void draw() {
+			drawing.clear();
+			drawing.circle(moleX, moleY, moleRadius * (moleTime / 3.0));
+		}
+	
+		@Override
+		public void mouseClicked() {
+			if( distance(moleX, moleY, mouseX, mouseY) < moleRadius ) {
+				randomizeMole();
+				redraw();
+			}
+		}
+	
+		public static void main( String[] args ) {
+			new Shapes();
+		}
+	
+	}
+	```
+
+<figure markdown>
+![Whack-a-mole](assets/quickstart/shapes_6.1.gif){ width=400 }
+</figure>
+
+!!! tip ""
+
+	Der Maulwurf muss mittlerweile an drei verschiedenen Stellen im Programm
+	auf eine zufällige Position gesetzt werden (am Anfang, wenn er angeklickt 
+	wurde und wenn die drei Sekunden abgelaufen sind). Daher wurde das Versetzen
+	in eine eigene Methode `randomizeMole()` ausgelagert. 
+
+### Punktezähler
+
+Zum Schluss wollen wir noch bei jedem Treffer mit der Maus die Punkte Zählen und
+als Text auf die Zeichenfläche schreiben.
+
+Dazu ergänzen wir eine weitere Objektvariable `score`, die in `mouseClicked()`
+erhöht wird, falls der Kreis getroffen wurde.
+
+Um den Punktestand anzuzeigen ergänzen wir in `draw()` einen Aufruf von 
+{{ jdl('layers.DrawingLayer', 'text(java.lang.String,double,double,schule.ngb.zm.Options.Direction)') }} 
+mit dem  Inhalt von `score` und den Koordinaten, an denen der Text gezeigt 
+werden soll.
+Die Zeichenebene zeichnet im Moment alle Formen und Text ausgehend vom Zentrum
+der Form. Damit der Text 10 Pixel vom Rand entfernt links oben angezeigt wird,
+können wir der Text Methode (und allen anderen, die etwas zeichnen) eine {{
+jdl('Options.Direction', title='Richtung') }} übergeben, die festlegt, von
+welchem Ausgangspunkt (oder _Ankerpunkt_) die Form gezeichnet werden soll.
+
+```Java
+drawing.setFillColor(BLACK);
+	drawing.text("Punkte: "+score,10,10,NORTHWEST);
+```
+
+<figure markdown>
+![Whack-a-mole](assets/quickstart/shapes_6.2.png){ width=400 }
+</figure>
+
+??? example "Quelltext"
+
+	```Java
+	import schule.ngb.zm.Zeichenmaschine;
+	
+	public class Shapes extends Zeichenmaschine {
+	
+		private int moleRadius = 20;
+	
+		private int moleX;
+	
+		private int moleY;
+	
+		private double moleTime;
+	
+		private int score = 0;
+	
+		public Shapes() {
+			super(800, 800, "Shapes");
+		}
+	
+		@Override
+		public void setup() {
+			background.setColor(BLUE);
+	
+			drawing.noStroke();
+			drawing.setFontSize(24);
+	
+			randomizeMole();
+		}
+	
+		private void randomizeMole() {
+			moleX = random(moleRadius*2, canvasWidth - moleRadius*2);
+			moleY = random(moleRadius*2, canvasHeight - moleRadius*2);
+			moleTime = 3.0;
+		}
+	
+		@Override
+		public void update( double delta ) {
+			moleTime -= delta;
+	
+			if( moleTime <= 0 ) {
+				randomizeMole();
+			}
+		}
+	
+		@Override
+		public void draw() {
+			drawing.clear();
+	
+			drawing.setFillColor(255, 223, 34);
+			drawing.circle(moleX, moleY, moleRadius * (moleTime / 3.0));
+	
+			drawing.setFillColor(BLACK);
+			drawing.text("Punkte: " + score, 10, 10, NORTHWEST);
+		}
+	
+		@Override
+		public void mouseClicked() {
+			if( distance(moleX, moleY, mouseX, mouseY) < moleRadius ) {
+				score += 1;
+				randomizeMole();
+				redraw();
+			}
+		}
+	
+		public static void main( String[] args ) {
+			new Shapes();
+		}
+	
+	}
+	```
+
+## Wie es weitergehen kann
+
+In diesem Schnellstart-Tutorial hast Du die Grundlagen der _Zeichenmaschine_
+gelernt. Um weiterzumachen, kannst Du versuchen, das Whack-a-mole Spiel um diese
+Funktionen zu erweitern:
+
+- Mehrere "Maulwürfe" gleichzeitig.
+- Unterschiedliche Zeiten pro Maulwurf.
+
+Wenn Du mehr über die Möglichkeiten lernen möchtest, die Dir die
+_Zeichenmaschine_ bereitstellt, kannst Du Dir die weiteren Tutorials in dieser
+Dokumentation ansehen. Ein guter Startpunkt ist das
+[Aquarium](tutorials/aquarium/aquarium1.md).
+
+Viele verschiedene Beispiele, ohne detailliertes Tutorial, findest Du in der
+Kategorie Beispiele und auf GitHub im Repository
+[jneug/zeichenmaschine-examples](https://github.com/jneug/zeichenmaschine-examples).

docs/tutorials/aquarium/aquarium1.md

@@ -0,0 +1,19 @@
+# Tutorial: Aquarium
+
+In diesem Tutorial wollen wir mithilfe der _Zeichenmaschine_ ein (bonbonbuntes) 
+interaktives Aquarium entwickeln. Dabei werden wir in verschiedenen Ausbaustufen 
+zunächst das System Modellieren und dann implementieren.
+
+!!! info "Mein bonbonbuntes Aquarium"
+
+	Das Projekt [Mein bonbonbuntes Aquarium](http://blog.schockwellenreiter.de/2021/02/2021021201.html) 
+	stammt ursprünglich aus dem Blog [Schockwellenreiter](http://blog.schockwellenreiter.de) 
+	von [Jörg Kantel](http://cognitiones.kantel-chaos-team.de/cv.html).
+
+Das Endprodukt soll folgendes umfassen:
+
+- Darstellung eines hübschen Aquariums mit Fischen, die hin und her schwimmen.
+	- Zur Darstellung wollen wir wie im Original die Sprites aus dem [Fish Pack von Kenny.nl](https://www.kenney.nl/assets/fish-pack) nutzen.
+- Das Aquarium soll durch passende Geräusche untermalt werden.
+- Bei einem Klick in das Aquarium soll ein zufälliger Fisch erscheinen.
+- Bei einem Druck auf die Leertaste soll ein Hai durch das Aquarium schwimmen und alle Fische auf seinem Weg auffressen. 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

mkdocs.yml

@@ -0,0 +1,83 @@
+site_name: Zeichenmaschine.xyz
+site_description: Eine kleine Java-Bibliothek für grafische Programmierung im Informatikunterricht.
+site_author: J. Neugebauer
+repo_url: https://github.com/jneug/zeichenmaschine
+repo_name: jneug/zeichenmaschine
+
+site_dir: build/docs/site
+
+theme:
+    name: material
+    custom_dir: docs/home_override/
+    language: de
+    logo: assets/icon_64.png
+    favicon: assets/icon_32.png
+    features:
+        - content.code.annotate
+        - navigation.top
+        - navigation.tracking
+        - search.suggest
+    font: false
+    palette:
+        - media: "(prefers-color-scheme: light)"
+          scheme: default
+          primary: blue
+          accent: deep orange
+          toggle:
+              icon: material/weather-sunny
+              name: Dunkles Design aktivieren
+        - media: "(prefers-color-scheme: dark)"
+          scheme: slate
+          primary: blue
+          accent: deep orange
+          toggle:
+              icon: material/weather-night
+              name: Helles Design aktivieren
+extra_css:
+    - assets/zmstyles.css
+
+nav:
+    -   Einführung: einfuehrung.md
+    -   Schnellstart: schnellstart.md
+    -   Installation: installation.md
+    -   Tutorials:
+            -   Aquarium: tutorials/aquarium/aquarium1.md
+    -   Beispiele:
+            -   Mondrian: beispiele/mondrian.md
+
+markdown_extensions:
+    - admonition
+    - attr_list
+    - def_list
+    - footnotes
+    - md_in_html
+    - toc:
+          permalink: true
+    - pymdownx.magiclink
+    - pymdownx.betterem:
+          smart_enable: all
+    - pymdownx.caret
+    - pymdownx.smartsymbols
+    - pymdownx.emoji:
+          emoji_index: !!python/name:materialx.emoji.twemoji
+          emoji_generator: !!python/name:materialx.emoji.to_svg
+    - pymdownx.highlight:
+          anchor_linenums: true
+    - pymdownx.inlinehilite
+    - pymdownx.snippets
+    - pymdownx.details
+    - pymdownx.superfences:
+          custom_fences:
+              - name: mermaid
+                class: mermaid
+                format: !!python/name:pymdownx.superfences.fence_code_format
+plugins:
+    - search:
+          lang: de
+          separator: '[\s\-\.]'
+    - macros:
+        module_name: docs/macros
+
+extra:
+    javadoc_url: https://zeichenmaschine.xyz/docs/
+    javadoc_default_package: schule.ngb.zm

requirements.txt

@@ -0,0 +1,25 @@
+certifi==2022.9.24
+charset-normalizer==2.1.1
+click==8.1.3
+ghp-import==2.1.0
+idna==3.4
+Jinja2==3.1.2
+Markdown==3.3.7
+MarkupSafe==2.1.1
+mergedeep==1.3.4
+mkdocs==1.4.1
+mkdocs-macros-plugin==0.7.0
+mkdocs-material==8.5.6
+mkdocs-material-extensions==1.0.3
+packaging==21.3
+Pygments==2.13.0
+pymdown-extensions==9.6
+pyparsing==3.0.9
+python-dateutil==2.8.2
+PyYAML==6.0
+pyyaml_env_tag==0.1
+requests==2.28.1
+six==1.16.0
+termcolor==2.0.1
+urllib3==1.26.12
+watchdog==2.1.9

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

@@ -0,0 +1,194 @@
+package schule.ngb.zm;
+
+import java.awt.Graphics2D;
+import java.awt.MultipleGradientPaint;
+import java.awt.Paint;
+import java.awt.Stroke;
+
+/**
+ * Basisimplementierung der {@link Strokeable} und {@link Fillable} APIs.
+ *
+ * Die Klasse bietet eine Grundlage zur Implementierung eigener Zeichenobjekte,
+ * die eine Füllung und eine Konturlinie haben können.
+ */
+public abstract class BasicDrawable extends Constants implements Strokeable, Fillable {
+
+	/**
+	 * Ob das Objekt gezeichnet werden soll.
+	 */
+	protected boolean visible = true;
+
+	/**
+	 * Aktuelle Farbe der Konturlinie oder {@code null}, wenn das Objekt ohne
+	 * Kontur dargestellt werden soll.
+	 */
+	protected schule.ngb.zm.Color strokeColor = DEFAULT_STROKECOLOR;
+
+	/**
+	 * Die Dicke der Konturlinie. Wird nicht kleiner als 0.
+	 */
+	protected double strokeWeight = DEFAULT_STROKEWEIGHT;
+
+	/**
+	 * Die Art der Konturlinie.
+	 */
+	protected Options.StrokeType strokeType = SOLID;
+
+	/**
+	 * Cache für den aktuellen {@code Stroke} der Kontur. Wird nach Änderung
+	 * einer der Kontureigenschaften auf {@code null} gesetzt und beim nächsten
+	 * Zeichnen neu erstellt.
+	 */
+	protected Stroke stroke = null;
+
+	/**
+	 * Die aktuelle Füllfarbe der Form oder {@code null}, wenn das Objekt nicht
+	 * gefüllt werden soll.
+	 */
+	protected Color fillColor = DEFAULT_FILLCOLOR;
+
+	/**
+	 * Der aktuelle Farbverlauf des Objektes oder {@code null}, wenn es keinen
+	 * Farbverlauf besitzt.
+	 */
+	protected MultipleGradientPaint fill = null;
+
+
+	// Implementierung Drawable Interface
+
+	/**
+	 * Ob das Objekt angezeigt bzw. gezeichnet werden soll.
+	 *
+	 * @return {@code true}, wenn das Objekt angezeigt werden soll,
+	 *    {@code false} sonst.
+	 */
+	public boolean isVisible() {
+		return visible;
+	}
+
+	/**
+	 * Versteckt das Objekt.
+	 */
+	public void hide() {
+		visible = false;
+	}
+
+	/**
+	 * Zeigt das Objekt an.
+	 */
+	public void show() {
+		visible = true;
+	}
+
+	/**
+	 * Versteckt da Objekt, wenn es derzeit angezeigt wird und zeigt es
+	 * andernfalls an.
+	 */
+	public void toggle() {
+		visible = !visible;
+	}
+
+	public abstract void draw( Graphics2D graphics );
+
+
+	// Implementierung Fillable Interface
+
+	@Override
+	public void setFill( Paint fill ) {
+		if( fill == null ) {
+			this.fill = null;
+		} else if( fill instanceof Color ) {
+			this.fillColor = ((Color) fill);
+			this.fill = null;
+		} else if( fill instanceof MultipleGradientPaint ) {
+			this.fillColor = null;
+			this.fill = (MultipleGradientPaint) fill;
+		}
+	}
+
+	@Override
+	public Paint getFill() {
+		if( fill != null ) {
+			return fill;
+		} else if( fillColor != null && fillColor.getAlpha() > 0 ) {
+			return fillColor;
+		} else {
+			return null;
+		}
+	}
+
+	@Override
+	public boolean hasFillColor() {
+		return fillColor != null;
+	}
+
+	@Override
+	public boolean hasGradient() {
+		return fill != null;
+	}
+
+	@Override
+	public Color getFillColor() {
+		return fillColor;
+	}
+
+	@Override
+	public void setFillColor( Color color ) {
+		fillColor = color;
+		fill = null;
+	}
+
+	@Override
+	public MultipleGradientPaint getGradient() {
+		return fill;
+	}
+
+
+	// Implementierung Strokeable Interface
+
+	@Override
+	public void setStroke( Stroke stroke ) {
+		this.stroke = stroke;
+	}
+
+	@Override
+	public Stroke getStroke() {
+		if( stroke == null ) {
+			stroke = Strokeable.createStroke(strokeType, strokeWeight);
+		}
+		return stroke;
+	}
+
+	@Override
+	public Color getStrokeColor() {
+		return strokeColor;
+	}
+
+	@Override
+	public void setStrokeColor( Color color ) {
+		strokeColor = color;
+	}
+
+	@Override
+	public double getStrokeWeight() {
+		return strokeWeight;
+	}
+
+	@Override
+	public void setStrokeWeight( double weight ) {
+		strokeWeight = weight;
+		this.stroke = null;
+	}
+
+	@Override
+	public Options.StrokeType getStrokeType() {
+		return strokeType;
+	}
+
+	@Override
+	public void setStrokeType( Options.StrokeType type ) {
+		strokeType = type;
+		this.stroke = null;
+	}
+
+}

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

@@ -4,6 +4,10 @@ import java.awt.*;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Rectangle2D;
 import java.awt.image.ColorModel;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
 
 /**
  * Repräsentiert eine Farbe in der Zeichenmaschine.
@@ -14,6 +18,7 @@ import java.awt.image.ColorModel;
  * Eine Farbe hat außerdem einen Transparenzwert zwischen 0 (unsichtbar) und 255
  * (deckend).
  */
+@SuppressWarnings( "unused" )
 public class Color implements Paint {
 
 
@@ -47,38 +52,67 @@ public class Color implements Paint {
 	 * Die Farbe Zeichenmaschinen-Rot.
 	 */
 	public static final Color RED = new Color(240, 80, 37);
+
+	/**
+	 * Die Farbe Rot.
+	 */
+	public static final Color PURE_RED = new Color(255, 0, 0);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Grün.
 	 */
 	public static final Color GREEN = new Color(98, 199, 119);
+
+	/**
+	 * Die Farbe Grün.
+	 */
+	public static final Color PURE_GREEN = new Color(0, 255, 0);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Blau.
 	 */
-	public static final Color BLUE = new Color(49, 197, 244);
+	public static final Color BLUE = new Color(43, 128, 243); // 49, 197, 244
+
+	/**
+	 * Die Farbe Blau.
+	 */
+	public static final Color PURE_BLUE = new Color(0, 0, 255);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Gelb.
 	 */
 	public static final Color YELLOW = new Color(248, 239, 34);
+
+	/**
+	 * Die Farbe Gelb.
+	 */
+	public static final Color PURE_YELLOW = new Color(255, 255, 0);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Orange.
 	 */
 	public static final Color ORANGE = new Color(248, 158, 80);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Türkis.
 	 */
 	public static final Color CYAN = new Color(java.awt.Color.CYAN);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Magenta.
 	 */
 	public static final Color MAGENTA = new Color(java.awt.Color.MAGENTA);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Rosa.
 	 */
 	public static final Color PINK = new Color(240, 99, 164);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Lila.
 	 */
 	public static final Color PURPLE = new Color(101, 0, 191);
+
 	/**
 	 * Die Farbe Zeichenmaschinen-Braun.
 	 */
@@ -88,6 +122,7 @@ public class Color implements Paint {
 	 * Die Farbe Helmholtz-Grün.
 	 */
 	public static final Color HGGREEN = new Color(0, 165, 81);
+
 	/**
 	 * Die Farbe Helmholtz-Rot.
 	 */
@@ -107,7 +142,7 @@ public class Color implements Paint {
 	}
 
 	/**
-	 * Erstellt eine graue Farbe entsprechend des Grauwertes <var>gray</var>.
+	 * Erstellt eine graue Farbe entsprechend dem Grauwert {@code gray}.
 	 *
 	 * @param gray Ein Grauwert zwischen 0 und 255.
 	 */
@@ -116,8 +151,8 @@ public class Color implements Paint {
 	}
 
 	/**
-	 * Erstellt eine graue Farbe entsprechend des Grauwertes <var>gray</var> und
-	 * des Transparentwertes <var>alpha</var>.
+	 * Erstellt eine graue Farbe entsprechend dem Grauwert {@code gray} und dem
+	 * Transparenzwert {@code alpha}.
 	 *
 	 * @param gray Ein Grauwert zwischen 0 und 255.
 	 */
@@ -126,9 +161,9 @@ public class Color implements Paint {
 	}
 
 	/**
-	 * Erstellt eine Farbe. Die Parameter <var>red</var>, <var>green</var> und
-	 * <var>blue</var> geben die Rot-, Grün- und Blauanteile der Farbe. Die
-	 * Werte liegen zwischen 0 und 255.
+	 * Erstellt eine Farbe. Die Parameter {@code red}, {@code green} und
+	 * {@code blue} geben die Rot-, Grün- und Blauanteile der Farbe. Die Werte
+	 * liegen zwischen 0 und 255.
 	 *
 	 * @param red Rotwert zwischen 0 und 255.
 	 * @param green Grünwert zwischen 0 und 255.
@@ -139,11 +174,11 @@ public class Color implements Paint {
 	}
 
 	/**
-	 * Erstellt eine Farbe. Die Parameter <var>red</var>, <var>green</var> und
-	 * <var>blue</var> geben die Rot-, Grün- und Blauanteile der Farbe. Die
-	 * Werte liegen zwischen 0 und 255.
-	 * <var>alpha</var> gibt den den Transparentwert an (auch zwischen
-	 * 0 und 255), wobei 0 komplett durchsichtig ist und 255 komplett deckend.
+	 * Erstellt eine Farbe. Die Parameter {@code red}, {@code green} und
+	 * {@code blue} geben die Rot-, Grün- und Blauanteile der Farbe. Die Werte
+	 * liegen zwischen 0 und 255. {@code alpha} gibt den den Transparentwert an
+	 * (auch zwischen 0 und 255), wobei 0 komplett durchsichtig ist und 255
+	 * komplett deckend.
 	 *
 	 * @param red Rotwert zwischen 0 und 255.
 	 * @param green Grünwert zwischen 0 und 255.
@@ -151,24 +186,24 @@ public class Color implements Paint {
 	 * @param alpha Transparentwert zwischen 0 und 255.
 	 */
 	public Color( int red, int green, int blue, int alpha ) {
-		rgba = ((alpha & 0xFF) << 24) | ((red & 0xFF) << 16) | ((green & 0xFF) << 8) | ((blue & 0xFF) << 0);
+		rgba = ((alpha & 0xFF) << 24) | ((red & 0xFF) << 16) | ((green & 0xFF) << 8) | (blue & 0xFF);
 	}
 
 	/**
-	 * Erstellt eine Farbe als Kopie von <var>color</var>.
+	 * Erstellt eine Farbe als Kopie von {@code color}.
 	 *
-	 * @param color
+	 * @param color Eine Farbe.
 	 */
 	public Color( Color color ) {
-		this(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());
+		this(color.getRGBA(), true);
 	}
 
 	/**
-	 * Erstellt eine Farbe als Kopie von <var>color</var> und ersetzt den
-	 * Transparentwert durch <var>alpha</var>.
+	 * Erstellt eine Farbe als Kopie von {@code color} und ersetzt den
+	 * Transparentwert durch {@code alpha}.
 	 *
-	 * @param color
-	 * @param alpha
+	 * @param color Eine Farbe.
+	 * @param alpha Der neue Transparenzwert.
 	 */
 	public Color( Color color, int alpha ) {
 		this(color.getRed(), color.getGreen(), color.getBlue(), alpha);
@@ -203,46 +238,97 @@ public class Color implements Paint {
 
 	/**
 	 * Erzeugt eine Farbe aus einem kodierten RGBA Integer-Wert.
+	 * <p>
+	 * Der 32-bit Integer enthält (von rechts) in Bit 1 bis 8 den Rotwert, in
+	 * Bit 9 bis 16 Grünwert, in Bit 17 bis 24 den Blauwert und in Bit 25 bis 32
+	 * den Transparenzwert der Farbe.
 	 *
-	 * @param rgba
-	 * @return
+	 * @param rgba Eine RGBA-Farbe.
+	 * @return Ein Farbobjekt.
 	 */
 	public static Color getRGBColor( int rgba ) {
-		Color c = new Color(rgba, true);
-		return c;
+		return new Color(rgba, true);
 	}
 
+	/**
+	 * Erzeugt eine Farbe aus Werten im
+	 * <a href="https://de.wikipedia.org/wiki/HSV-Farbraum">HSB-Farbraum</a>.
+	 * <p>
+	 * {code h} beschreibt den Farbwert (engl. <em>hue</em>), {@code s} die
+	 * Sättigung (engl. <em>saturation</em>) und {@code b} die absolute
+	 * Helligkeit (engl. <em>brightness</em>) der Farbe. Alle Werte werden
+	 * zwischen 0.0 und 1.0 angegeben.
+	 *
+	 * @param h Der Farbwert.
+	 * @param s Die Sättigung.
+	 * @param b Die absolute Helligkeit.
+	 * @return Ein Farbobjekt.
+	 * @see java.awt.Color#getHSBColor(float, float, float)
+	 */
 	public static Color getHSBColor( double h, double s, double b ) {
 		return new Color(java.awt.Color.getHSBColor((float) h, (float) s, (float) b));
 	}
 
+	/**
+	 * Erzeugt eine Farbe aus Werten im
+	 * <a href="https://de.wikipedia.org/wiki/HSV-Farbraum">HSL-Farbraum</a>.
+	 * <p>
+	 * {code h} beschreibt den Farbwert (engl. <em>hue</em>), {@code s} die
+	 * Sättigung (engl. <em>saturation</em>) und {@code l} die relative
+	 * Helligkeit (engl. <em>lightness</em>) der Farbe. Alle Werte werden
+	 * zwischen 0.0 und 1.0 angegeben.
+	 *
+	 * @param h Der Farbwert.
+	 * @param s Die Sättigung.
+	 * @param l Die relative Helligkeit.
+	 * @return Ein Farbobjekt.
+	 */
 	public static Color getHSLColor( double h, double s, double l ) {
 		int rgb = Color.HSLtoRGB(new float[]{(float) h, (float) s, (float) l});
 		return Color.getRGBColor(rgb);
 	}
 
-	public static Color parseString( String pColor ) {
-		pColor = pColor.toLowerCase().strip();
-		if( pColor.contains("red") || pColor.contains("rot") ) {
-			return Color.RED.copy();
-		} else if( pColor.contains("blue") || pColor.contains("blau") ) {
-			return Color.BLUE.copy();
-		} else if( pColor.contains("green") || pColor.contains("grün") || pColor.contains("gruen") ) {
-			return Color.GREEN.copy();
-		} else if( pColor.contains("yellow") || pColor.contains("gelb") ) {
-			return Color.YELLOW.copy();
-		} else {
-			return new Color();
+	/**
+	 * Erstellt aus einem Farbnamen ein Farbobjekt.
+	 * <p>
+	 * Die gültigen Farbnamen können unter <a
+	 * href="https://htmlcolors.com/color-names">https://htmlcolors.com/color-names</a>
+	 * nachgeschlagen werden.
+	 *
+	 * @param color Der Name einer Farbe.
+	 * @return Ein Farbobjekt.
+	 */
+	public static Color parseString( String color ) {
+		color = color.toLowerCase().strip();
+
+		// Parse colornames file and return first match
+		try( InputStream in = Color.class.getResourceAsStream("colornames.csv"); BufferedReader reader = new BufferedReader(new InputStreamReader(in)) ) {
+			String line;
+			while( (line = reader.readLine()) != null ) {
+				String[] parts = line.split(",");
+				if( parts.length == 2 ) {
+					if( parts[0].equals(color) ) {
+						return Color.parseHexcode(parts[1]);
 					}
 				}
+			}
+		} catch( IOException ex ) {
+			// LOG?
+		}
+		return new Color();
+	}
 
 	/**
-	 * Erzeugt eine Farbe aus einem hexadezimalen Code. Der Hexcode kann sechs-
-	 * oder achtstellig sein (wenn ein Transparentwert vorhanden ist). Dem Code
-	 * kann ein {@code #} Zeichen vorangestellt sein.
+	 * Erzeugt eine Farbe aus einem hexadezimalen Code. Der Hexcode kann drei-,
+	 * sechs- oder achtstellig sein (wenn ein Transparentwert vorhanden ist).
+	 * Dem Code kann ein {@code #} Zeichen vorangestellt sein, muss es aber
+	 * nicht.
+	 * <p>
+	 * Bei einem dreistelligen Code wird jedes zeichen doppelt interpretiert.
+	 * Das beduetet {@code #ABC} ist gleichbedeutend mit {@code #AABBCC}.
 	 *
-	 * @param hexcode
-	 * @return
+	 * @param hexcode Eine Farbe als Hexcode.
+	 * @return Ein Farbobjekt.
 	 */
 	public static Color parseHexcode( String hexcode ) {
 		if( hexcode.startsWith("#") ) {
@@ -259,8 +345,6 @@ public class Color implements Paint {
 		} else if( hexcode.length() == 8 ) {
 			alpha = Integer.valueOf(hexcode.substring(6, 8), 16);
 			hexcode = hexcode.substring(0, 6);
-		} else {
-			hexcode = hexcode;
 		}
 
 		return Color.getRGBColor((alpha << 24) | Integer.valueOf(hexcode, 16));
@@ -281,7 +365,7 @@ public class Color implements Paint {
 		if( color1 == null && color2 == null ) {
 			throw new IllegalArgumentException("Color.interpolate() needs at least one color to be not null.");
 		}
-		if( t < 0.0 || color2 == null ) {
+		if( (color1 != null && t < 0.0) || color2 == null ) {
 			return color1.copy();
 		}
 		if( t > 1.0 || color1 == null ) {
@@ -307,12 +391,12 @@ public class Color implements Paint {
 		if( c == 0 ) {
 			h_ = 0;
 		} else if( max == r ) {
-			h_ = (float) (g - b) / c;
+			h_ = (g - b) / c;
 			if( h_ < 0 ) h_ += 6.f;
 		} else if( max == g ) {
-			h_ = (float) (b - r) / c + 2.f;
+			h_ = (b - r) / c + 2.f;
 		} else if( max == b ) {
-			h_ = (float) (r - g) / c + 4.f;
+			h_ = (r - g) / c + 4.f;
 		}
 		float h = 60.f * h_;
 
@@ -331,6 +415,14 @@ public class Color implements Paint {
 		return hsl;
 	}
 
+	/**
+	 * Konvertiert die Komponenten einer Farbe aus dem HSL-Farbraum in den
+	 * RGB-Farbraum.
+	 *
+	 * @param hsl Die HSL-Komponenten als float-Array.
+	 * @return Der RGBA-Farbwert.
+	 * @see #HSLtoRGB(float[], int)
+	 */
 	public static int HSLtoRGB( float[] hsl ) {
 		return HSLtoRGB(hsl, 255);
 	}
@@ -339,9 +431,9 @@ public class Color implements Paint {
 	 * Konvertiert eine Farbe mit Komponenten im HSL-Farbraum in den
 	 * RGB-Farbraum.
 	 * <p>
-	 * Die Farbkomponenten werden als Float-Array übergeben. Im Index 0 steht
-	 * der h-Wert im Bereich 0 bis 360, Index 1 und 2 enthalten den s- und
-	 * l-Wert im Bereich von 0 bis 1.
+	 * Die Farbkomponenten werden als float-Array übergeben. Im Index 0 steht
+	 * der H-Wert im Bereich 0 bis 360, Index 1 und 2 enthalten den S- und
+	 * L-Wert im Bereich von 0 bis 1.
 	 *
 	 * @param hsl Die Farbkomponenten im HSL-Farbraum.
 	 * @param alpha Ein Transparenzwert im Bereich 0 bis 255.
@@ -484,16 +576,17 @@ public class Color implements Paint {
 		}
 	}
 
-	@Override
 	/**
 	 * Prüft, ob ein anderes Objekt zu diesem gleich ist.
+	 * <p>
+	 * Die Methode gibt genau dann {@code true} zurück, wenn das andere Objekt
+	 * nicht {@code null} ist, vom Typ {@code Color} ist und es dieselben Rot-,
+	 * Grün-, Blau- und Transparenzwerte hat.
 	 *
-	 * Die Methode gibt genau dann {@code true} zurück, wenn das andere
-	 * Objekt nicht {@code null} ist, vom Typ {@code Color} ist und es
-	 * dieselben Rot-, Grün-, Blau- und Transparenzwerte hat.
 	 * @param obj Das zu vergleichende Objekt.
 	 * @return {@code true}, wenn die Objekte gleich sind, sonst {@code false}.
 	 */
+	@Override
 	public boolean equals( Object obj ) {
 		if( obj == null ) {
 			return false;

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

@@ -1,23 +1,27 @@
 package schule.ngb.zm;
 
 import schule.ngb.zm.anim.Easing;
+import schule.ngb.zm.util.Validator;
 import schule.ngb.zm.util.io.ImageLoader;
 import schule.ngb.zm.util.Noise;
 
 import java.awt.Cursor;
+import java.awt.Font;
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseEvent;
 import java.awt.image.BufferedImage;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.Random;
 import java.util.function.DoubleUnaryOperator;
 
 /**
- * Basisklasse für die meisten Objekte der Zeichemaschine, die von Nutzern
+ * Basisklasse für die meisten Objekte der Zeichenmaschine, die von Nutzern
  * erweitert werden können.
  * <p>
  * Die Konstanten stellen viele Funktionen zur einfachen Programmierung bereit
  * und enthält auch einige dynamische Werte, die von der Zeichenmaschine laufend
- * aktuell gehalten werden (beispielsweise {@link #runtime}.
+ * aktuell gehalten werden (beispielsweise {@link #runtime}).
  * <p>
  * Für die Implementierung eigener Klassen ist es oft hilfreich von
  * {@code Constants} zu erben, um die Methoden und Konstanten einfach im
@@ -64,13 +68,49 @@ public class Constants {
 	/**
 	 * Patchversion der Zeichenmaschine.
 	 */
-	public static final int APP_VERSION_REV = 22;
+	public static final int APP_VERSION_REV = 32;
 
 	/**
 	 * Version der Zeichenmaschine als Text-String.
 	 */
 	public static final String APP_VERSION = APP_VERSION_MAJ + "." + APP_VERSION_MIN + "." + APP_VERSION_REV;
 
+	/**
+	 * Gibt an, ob die Zeichenmaschine unter macOS gestartet wurde.
+	 */
+	public static final boolean MACOS;
+
+	/**
+	 * Gibt an, ob die Zeichenmaschine unter Windows gestartet wurde.
+	 */
+	public static final boolean WINDOWS;
+
+	/**
+	 * Gibt an, ob die Zeichenmaschine unter Linux gestartet wurde.
+	 */
+	public static final boolean LINUX;
+
+	static {
+		final String name = System.getProperty("os.name");
+
+		if( name.contains("Mac") ) {
+			MACOS = true;
+			WINDOWS = false;
+			LINUX = false;
+		} else if( name.contains("Windows") ) {
+			MACOS = false;
+			WINDOWS = true;
+			LINUX = false;
+		} else if( name.equals("Linux") ) {  // true for the ibm vm
+			MACOS = false;
+			WINDOWS = false;
+			LINUX = true;
+		} else {
+			MACOS = false;
+			WINDOWS = false;
+			LINUX = false;
+		}
+	}
 
 	/**
 	 * Standardbreite eines Zeichenfensters.
@@ -405,6 +445,21 @@ public class Constants {
 	 */
 	public static final double TWO_PI = Math.PI * 2.0;
 
+	/**
+	 * Konstante für fette Schrift.
+	 */
+	public static final int BOLD = Font.BOLD;
+
+	/**
+	 * Konstante für kursive Schrift.
+	 */
+	public static final int ITALIC = Font.ITALIC;
+
+	/**
+	 * Konstante für normale Schrift.
+	 */
+	public static final int PLAIN = Font.PLAIN;
+
 	/*
 	 * Globale Variablen, die von allen Klassen genutzt werden dürfen. Änderungen
 	 * wirken sich auf die aktuelle Zeichenmaschine aus und sollten nur von der
@@ -731,6 +786,30 @@ public class Constants {
 
 	// Mathematische Funktionen
 
+	/**
+	 * Berechnet das Minimum aller angegebenen Werte.
+	 *
+	 * <pre><code>
+	 * int minimum = min(1, 5, 3); // 1
+	 * </code></pre>
+	 *
+	 * @param numbers Die Werte, aus denen das Minimum ermittelt werden soll.
+	 * @return Das Minimum der Werte.
+	 * @throws IllegalArgumentException Wenn die Eingabe {@code null} oder leer
+	 *                                  ist.
+	 */
+	public static final int min( int... numbers ) {
+		if( numbers == null || numbers.length == 0 ) {
+			throw new IllegalArgumentException("Array may not be <null> or empty.");
+		}
+
+		int min = numbers[0];
+		for( int i = 1; i < numbers.length; i++ ) {
+			min = Math.min(min, numbers[i]);
+		}
+		return min;
+	}
+
 	/**
 	 * Berechnet das Minimum aller angegebenen Werte.
 	 *
@@ -755,6 +834,30 @@ public class Constants {
 		return min;
 	}
 
+	/**
+	 * Berechnet das Maximum aller angegebenen Werte.
+	 *
+	 * <pre><code>
+	 * double maximum = max(1, 5, 3); // 5
+	 * </code></pre>
+	 *
+	 * @param numbers Die Werte, aus denen das Maximum ermittelt werden soll.
+	 * @return Das Maximum der Werte.
+	 * @throws IllegalArgumentException Wenn die Eingabe {@code null} oder leer
+	 *                                  ist.
+	 */
+	public static final int max( int... numbers ) {
+		if( numbers == null || numbers.length == 0 ) {
+			throw new IllegalArgumentException("Array may not be <null> or empty.");
+		}
+
+		int max = numbers[0];
+		for( int i = 1; i < numbers.length; i++ ) {
+			max = Math.max(max, numbers[i]);
+		}
+		return max;
+	}
+
 	/**
 	 * Berechnet das Maximum aller angegebenen Werte.
 	 *
@@ -1000,7 +1103,7 @@ public class Constants {
 	}
 
 	/**
-	 * Ermittelt den Arkuskosinus der angegebenen Zahl.
+	 * Ermittelt den Arcuskosinus der angegebenen Zahl.
 	 *
 	 * @param x Eine Zahl.
 	 * @return {@code acos(x)}.
@@ -1010,7 +1113,7 @@ public class Constants {
 	}
 
 	/**
-	 * Ermittelt den Arkusktangens der angegebenen Zahl.
+	 * Ermittelt den Arcusktangens der angegebenen Zahl.
 	 *
 	 * @param x Eine Zahl.
 	 * @return {@code atan(x)}.
@@ -1150,6 +1253,12 @@ public class Constants {
 		return interpolate(toMin, toMax, (value - fromMin) / (fromMax - fromMin));
 	}
 
+	public static final double distance( double fromX, double fromY, double toX, double toY ) {
+		double diffX = toX - fromX;
+		double diffY = toY - fromY;
+		return sqrt(diffX*diffX + diffY*diffY);
+	}
+
 	/**
 	 * Geteilte {@code Random}-Instanz für einheitliche Zufallszahlen.
 	 */
@@ -1280,6 +1389,26 @@ public class Constants {
 		return getRandom().nextGaussian();
 	}
 
+	/**
+	 * Wählt ein zufälliges Element aus dem Array aus.
+	 *
+	 * @param values Ein Array mit Werten, die zur Auswahl stehen.
+	 * @return Ein zufälliges Element aus dem Array.
+	 */
+	/*public static final int choice( int... values ) {
+		return values[random(0, values.length - 1)];
+	}*/
+
+	/**
+	 * Wählt ein zufälliges Element aus dem Array aus.
+	 *
+	 * @param values Ein Array mit Werten, die zur Auswahl stehen.
+	 * @return Ein zufälliges Element aus dem Array.
+	 */
+	/*public static final double choice( double... values ) {
+		return values[random(0, values.length - 1)];
+	}*/
+
 	/**
 	 * Wählt ein zufälliges Element aus dem Array aus.
 	 *
@@ -1287,7 +1416,7 @@ public class Constants {
 	 * @param <T> Datentyp des Elements.
 	 * @return Ein zufälliges Element aus dem Array.
 	 */
-	public static final <T> T choice( T[] values ) {
+	public static final <T> T choice( T... values ) {
 		return values[random(0, values.length - 1)];
 	}
 
@@ -1296,15 +1425,149 @@ public class Constants {
 	 *
 	 * @param values Ein Array mit Werten, die zur Auswahl stehen.
 	 * @param n Anzahl der auszuwählenden Elemente.
+	 * @param unique Bei {@code true} werden Elemente im Array nur maximal
+	 * 	einmal ausgewählt (Ziehen ohne Zurücklegen).
+	 * @return Ein zufälliges Element aus dem Array.
+	 * @throws IllegalArgumentException Wenn {@code unique == true} und
+	 *                                  {@code values.length < n}, also nicht
+	 *                                  genug Werte zur Wahl stehen.
+	 */
+	public static final int[] choice( int[] values, int n, boolean unique ) {
+		if( unique && values.length < n )
+			throw new IllegalArgumentException(
+				String.format("Need at least <%d> values to choose <%d> unique values (<%d> given).", n, n, values.length)
+			);
+
+		int[] result = new int[n];
+		int[] valuesCopy = Arrays.copyOf(values, values.length);
+		for( int i = 0; i < n; i++ ) {
+			int j = random(0, valuesCopy.length - 1);
+			int l = valuesCopy.length - 1;
+
+			result[i] = valuesCopy[j];
+			valuesCopy[j] = valuesCopy[l];
+			valuesCopy[l] = result[i];
+
+			if( unique )
+				valuesCopy = Arrays.copyOf(valuesCopy, l);
+		}
+		return result;
+	}
+
+	/**
+	 * Wählt die angegebene Anzahl Elemente aus dem Array aus.
+	 *
+	 * @param values Ein Array mit Werten, die zur Auswahl stehen.
+	 * @param n Anzahl der auszuwählenden Elemente.
+	 * @param unique Bei {@code true} werden Elemente im Array nur maximal
+	 * 	einmal ausgewählt (Ziehen ohne Zurücklegen).
+	 * @return Ein zufälliges Element aus dem Array.
+	 * @throws IllegalArgumentException Wenn {@code unique == true} und
+	 *                                  {@code values.length < n}, also nicht
+	 *                                  genug Werte zur Wahl stehen.
+	 */
+	public static final double[] choice( double[] values, int n, boolean unique ) {
+		if( unique && values.length < n )
+			throw new IllegalArgumentException(
+				String.format("Need at least <%d> values to choose <%d> unique values (<%d> given).", n, n, values.length)
+			);
+
+		double[] result = new double[n];
+		double[] valuesCopy = Arrays.copyOf(values, values.length);
+		for( int i = 0; i < n; i++ ) {
+			int j = random(0, valuesCopy.length - 1);
+			int l = valuesCopy.length - 1;
+
+			result[i] = valuesCopy[j];
+			valuesCopy[j] = valuesCopy[l];
+			valuesCopy[l] = result[i];
+
+			if( unique )
+				valuesCopy = Arrays.copyOf(valuesCopy, l);
+		}
+		return result;
+	}
+
+	/**
+	 * Wählt die angegebene Anzahl Elemente aus dem Array aus.
+	 *
+	 * @param values Ein Array mit Werten, die zur Auswahl stehen.
+	 * @param n Anzahl der auszuwählenden Elemente.
+	 * @param unique Bei {@code true} werden Elemente im Array nur maximal
+	 * 	einmal ausgewählt (Ziehen ohne Zurücklegen).
 	 * @param <T> Datentyp der Elemente.
 	 * @return Ein zufälliges Element aus dem Array.
+	 * @throws IllegalArgumentException Wenn {@code unique == true} und
+	 *                                  {@code values.length < n}, also nicht
+	 *                                  genug Werte zur Wahl stehen.
 	 */
-	public static final <T> T[] choice( T[] values, int n ) {
-		Object[] result = new Object[n];
+	public static final <T> T[] choice( T[] values, int n, boolean unique ) {
+		if( unique && values.length < n )
+			throw new IllegalArgumentException(
+				String.format("Need at least <%d> values to choose <%d> unique values (<%d> given).", n, n, values.length)
+			);
+
+		T[] result = Arrays.copyOf(values, n);
+		T[] valuesCopy = Arrays.copyOf(values, values.length);
 		for( int i = 0; i < n; i++ ) {
-			result[i] = choice(values);
+			int last = valuesCopy.length - 1;
+			int j = random(0, last);
+
+			result[i] = valuesCopy[j];
+			valuesCopy[j] = valuesCopy[last];
+			valuesCopy[last] = result[i];
+
+			if( unique )
+				valuesCopy = Arrays.copyOf(valuesCopy, last);
 		}
-		return (T[]) result;
+		return result;
+	}
+
+	/**
+	 * Bringt die Zahlen im Array in eine zufällige Reihenfolge.
+	 *
+	 * @param values Ein Array mit Zahlen, die gemischt werden sollen.
+	 * @return Das Array in zufälliger Reihenfolge.
+	 */
+	public static final int[] shuffle( int[] values ) {
+		for( int i = 0; i < values.length - 1; i++ ) {
+			int j = random(i, values.length - 1);
+			int tmp = values[i];
+			values[i] = values[j];
+			values[j] = tmp;
+		}
+
+		return values;
+	}
+
+	/**
+	 * Bringt die Zahlen im Array in eine zufällige Reihenfolge.
+	 *
+	 * @param values Ein Array mit Zahlen, die gemischt werden sollen.
+	 * @return Das Array in zufälliger Reihenfolge.
+	 */
+	public static final double[] shuffle( double[] values ) {
+		for( int i = 0; i < values.length - 1; i++ ) {
+			int j = random(i, values.length - 1);
+			double tmp = values[i];
+			values[i] = values[j];
+			values[j] = tmp;
+		}
+
+		return values;
+	}
+
+	/**
+	 * Bringt die Werte im Array in eine zufällige Reihenfolge.
+	 *
+	 * @param values Ein Array mit Werte, die gemischt werden sollen.
+	 * @param <T> Datentyp der Elemente.
+	 * @return Das Array in zufälliger Reihenfolge.
+	 */
+	public static final <T> T[] shuffle( T[] values ) {
+		java.util.List<T> valueList = Arrays.asList(values);
+		Collections.shuffle(valueList, random);
+		return valueList.toArray(values);
 	}
 
 	/**
@@ -1473,38 +1736,93 @@ public class Constants {
 		}
 	}
 
+	/**
+	 * Konvertiert einen char-Wert in einen double-Wert.
+	 *
+	 * @param value Der char-Wert.
+	 * @return Ein double-Wert.
+	 */
 	public static final double asDouble( char value ) {
-		return (double) value;
+		return value;
 	}
 
+	/**
+	 * Konvertiert einen byte-Wert in einen double-Wert.
+	 *
+	 * @param value Der byte-Wert.
+	 * @return Ein double-Wert.
+	 */
 	public static final double asDouble( byte value ) {
 		return value;
 	}
 
+	/**
+	 * Konvertiert einen short-Wert in einen double-Wert.
+	 *
+	 * @param value Der short-Wert.
+	 * @return Ein double-Wert.
+	 */
 	public static final double asDouble( short value ) {
 		return value;
 	}
 
+	/**
+	 * Konvertiert einen long-Wert in einen double-Wert.
+	 *
+	 * @param value Der long-Wert.
+	 * @return Ein double-Wert.
+	 */
 	public static final double asDouble( long value ) {
 		return (double) value;
 	}
 
+	/**
+	 * Konvertiert einen double-Wert in einen double-Wert.
+	 *
+	 * @param value Der double-Wert.
+	 * @return Ein double-Wert.
+	 */
 	public static final double asDouble( double value ) {
 		return value;
 	}
 
+	/**
+	 * Konvertiert einen float-Wert in einen double-Wert.
+	 *
+	 * @param value Der float-Wert.
+	 * @return Ein double-Wert.
+	 */
 	public static final double asDouble( float value ) {
 		return value;
 	}
 
+	/**
+	 * Konvertiert einen int-Wert in einen double-Wert.
+	 *
+	 * @param value Der int-Wert.
+	 * @return Ein double-Wert.
+	 */
 	public static final double asDouble( int value ) {
 		return value;
 	}
 
+	/**
+	 * Konvertiert einen boolean-Wert in einen double-Wert.
+	 *
+	 * @param value Der boolean-Wert.
+	 * @return Ein double-Wert.
+	 */
 	public static final double asDouble( boolean value ) {
 		return value ? 1.0 : 0.0;
 	}
 
+	/**
+	 * Konvertiert einen String in einen double-Wert.
+	 *
+	 * @param value Der String.
+	 * @return Ein double-Wert.
+	 * @see Double#parseDouble(String)
+	 */
 	public static final double asDouble( String value ) {
 		try {
 			return Double.parseDouble(value);
@@ -1513,38 +1831,93 @@ public class Constants {
 		}
 	}
 
+	/**
+	 * Konvertiert einen char-Wert in einen boolean-Wert.
+	 *
+	 * @param value Der char-Wert.
+	 * @return Ein boolean-Wert.
+	 */
 	public static final boolean asBool( char value ) {
 		return value != 0;
 	}
 
+	/**
+	 * Konvertiert einen byte-Wert in einen boolean-Wert.
+	 *
+	 * @param value Der byte-Wert.
+	 * @return Ein boolean-Wert.
+	 */
 	public static final boolean asBool( byte value ) {
 		return value != 0;
 	}
 
+	/**
+	 * Konvertiert einen short-Wert in einen boolean-Wert.
+	 *
+	 * @param value Der short-Wert.
+	 * @return Ein boolean-Wert.
+	 */
 	public static final boolean asBool( short value ) {
 		return value != 0;
 	}
 
+	/**
+	 * Konvertiert einen int-Wert in einen boolean-Wert.
+	 *
+	 * @param value Der int-Wert.
+	 * @return Ein boolean-Wert.
+	 */
 	public static final boolean asBool( int value ) {
 		return value != 0;
 	}
 
+	/**
+	 * Konvertiert einen long-Wert in einen boolean-Wert.
+	 *
+	 * @param value Der long-Wert.
+	 * @return Ein boolean-Wert.
+	 */
 	public static final boolean asBool( long value ) {
 		return value != 0L;
 	}
 
+	/**
+	 * Konvertiert einen double-Wert in einen boolean-Wert.
+	 *
+	 * @param value Der double-Wert.
+	 * @return Ein boolean-Wert.
+	 */
 	public static final boolean asBool( double value ) {
 		return value != 0.0;
 	}
 
+	/**
+	 * Konvertiert einen float-Wert in einen boolean-Wert.
+	 *
+	 * @param value Der float-Wert.
+	 * @return Ein boolean-Wert.
+	 */
 	public static final boolean asBool( float value ) {
 		return value != 0.0f;
 	}
 
+	/**
+	 * Konvertiert einen boolean-Wert in einen boolean-Wert.
+	 *
+	 * @param value Der boolean-Wert.
+	 * @return Ein boolean-Wert.
+	 */
 	public static final boolean asBool( boolean value ) {
 		return value;
 	}
 
+	/**
+	 * Konvertiert einen String in einen boolean-Wert.
+	 *
+	 * @param value Der String.
+	 * @return Ein boolean-Wert.
+	 * @see Boolean#parseBoolean(String)
+	 */
 	public static final boolean asBool( String value ) {
 		return Boolean.parseBoolean(value);
 	}
@@ -1605,7 +1978,7 @@ public class Constants {
 		return Integer.valueOf(binary, 16);
 	}
 
-	// Konstants für Key events (Copied from KeyEvent)
+	// Konstanten für Key events (Copied from KeyEvent)
 
 	/**
 	 * Constant for the ENTER virtual key.

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

@@ -0,0 +1,279 @@
+package schule.ngb.zm;
+
+import schule.ngb.zm.shapes.Shape;
+
+import java.awt.*;
+
+/**
+ * {@link Drawable} Klassen, die mit einer Füllung versehen werden können.
+ * <p>
+ * Das {@code Fillable} Interface dient hauptsächlich zur Vereinheitlichung der
+ * API für Füllungen. Durch Implementation wird sichergestellt, dass alle
+ * Objekte, die eine Füllung haben können, dieselben Methoden zur Verfügung
+ * stellen. Wenn eine {@link Shape} eine
+ * {@link Fillable#setFillColor(Color, int)} Methode hat, dann sollte auch eine
+ * {@link schule.ngb.zm.layers.TurtleLayer.Turtle} dieselbe Methode anbieten. Im
+ * Einzelfall kann es sinnvoll sein, weitere Methoden für Füllungen zur
+ * Verfügung zu stellen. Allerdings sollte davon nach Möglichkeit zugunsten
+ * einer einheitlichen API abgesehen werden.
+ * <p>
+ * Das Äquivalent für Konturlinien stellt {@link Strokeable} dar.
+ * <p>
+ * Im einfachsten Fall reicht es {@link #setFill(Paint)} und {@link #getFill()}
+ * zu implementieren. Die anderen Methoden besitzen Standardimplementierungen,
+ * die sich auf die beiden Methoden beziehen. Allerdings ist es in vielen Fällen
+ * sinnvoll, einige der Methoden gezielt zu überschreiben, um sie an spezifische
+ * Situationen anzupassen.
+ */
+public interface Fillable extends Drawable {
+
+	/**
+	 * Setzt die Füllung direkt auf das angegebene {@code Paint}-Objekt.
+	 *
+	 * @param fill Die neue Füllung.
+	 */
+	void setFill( Paint fill );
+
+	/**
+	 * Gibt die aktuell gesetzte Füllung zurück.
+	 * <p>
+	 * Die Art der Füllung kann anhand der Abfragen {@link #hasFillColor()} und
+	 * {@link #hasGradient()} ermittelt werden.
+	 *
+	 * @return Die aktuelle Füllung.
+	 */
+	Paint getFill();
+
+	/**
+	 * Gibt an, ob aktuell eine sichtbare Füllung konfiguriert ist.
+	 * <p>
+	 * Eine Füllung gilt als sichtbar, wenn eine nciht transparente Füllfarbe
+	 * oder ein Farbverlauf eingestellt ist.
+	 *
+	 * @return {@code true}, wenn die Füllung sichtbar ist, {@code false} sonst.
+	 */
+	default boolean hasFill() {
+		return (hasFillColor() && getFillColor().getAlpha() > 0) || hasGradient();
+	}
+
+	/**
+	 * Gibt an, ob eine Füllfarbe konfiguriert ist.
+	 * <p>
+	 * Im Gegensatz zu {@link #hasFill()} prüft die Methode <em>nicht</em>, ob
+	 * die Füllfarbe transparent ist.
+	 *
+	 * @return {@code true}, wenn eine Füllfarbe gesetzt ist.
+	 */
+	default boolean hasFillColor() {
+		Paint fill = getFill();
+		return fill instanceof Color;
+	}
+
+	/**
+	 * Gibt an, ob ein Farbverlauf konfiguriert ist.
+	 *
+	 * @return {@code true}, wenn ein Farbverlauf gesetzt ist.
+	 */
+	default boolean hasGradient() {
+		Paint fill = getFill();
+		return fill instanceof MultipleGradientPaint;
+	}
+
+	/**
+	 * Gibt die aktuelle Füllfarbe der Form zurück.
+	 *
+	 * @return Die aktuelle Füllfarbe oder {@code null}.
+	 */
+	default Color getFillColor() {
+		if( hasFillColor() ) {
+			return (Color) getFill();
+		} else {
+			return null;
+		}
+	}
+
+	/**
+	 * Setzt die Füllfarbe auf die angegebene Farbe.
+	 *
+	 * @param color Die neue Füllfarbe oder {@code null}.
+	 * @see Color
+	 */
+	default void setFillColor( Color color ) {
+		setFill(color);
+	}
+
+	/**
+	 * Setzt die Füllfarbe auf die angegebene Farbe und setzt die Transparenz
+	 * auf den angegebenen Wert. 0 is komplett durchsichtig und 255 komplett
+	 * deckend.
+	 *
+	 * @param color Die neue Füllfarbe oder {@code null}.
+	 * @param alpha Ein Transparenzwert zwischen 0 und 255.
+	 * @see Color#Color(Color, int)
+	 */
+	default void setFillColor( Color color, int alpha ) {
+		setFillColor(new Color(color, alpha));
+	}
+
+	/**
+	 * Setzt die Füllfarbe auf einen Grauwert mit der angegebenen Intensität. 0
+	 * entspricht schwarz, 255 entspricht weiß.
+	 *
+	 * @param gray Ein Grauwert zwischen 0 und 255.
+	 * @see Color#Color(int)
+	 */
+	default void setFillColor( int gray ) {
+		setFillColor(gray, gray, gray, 255);
+	}
+
+	/**
+	 * Setzt die Füllfarbe auf einen Grauwert mit der angegebenen Intensität und
+	 * dem angegebenen Transparenzwert. Der Grauwert 0 entspricht schwarz, 255
+	 * entspricht weiß.
+	 *
+	 * @param gray Ein Grauwert zwischen 0 und 255.
+	 * @param alpha Ein Transparenzwert zwischen 0 und 255.
+	 * @see Color#Color(int, int)
+	 */
+	default void setFillColor( int gray, int alpha ) {
+		setFillColor(gray, gray, gray, alpha);
+	}
+
+	/**
+	 * Setzt die Füllfarbe auf die Farbe mit den angegebenen Rot-, Grün- und
+	 * Blauanteilen.
+	 *
+	 * @param red Der Rotanteil der Farbe zwischen 0 und 255.
+	 * @param green Der Grünanteil der Farbe zwischen 0 und 255.
+	 * @param blue Der Blauanteil der Farbe zwischen 0 und 255.
+	 * @see Color#Color(int, int, int)
+	 * @see <a
+	 * 	href="https://de.wikipedia.org/wiki/RGB-Farbraum">https://de.wikipedia.org/wiki/RGB-Farbraum</a>
+	 */
+	default void setFillColor( int red, int green, int blue ) {
+		setFillColor(red, green, blue, 255);
+	}
+
+	/**
+	 * Setzt die Füllfarbe auf die Farbe mit den angegebenen Rot-, Grün- und
+	 * Blauanteilen und dem angegebenen Transparenzwert.
+	 *
+	 * @param red Der Rotanteil der Farbe zwischen 0 und 255.
+	 * @param green Der Grünanteil der Farbe zwischen 0 und 255.
+	 * @param blue Der Blauanteil der Farbe zwischen 0 und 255.
+	 * @param alpha Ein Transparenzwert zwischen 0 und 25
+	 * @see Color#Color(int, int, int, int)
+	 * @see <a
+	 * 	href="https://de.wikipedia.org/wiki/RGB-Farbraum">https://de.wikipedia.org/wiki/RGB-Farbraum</a>
+	 */
+	default void setFillColor( int red, int green, int blue, int alpha ) {
+		setFillColor(new Color(red, green, blue, alpha));
+	}
+
+	/**
+	 * Entfernt die Füllung der Form.
+	 */
+	default void noFill() {
+		setFillColor(null);
+		noGradient();
+	}
+
+	/**
+	 * Setzt die Füllfarbe auf den Standardwert zurück.
+	 *
+	 * @see schule.ngb.zm.Constants#DEFAULT_FILLCOLOR
+	 */
+	default void resetFill() {
+		setFillColor(Constants.DEFAULT_FILLCOLOR);
+		noGradient();
+	}
+
+	/**
+	 * Gibt den aktuellen Farbverlauf der Form zurück.
+	 *
+	 * @return Der aktuelle Farbverlauf oder {@code null}.
+	 */
+	default MultipleGradientPaint getGradient() {
+		if( hasGradient() ) {
+			return (MultipleGradientPaint) getFill();
+		} else {
+			return null;
+		}
+	}
+
+	/**
+	 * Setzt die Füllung auf einen linearen Farbverlauf, der am Punkt
+	 * ({@code fromX}, {@code fromY}) mit der Farbe {@code from} startet und am
+	 * Punkt (({@code toX}, {@code toY}) mit der Farbe {@code to} endet.
+	 *
+	 * @param fromX x-Koordinate des Startpunktes.
+	 * @param fromY y-Koordinate des Startpunktes.
+	 * @param from Farbe am Startpunkt.
+	 * @param toX x-Koordinate des Endpunktes.
+	 * @param toY y-Koordinate des Endpunktes.
+	 * @param to Farbe am Endpunkt.
+	 */
+	default void setGradient( double fromX, double fromY, Color from, double toX, double toY, Color to ) {
+		setFill(new LinearGradientPaint(
+			(float) fromX, (float) fromY,
+			(float) toX, (float) toY,
+			new float[]{0f, 1f},
+			new java.awt.Color[]{from.getJavaColor(), to.getJavaColor()}
+		));
+	}
+
+	/**
+	 * Setzt die Füllung auf einen linearen Farbverlauf, der in die angegebene
+	 * Richtung verläuft.
+	 *
+	 * @param from Farbe am Startpunkt.
+	 * @param to Farbe am Endpunkt.
+	 * @param dir Richtung des Farbverlaufs.
+	 */
+	default void setGradient( Color from, Color to, Options.Direction dir ) {
+		int whalf = (Constants.canvasWidth / 2);
+		int hhalf = (Constants.canvasHeight / 2);
+		setGradient(whalf - dir.x * whalf, hhalf - dir.y * hhalf, from, whalf + dir.x * whalf, hhalf + dir.y * hhalf, to);
+	}
+
+	/**
+	 * Setzt die Füllung auf einen kreisförmigen (radialen) Farbverlauf, mit dem
+	 * Zentrum im Punkt ({@code centerX}, {@code centerY}) und dem angegebenen
+	 * Radius. Der Verlauf starte im Zentrum mit der Farbe {@code from} und
+	 * endet am Rand des durch den Radius beschriebenen Kreises mit der Farbe
+	 * {@code to}.
+	 *
+	 * @param centerX x-Koordinate des Kreismittelpunktes.
+	 * @param centerY y-Koordinate des Kreismittelpunktes.
+	 * @param radius Radius des Kreises.
+	 * @param from Farbe im Zentrum des Kreises.
+	 * @param to Farbe am Rand des Kreises.
+	 */
+	default void setGradient( double centerX, double centerY, double radius, Color from, Color to ) {
+		setFill(new RadialGradientPaint(
+			(float) centerX, (float) centerY, (float) radius,
+			new float[]{0f, 1f},
+			new java.awt.Color[]{from.getJavaColor(), to.getJavaColor()}));
+	}
+
+	/**
+	 * Setzt die Füllung auf einen kreisförmigen (radialen) Farbverlauf, der im
+	 * Zentrum beginnt.
+	 *
+	 * @param from Farbe im Zentrum.
+	 * @param to Farbe am Rand.
+	 */
+	default void setGradient( Color from, Color to ) {
+		int whalf = (Constants.canvasWidth / 2);
+		int hhalf = (Constants.canvasHeight / 2);
+		setGradient(whalf, hhalf, Math.min(whalf, hhalf), from, to);
+	}
+
+	/**
+	 * Entfernt den Farbverlauf von der Form.
+	 */
+	default void noGradient() {
+		setFill(null);
+	}
+
+}

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

@@ -12,10 +12,10 @@ import java.awt.image.BufferedImage;
  * Die {@code Zeichenleinwand} besteht aus einer Reihe von Ebenen, die
  * übereinandergelegt und von "unten" nach "oben" gezeichnet werden. Die Inhalte
  * der oberen Ebenen können also Inhalte der darunterliegenden verdecken.
- *
- * Ebenen sind ein zentraler Bestandteil bei der Implementierung einer {@link Zeichenmaschine}.
- * Es werden
- * Sie erben von {@code Constants}, damit sie beim
+ * <p>
+ * Ebenen sind ein zentraler Bestandteil bei der Implementierung einer
+ * {@link Zeichenmaschine}. Sie erben von {@code Constants}, da neue Ebenentypen
+ * von Nutzern implementiert werden können.
  */
 public abstract class Layer extends Constants implements Drawable, Updatable {
 
@@ -43,24 +43,39 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 	protected boolean active = true;
 
 
+	/**
+	 * Erstellt eine neue Ebene mit den Standardmaßen.
+	 */
 	public Layer() {
 		this(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 	}
 
+	/**
+	 * Erstellt eine neue Ebene mit den angegebenen Maßen.
+	 *
+	 * @param width Die Breite der Ebene.
+	 * @param height Die Höhe der Ebene.
+	 */
 	public Layer( int width, int height ) {
 		createCanvas(width, height);
 	}
 
+	/**
+	 * @return Die Breite der Ebene.
+	 */
 	public int getWidth() {
 		return buffer.getWidth();
 	}
 
+	/**
+	 * @return Die Höhe der Ebene.
+	 */
 	public int getHeight() {
 		return buffer.getHeight();
 	}
 
 	/**
-	 * Ändert die Größe der Ebene auf die angegebene Größe.
+	 * Ändert die Größe der Ebene auf die angegebenen Maße.
 	 *
 	 * @param width Die neue Breite.
 	 * @param height Die neue Höhe.
@@ -73,11 +88,15 @@ 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;
 	}
 
 	/**
-	 * Gibt die Resourcen der Ebene frei.
+	 * Gibt die Ressourcen der Ebene frei.
 	 */
 	public void dispose() {
 		drawing.dispose();
@@ -88,7 +107,7 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 	/**
 	 * Erstellt einen neuen Puffer für die Ebene und konfiguriert diesen.
 	 *
-	 * @param width Width des neuen Puffers.
+	 * @param width Breite des neuen Puffers.
 	 * @param height Höhe des neuen Puffers.
 	 */
 	private void createCanvas( int width, int height ) {
@@ -115,7 +134,7 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 	 * Erstellt einen neuen Puffer für die Ebene mit der angegebenen Größe und
 	 * kopiert den Inhalt des alten Puffers in den Neuen.
 	 *
-	 * @param width Width des neuen Puffers.
+	 * @param width Breite des neuen Puffers.
 	 * @param height Höhe des neuen Puffers.
 	 */
 	private void recreateCanvas( int width, int height ) {
@@ -139,14 +158,14 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 	}
 
 	/**
-	 * Zeichnet den Puffer auf die Grafik-Instanz.
+	 * Zeichnet den Puffer auf den Grafikkontext.
 	 *
-	 * @param pGraphics
+	 * @param graphics Der Grafikkontext, auf den gezeichnet wird.
 	 */
 	@Override
-	public void draw( Graphics2D pGraphics ) {
+	public void draw( Graphics2D graphics ) {
 		if( visible ) {
-			pGraphics.drawImage(buffer, 0, 0, null);
+			graphics.drawImage(buffer, 0, 0, null);
 		}
 	}
 
@@ -155,14 +174,26 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 		return visible;
 	}
 
+	/**
+	 * Versteckt die Ebene.
+	 */
 	public void hide() {
 		visible = false;
 	}
 
-	public void view() {
+	/**
+	 * Zeigt die Ebene an, falls sie versteckt war.
+	 */
+	@SuppressWarnings( "unused" )
+	public void show() {
 		visible = true;
 	}
 
+	/**
+	 * Versteckt oder zeigt die Ebene, je nachdem, welchen Zustand sie derzeit
+	 * hat.
+	 */
+	@SuppressWarnings( "unused" )
 	public void toggle() {
 		visible = !visible;
 	}
@@ -176,4 +207,22 @@ public abstract class Layer extends Constants implements Drawable, Updatable {
 		return active;
 	}
 
+	/**
+	 * Prüft, ob die angegebenen Koordinaten innerhalb der Ebene liegen, oder
+	 * nicht.
+	 * <p>
+	 * Eine Koordinate liegt in der Ebene, wenn die {@code x}- und
+	 * {@code y}-Koordinaten größer oder gleich Null und kleiner als die Breite
+	 * bzw. Höhe der Ebene sind.
+	 *
+	 * @param x Die x-Koordinate.
+	 * @param y Die y-Koordinate.
+	 * @return {@code true}, wenn die Koordinaten innerhalb der Ebene liegen,
+	 *    {@code false}, wenn sie außerhalb liegen.
+	 */
+	@SuppressWarnings( "unused" )
+	public boolean isInBounds( int x, int y ) {
+		return (x >= 0 && y >= 0 && x < getWidth() && y < getHeight());
+	}
+
 }

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

@@ -11,17 +11,71 @@ public final class Options {
 	private Options() {
 	}
 
+	/**
+	 * Linienstile für Konturlinien.
+	 */
 	public enum StrokeType {
-		SOLID, DASHED, DOTTED
+		/**
+		 * Durchgezogene Linien.
+		 */
+		SOLID,
+
+		/**
+		 * Getrichelte Linien.
+		 */
+		DASHED,
+
+		/**
+		 * Gepunktete Linien.
+		 */
+		DOTTED
 	}
 
+	/**
+	 * Stile für Pfeilspitzen.
+	 */
 	public enum ArrowHead {
-		LINES, FILLED
+		/**
+		 * Einfache Pfeilspitze aus zwei Linien.
+		 */
+		LINES,
+
+		/**
+		 * Gefülltes Dreieck.
+		 */
+		FILLED
 	}
 
+	/**
+	 * Arten von Bögen.
+	 * <p>
+	 * Die Werte legen fest, wie Bögen geschlossen werden sollen, wenn sie
+	 * beispielsweise gefüllt werden.
+	 * <p>
+	 * Wrapper für die AWT-Konstanten in {@link Arc2D}.
+	 */
 	public enum PathType {
-		OPEN(Arc2D.OPEN), CLOSED(Arc2D.CHORD), PIE(Arc2D.PIE);
+		/**
+		 * Offener Pfad, bei dem die Pfadenden direkt miteinander verbunden
+		 * werden ohne eine Linie zu ziehen.
+		 */
+		OPEN(Arc2D.OPEN),
 
+		/**
+		 * Geschlossener Pfad, bei dem die Pfadenden direkt miteinander
+		 * verbunden werden, indem eine Linie gezogen wird.
+		 */
+		CLOSED(Arc2D.CHORD),
+
+		/**
+		 * Geschlossener Pfad, bei dem Linien von den Pfadenden zum Mittelpunkt
+		 * des Kreises, der den Kreisbogen festlegt, gezogen werden.
+		 */
+		PIE(Arc2D.PIE);
+
+		/**
+		 * Der entsprechende Wert der Konstanten in {@link Arc2D}
+		 */
 		public final int awt_type;
 
 		PathType( int type ) {
@@ -33,24 +87,100 @@ public final class Options {
 	 * Zustände in denen sich die Zeichenmaschine befinden kann.
 	 */
 	public enum AppState {
+		/**
+		 * Die Zeichenmaschine befindet sich in der Initialisierung. Die
+		 * Laufzeitumgebung wird konfiguriert und alle nötigen Komonenten
+		 * ({@link Zeichenfenster}, {@link Zeichenleinwand}, ...) werden
+		 * erstellt.
+		 */
 		INITIALIZING,
+
+		/**
+		 * Die Initialisierung der Zeichenmaschine ist beendet, aber der
+		 * {@link schule.ngb.zm.Zeichenmaschine.Zeichenthread Zeichenthread}
+		 * wurde noch nicht gestartet.
+		 */
 		INITIALIZED,
+
+		/**
+		 * Die Zeichenmaschine wurde gestartet und der
+		 * {@link schule.ngb.zm.Zeichenmaschine.Zeichenthread Zeichenthread}
+		 * arbeitet.
+		 */
 		RUNNING,
-		UPDATING,
-		DRAWING,
+
+		/**
+		 * Der {@link schule.ngb.zm.Zeichenmaschine.Zeichenthread Zeichenthread}
+		 * wurde pausiert.
+		 */
 		PAUSED,
+
+		/**
+		 * Der {@link schule.ngb.zm.Zeichenmaschine.Zeichenthread Zeichenthread}
+		 * wurde gestoppt, die Zeichenmaschine ist aber noch nicht vollständig
+		 * heruntergefahren und hat noch nicht alle Ressourcen freigegeben.
+		 */
 		STOPPED,
+
+		/**
+		 * Der {@link schule.ngb.zm.Zeichenmaschine.Zeichenthread Zeichenthread}
+		 * ist beendet.
+		 */
 		TERMINATED,
+
+		/**
+		 * Die Zeichenmaschine ist dabei, vollständig herunterzufahren und alle
+		 * Ressourcen freizugeben.
+		 */
+		QUITING,
+
+		/**
+		 * Der {@link schule.ngb.zm.Zeichenmaschine.Zeichenthread Zeichenthread}
+		 * wartet gerade auf den nächsten Frame.
+		 */
 		IDLE,
+
+		/**
+		 * Die Zeichenmaschine führt gerade
+		 * {@link Zeichenmaschine#update(double)} aus.
+		 */
+		UPDATING,
+
+		/**
+		 * Die Zeichenmaschine führt gerade {@link Zeichenmaschine#draw()} aus.
+		 */
+		DRAWING,
+
+		/**
+		 * Die Ausführung der Zeichenmaschine wurde mit
+		 * {@link Zeichenmaschine#delay(int)} verzögert und wartet auf
+		 * Fortsetzung.
+		 */
 		DELAYED,
+
+		/**
+		 * Die Zeichenmaschine sendet gereade gesammelte Events und führt Tasks
+		 * aus.
+		 */
 		DISPATCHING
 	}
 
 	/**
 	 * Richtungen für die Ausrichtung von Formen. Richtungen sind durch
-	 * Einheitsvektoren bzw. deren Kombination repräsentiert, wodurch mit ihnen
-	 * gerechnet werden kann. Jede Richtung ist zusätzlich als Himmelsrichtung
-	 * definiert.
+	 * Einheitsvektoren bzw. deren Kombination im Koordinatensystem der
+	 * Zeichenfläche repräsentiert, wodurch mit ihnen gerechnet werden kann. Die
+	 * Richtung {@link #DOWN} ist beispielsweise gleich {@code (1, 0)}.
+	 * <p>
+	 * Jede Richtung ist zusätzlich als Himmelsrichtung definiert. {@link #EAST}
+	 * ist äquivalent zu {@link #RIGHT} als {@code (0, 1)} definiert. Auch wenn
+	 * beide Werte dieselbe Richtung beschreiben sind sie nicht "gleich"
+	 * ({@code EAST != RIGHT}). Um verschiedene Richtungen zuverlässig zu
+	 * vergleichen, sollte daher {@link #equals(Direction)} verwendet werden.
+	 * <p>
+	 * Für zusammengesetzten Richtungen wie {@link #NORTHEAST} bzw
+	 * {@link #UPRIGHT} lassen sich mit {@link #in(Direction)} und
+	 * {@link #contains(Direction)} Beziehungen zu den anderen Richtungen
+	 * prüfen. Beispielsweise ist {@code NORTHEAST.contains(NORTH)} wahr.
 	 */
 	public enum Direction {
 		CENTER(0, 0),
@@ -88,31 +218,117 @@ public final class Options {
 			this.y = original.y;
 		}
 
+		/**
+		 * Prüft, ob die angegebene Richtung gleich dieser ist. Dabei werden die
+		 * Komponenten des Richtungsvektors geprüft. Daher sind für die Methode
+		 * beispielsweise {@link #NORTH} und {@link #UP} gleich.
+		 *
+		 * @param dir Eine andere Richtung.
+		 * @return {@code true}, wenn die Richtungen dieselben Komponenten
+		 * 	haben, {@code false} sonst.
+		 */
+		public boolean equals( Direction dir ) {
+			return this.x == dir.x && this.y == dir.y;
+		}
+
+		/**
+		 * Prüft, ob diese Richtung Tile der angegebenen Richtung ist.
+		 * <p>
+		 * Beispielsweise ist {@link #NORTH} Teil von {@link #NORTHWEST}, aber
+		 * nicht von {@link #SOUTHWEST}. Dabei wird doe Art der Richtung nicht
+		 * beachtet. {@link #UP} ist daher auch Teil von {@link #NORTHWEST}.
+		 *
+		 * <pre>
+		 * NORTH.in(NORTHWEST) // true
+		 * NORTH.in(SOUTHWEST) // false
+		 * UP.in(NORTHWEST) // true
+		 * </pre>
+		 *
+		 * @param dir Eine andere Richtung.
+		 * @return {@code true}, wenn diese Richtungen Teil der anderen ist,
+		 *    {@code false} sonst.
+		 */
 		public boolean in( Direction dir ) {
 			return (this.x == dir.x && this.y == 0) || (this.y == dir.y && this.x == 0) || (this.x == dir.x && this.y == dir.y);
 		}
 
+		/**
+		 * Prüft, ob die angegebene Richtung Teil dieser Richtung ist.
+		 * <p>
+		 * Beispielsweise ist {@link #NORTH} Teil von {@link #NORTHWEST}, aber
+		 * nicht von {@link #SOUTHWEST}. Dabei wird die Art der Richtung nicht
+		 * beachtet. {@link #UP} ist daher auch Teil von {@link #NORTHWEST}.
+		 *
+		 * <pre>
+		 * NORTHWEST.contains(NORTH) // true
+		 * SOUTHWEST.in(NORTH) // false
+		 * NORTHWEST.in(UP) // true
+		 * </pre>
+		 *
+		 * @param dir Eine andere Richtung.
+		 * @return {@code true}, wenn diese Richtungen Teil der anderen ist,
+		 *    {@code false} sonst.
+		 */
 		public boolean contains( Direction dir ) {
 			return dir.in(this);
 		}
 
+		/**
+		 * @return Diese Richtung als Vektor-Objekt.
+		 */
 		public Vector asVector() {
 			return new Vector(x, y);
 		}
 
 		/**
-		 * Gibt die entgegengesetzte Richtung zu dieser zurück.
+		 * Liefert die entgegengesetzte Richtung zu dieser.
+		 * <p>
+		 * Es wird die Art der Richtung berücksichtigt. Das bedeutet, das
+		 * Inverse von {@link #UP} ist {@link #DOWN}, während das Inverse von
+		 * {@link #NORTH} zu {@link #SOUTH} wird.
 		 *
-		 * @return
+		 * @return Die entgegengesetzte Richtung zu dieser.
 		 */
 		public Direction inverse() {
-			for( Direction dir : Direction.values() ) {
-				if( dir.x == -this.x && dir.y == -this.y ) {
-					return dir;
-				}
-			}
+			switch( this ) {
+				case UP:
+					return DOWN;
+				case DOWN:
+					return UP;
+				case LEFT:
+					return RIGHT;
+				case RIGHT:
+					return LEFT;
+				case UPLEFT:
+					return DOWNRIGHT;
+				case UPRIGHT:
+					return DOWNLEFT;
+				case DOWNLEFT:
+					return UPRIGHT;
+				case DOWNRIGHT:
+					return UPLEFT;
+				case MIDDLE:
+					return MIDDLE;
+				case NORTH:
+					return SOUTH;
+				case SOUTH:
+					return NORTH;
+				case EAST:
+					return WEST;
+				case WEST:
+					return EAST;
+				case SOUTHWEST:
+					return NORTHEAST;
+				case SOUTHEAST:
+					return NORTHWEST;
+				case NORTHEAST:
+					return SOUTHWEST;
+				case NORTHWEST:
+					return SOUTHEAST;
+				default:
 					return CENTER;
 			}
 		}
+	}
 
 }

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

@@ -108,7 +108,7 @@ public class Spielemaschine extends Zeichenmaschine {
 		}
 
 		@Override
-		public void draw( Graphics2D pGraphics ) {
+		public void draw( Graphics2D graphics ) {
 			clear();
 			List<Drawable> it = List.copyOf(drawables);
 			for( Drawable d: it ) {
@@ -116,7 +116,7 @@ public class Spielemaschine extends Zeichenmaschine {
 					d.draw(drawing);
 				}
 			}
-			super.draw(pGraphics);
+			super.draw(graphics);
 		}
 
 	}

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

@@ -1,51 +1,68 @@
-package schule.ngb.zm.shapes;
+package schule.ngb.zm;
 
-import schule.ngb.zm.Color;
-import schule.ngb.zm.Constants;
-import schule.ngb.zm.Drawable;
-import schule.ngb.zm.Options;
+import schule.ngb.zm.shapes.Shape;
 
 import java.awt.BasicStroke;
-import java.awt.Graphics2D;
 import java.awt.Stroke;
 
-
 /**
- * Basisklasse für Formen, die eine Konturlinie besitzen.
+ * {@link Drawable} Klassen, die mit einer Konturlinie versehen werden können.
+ * <p>
+ * Das {@code Strokeable} Interface dient hauptsächlich zur Vereinheitlichung
+ * der API für Konturlinien. Durch Implementation wird sichergestellt, dass alle
+ * Objekte, die eine Konturlinie haben können, dieselben Methoden zur Verfügung
+ * stellen. Wenn eine {@link Shape} eine
+ * {@link Strokeable#setStrokeColor(Color, int)} Methode hat, dann sollte auch
+ * eine {@link schule.ngb.zm.layers.TurtleLayer.Turtle} dieselbe Methode
+ * anbieten. Im Einzelfall kann es sinnvoll sein, weitere Methoden für
+ * Konturlinien zur verfügung zu stellen. Allerdings sollte davon nach
+ * Möglichkeit zugunsten einer einheitlichen API abgesehen werden.
+ * <p>
+ * Das Äquivalent für Füllungen stellt {@link Fillable} dar.
  */
-public abstract class StrokedShape extends Constants implements Drawable {
+public interface Strokeable extends Drawable {
 
 	/**
-	 * Aktuelle Farbe der Konturlinie oder {@code null}, wenn die Form ohne
-	 * kontur dargestellt werden soll.
+	 * Setzt den {@code Stroke} für die Konturlinie direkt.
+	 *
+	 * @param stroke Ein {@code Stroke}-Objekt.
 	 */
-	protected Color strokeColor = DEFAULT_STROKECOLOR;
+	void setStroke( Stroke stroke );
 
 	/**
-	 * Die Dicke der Konturlinie. Wird nicht kleiner als 0.
+	 * Gibt ein {@code Stroke}-Objekt mit den aktuell gesetzten Eigenschaften
+	 * zurück.
+	 *
+	 * @return Ein {@code Stroke} mit den passenden Kontureigenschaften.
 	 */
-	protected double strokeWeight = DEFAULT_STROKEWEIGHT;
+	Stroke getStroke();
 
 	/**
-	 * Die Art der Konturlinie.
+	 * Gibt an, ob die aktuell gesetzten Eigenschaften eine sichtbare
+	 * Konturlinie erzeugen.
+	 * <p>
+	 * Die Konturlinie gilt als sichtbar, wenn sie eine nicht transparente Farbe
+	 * und eine Dicke größer 0 besitzt.
+	 * <p>
+	 * Das bedeutet, falls die Methode {@code false} zurückgibt, dann kann
+	 * {@link #getStroke()} trotzdem ein gültiges {@link Stroke}-Objekt
+	 * zurückgeben, beispielsweise wenn keine Farbe gesetzt wurde.
+	 *
+	 * @return {@code true}, wenn die Konturlinie sichtbar ist, {@code false}
+	 * 	sonst.
 	 */
-	protected Options.StrokeType strokeType = SOLID;
-
-	/**
-	 * Cache für den aktuellen {@code Stroke} der Kontur. Wird nach Änderung
-	 * einer der Kontureigenschaften auf {@code null} gesetzt und beim nächsten
-	 * Zeichnen neu erstellt.
-	 */
-	protected Stroke stroke = null;
+	default boolean hasStroke() {
+		Color strokeColor = getStrokeColor();
+		double strokeWeight = getStrokeWeight();
+		return strokeColor != null && strokeColor.getAlpha() > 0 && strokeWeight > 0;
+	}
 
 	/**
 	 * Gibt die aktuelle Farbe der Konturlinie zurück.
 	 *
 	 * @return Die Konturfarbe oder {@code null}.
 	 */
-	public Color getStrokeColor() {
-		return strokeColor;
-	}
+	Color getStrokeColor();
 
 	/**
 	 * Setzt die Farbe der Konturlinie auf die angegebene Farbe.
@@ -53,9 +70,7 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 * @param color Die neue Farbe der Konturlinie.
 	 * @see Color
 	 */
-	public void setStrokeColor( Color color ) {
-		this.strokeColor = color;
-	}
+	void setStrokeColor( Color color );
 
 	/**
 	 * Setzt die Farbe der Konturlinie auf die angegebene Farbe und setzt die
@@ -66,7 +81,7 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 * @param alpha Ein Transparenzwert zwischen 0 und 255.
 	 * @see Color#Color(Color, int)
 	 */
-	public void setStrokeColor( Color color, int alpha ) {
+	default void setStrokeColor( Color color, int alpha ) {
 		setStrokeColor(new Color(color, alpha));
 	}
 
@@ -77,7 +92,7 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 * @param gray Ein Grauwert zwischen 0 und 255.
 	 * @see Color#Color(int)
 	 */
-	public void setStrokeColor( int gray ) {
+	default void setStrokeColor( int gray ) {
 		setStrokeColor(gray, gray, gray, 255);
 	}
 
@@ -90,7 +105,7 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 * @param alpha Ein Transparenzwert zwischen 0 und 255.
 	 * @see Color#Color(int, int)
 	 */
-	public void setStrokeColor( int gray, int alpha ) {
+	default void setStrokeColor( int gray, int alpha ) {
 		setStrokeColor(gray, gray, gray, alpha);
 	}
 
@@ -105,7 +120,7 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 * @see <a
 	 * 	href="https://de.wikipedia.org/wiki/RGB-Farbraum">https://de.wikipedia.org/wiki/RGB-Farbraum</a>
 	 */
-	public void setStrokeColor( int red, int green, int blue ) {
+	default void setStrokeColor( int red, int green, int blue ) {
 		setStrokeColor(red, green, blue, 255);
 	}
 
@@ -121,14 +136,14 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 * @see <a
 	 * 	href="https://de.wikipedia.org/wiki/RGB-Farbraum">https://de.wikipedia.org/wiki/RGB-Farbraum</a>
 	 */
-	public void setStrokeColor( int red, int green, int blue, int alpha ) {
+	default void setStrokeColor( int red, int green, int blue, int alpha ) {
 		setStrokeColor(new Color(red, green, blue, alpha));
 	}
 
 	/**
 	 * Entfernt die Kontur der Form.
 	 */
-	public void noStroke() {
+	default void noStroke() {
 		setStrokeColor(null);
 	}
 
@@ -139,10 +154,10 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 * @see schule.ngb.zm.Constants#DEFAULT_STROKEWEIGHT
 	 * @see schule.ngb.zm.Constants#SOLID
 	 */
-	public void resetStroke() {
-		setStrokeColor(DEFAULT_STROKECOLOR);
-		setStrokeWeight(DEFAULT_STROKEWEIGHT);
-		setStrokeType(SOLID);
+	default void resetStroke() {
+		setStrokeColor(Constants.DEFAULT_STROKECOLOR);
+		setStrokeWeight(Constants.DEFAULT_STROKEWEIGHT);
+		setStrokeType(Constants.SOLID);
 	}
 
 	/**
@@ -150,9 +165,7 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 *
 	 * @return Die aktuelle Dicke der Linie.
 	 */
-	public double getStrokeWeight() {
-		return strokeWeight;
-	}
+	double getStrokeWeight();
 
 	/**
 	 * Setzt die Dicke der Konturlinie. Die Dicke muss größer 0 sein. Wird 0
@@ -160,9 +173,8 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 *
 	 * @param weight Die Dicke der Konturlinie.
 	 */
-	public void setStrokeWeight( double weight ) {
-		this.strokeWeight = max(0.0, weight);
-		this.stroke = null;
+	default void setStrokeWeight( double weight ) {
+		setStroke(createStroke(getStrokeType(), weight));
 	}
 
 	/**
@@ -171,25 +183,19 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 * @return Die aktuelle Art der Konturlinie.
 	 * @see Options.StrokeType
 	 */
-	public Options.StrokeType getStrokeType() {
-		return strokeType;
-	}
+	Options.StrokeType getStrokeType();
 
 	/**
-	 * Setzt den Typ der Kontur. Erlaubte Werte sind {@link #DASHED},
-	 * {@link #DOTTED} und {@link #SOLID}.
+	 * Setzt den Typ der Kontur. Erlaubte Werte sind {@link Constants#DASHED},
+	 * {@link Constants#DOTTED} und {@link Constants#SOLID}.
 	 *
 	 * @param type Eine der möglichen Konturarten.
 	 * @see Options.StrokeType
 	 */
-	public void setStrokeType( Options.StrokeType type ) {
-		this.strokeType = type;
-		this.stroke = null;
+	default void setStrokeType( Options.StrokeType type ) {
+		setStroke(createStroke(type, getStrokeWeight()));
 	}
 
-	@Override
-	public abstract void draw( Graphics2D graphics );
-
 	/**
 	 * Hilfsmethode, um ein {@link Stroke} Objekt mit den aktuellen
 	 * Kontureigenschaften zu erstellen. Der aktuelle {@code Stroke} wird
@@ -197,52 +203,26 @@ public abstract class StrokedShape extends Constants implements Drawable {
 	 *
 	 * @return Ein {@code Stroke} mit den passenden Kontureigenschaften.
 	 */
-	protected Stroke createStroke() {
-		// TODO: Used global cached Stroke Objects?
-		if( stroke == null ) {
+	static Stroke createStroke( Options.StrokeType strokeType, double strokeWeight ) {
 		switch( strokeType ) {
 			case DOTTED:
-					stroke = new BasicStroke(
+				return new BasicStroke(
 					(float) strokeWeight,
 					BasicStroke.CAP_ROUND,
 					BasicStroke.JOIN_ROUND,
 					10.0f, new float[]{1.0f, 5.0f}, 0.0f);
-					break;
 			case DASHED:
-					stroke = new BasicStroke(
+				return new BasicStroke(
 					(float) strokeWeight,
 					BasicStroke.CAP_ROUND,
 					BasicStroke.JOIN_ROUND,
 					10.0f, new float[]{5.0f}, 0.0f);
-					break;
 			case SOLID:
 			default:
-					stroke = new BasicStroke(
+				return new BasicStroke(
 					(float) strokeWeight,
 					BasicStroke.CAP_ROUND,
 					BasicStroke.JOIN_ROUND);
-					break;
-			}
-		}
-		return stroke;
-	}
-
-	/**
-	 * Hilfsmethode für Unterklassen, um die angegebene Form mit den aktuellen
-	 * Kontureigenschaften auf den Grafik-Kontext zu zeichnen. Die Methode
-	 * verändert gegebenenfalls die aktuelle Farbe des Grafikobjekts und setzt
-	 * sie nicht auf den Ursprungswert zurück, wie von {@link #draw(Graphics2D)}
-	 * gefordert. Dies sollte die aufrufende Unterklasse übernehmen.
-	 *
-	 * @param shape Die zu zeichnende Java-AWT Form
-	 * @param graphics Das Grafikobjekt.
-	 */
-	protected void strokeShape( java.awt.Shape shape, Graphics2D graphics ) {
-		if( strokeColor != null && strokeColor.getAlpha() > 0
-			&& strokeWeight > 0.0 ) {
-			graphics.setColor(strokeColor.getJavaColor());
-			graphics.setStroke(createStroke());
-			graphics.draw(shape);
 		}
 	}
 

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

@@ -28,7 +28,7 @@ public interface Updatable {
 	 * @return {@code true}, wenn das Objekt aktiv ist, {@code false}
 	 * 	andernfalls.
 	 */
-	public boolean isActive();
+	boolean isActive();
 
 	/**
 	 * Änderung des Zustandes des Objekts abhängig vom Zeitintervall
@@ -39,6 +39,6 @@ public interface Updatable {
 	 *
 	 * @param delta Zeitintervall seit dem letzten Aufruf (in Sekunden).
 	 */
-	public void update( double delta );
+	void update( double delta );
 
 }

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

@@ -23,6 +23,7 @@ import java.awt.geom.Point2D;
  * Der Vektor der Zeichenmaschine erweitert die Klasse {@link Point2D} und lässt
  * sich dadurch einfach mit den Klassen des {@link java.awt} Pakets benutzen.
  */
+@SuppressWarnings( "unused" )
 public class Vector extends Point2D.Double {
 
 	/**
@@ -127,7 +128,7 @@ public class Vector extends Point2D.Double {
 	}
 
 	/**
-	 * Erzeugt einen neuen Vektor mit derselben Richtun wie der angegebene
+	 * Erzeugt einen neuen Vektor mit derselben Richtung wie der angegebene
 	 * Vektor und der Länge 1.
 	 *
 	 * @param vector Der original Vektor.
@@ -197,6 +198,7 @@ public class Vector extends Point2D.Double {
 	 * @param y Der neue y-Wert.
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector set( double x, double y ) {
 		this.x = x;
 		this.y = y;
@@ -210,6 +212,7 @@ public class Vector extends Point2D.Double {
 	 * @param vector Ein Vektor.
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector set( Vector vector ) {
 		x = vector.x;
 		y = vector.y;
@@ -223,6 +226,7 @@ public class Vector extends Point2D.Double {
 	 * @param pPunkt Ein Punkt.
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector set( Point2D pPunkt ) {
 		x = pPunkt.getX();
 		x = pPunkt.getY();
@@ -271,6 +275,7 @@ public class Vector extends Point2D.Double {
 
 	/**
 	 * Legt die Länge des Vektors fest.
+	 *
 	 * @param length Die neue Länge des Vektors.
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
@@ -294,9 +299,9 @@ public class Vector extends Point2D.Double {
 	}
 
 	/**
-	 *
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector normalize() {
 		double len = length();
 		if( len != 0 && len != 1 ) {
@@ -308,9 +313,11 @@ public class Vector extends Point2D.Double {
 
 	/**
 	 * Addiert den Vektor {@code vector} zu diesem.
+	 *
 	 * @param vector Ein anderer Vektor.
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector add( Vector vector ) {
 		x += vector.x;
 		y += vector.y;
@@ -319,10 +326,12 @@ public class Vector extends Point2D.Double {
 
 	/**
 	 * Addiert die angegebenen Werte zur x- und y-Komponente des Vektors.
+	 *
 	 * @param x Summand x-Komponente.
 	 * @param y Summand y-Komponente.
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector add( double x, double y ) {
 		this.x += x;
 		this.y += y;
@@ -342,24 +351,28 @@ public class Vector extends Point2D.Double {
 		return vec;
 	}
 
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector sub( Vector vector ) {
 		x -= vector.x;
 		y -= vector.y;
 		return this;
 	}
 
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector sub( double x, double y ) {
 		this.x -= x;
 		this.y -= y;
 		return this;
 	}
 
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector scale( double scalar ) {
 		x *= scalar;
 		y *= scalar;
 		return this;
 	}
 
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector div( double scalar ) {
 		if( scalar == 0.0 ) {
 			throw new IllegalArgumentException("Can't divide by zero.");
@@ -409,8 +422,8 @@ public class Vector extends Point2D.Double {
 	 * dem quadrierten Abstand durchführen, wenn auch die gewünschte Entfernung
 	 * quadriert wird.
 	 *
-	 * @param vector
-	 * @return
+	 * @param vector Ein anderer Vektor.
+	 * @return Das Quadrat der Entfernung zum anderen Vektor.
 	 */
 	public double distanceSq( Vector vector ) {
 		return super.distanceSq(vector);
@@ -487,6 +500,7 @@ public class Vector extends Point2D.Double {
 	 * @return Dieser Vektor selbst (method chaining)
 	 * @see #setLength(double)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector limit( double max ) {
 		if( lengthSq() > max * max ) {
 			setLength(max);
@@ -503,6 +517,7 @@ public class Vector extends Point2D.Double {
 	 * @return Dieser Vektor selbst (method chaining)
 	 * @see #setLength(double)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector limit( double min, double max ) {
 		if( min > max ) {
 			double t = min;
@@ -556,6 +571,7 @@ public class Vector extends Point2D.Double {
 	 * @return Dieser Vektor selbst (method chaining)
 	 * @see #rotate(double)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector rotateRad( double rad ) {
 		double temp = x;
 		x = x * Math.cos(rad) - y * Math.sin(rad);
@@ -587,6 +603,7 @@ public class Vector extends Point2D.Double {
 	 * @param t Ein Wert zwischen 0 und 1.
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector morph( Vector vector, double t ) {
 		double tt = Math.min(Math.max(t, 0.0), 1.0);
 		x = x + (vector.x - x) * tt;
@@ -631,6 +648,7 @@ public class Vector extends Point2D.Double {
 	 * @param t Ein Wert zwischen 0 und 1.
 	 * @return Dieser Vektor selbst (method chaining)
 	 */
+	@SuppressWarnings( "UnusedReturnValue" )
 	public Vector interpolate( Vector vector, double t ) {
 		x = x + (vector.x - x) * t;
 		y = y + (vector.y - y) * t;

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

@@ -9,7 +9,6 @@ import java.awt.*;
 import java.awt.event.KeyAdapter;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
-import java.io.File;
 import java.io.IOException;
 import java.net.URL;
 import java.util.ArrayList;
@@ -24,6 +23,12 @@ import java.util.ArrayList;
  */
 public class Zeichenfenster extends JFrame {
 
+	/**
+	 * Setzt das Look and Feel auf den Standard des Systems.
+	 * <p>
+	 * Sollte einmalig vor erstellen des erstyen Programmfensters aufgerufen
+	 * werden.
+	 */
 	public static final void setLookAndFeel() {
 		try {
 			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
@@ -32,6 +37,17 @@ public class Zeichenfenster extends JFrame {
 		}
 	}
 
+	/**
+	 * Ermittelt ein {@link GraphicsDevice Anzeigegerät}, auf dem ein neues
+	 * Zeichenfenster angezeigt werden soll. In der Regel ist dies der
+	 * Bildschirm, auf dem sich derzeit der Mauszeiger befindet. Kann kein
+	 * solcher Bildschirm ermittelt werden, wird das
+	 * {@link GraphicsEnvironment#getDefaultScreenDevice() Standardgerät}
+	 * zurückgegeben.
+	 *
+	 * @return Das Anzeigegerät, auf dem ein neues Fenster angezeigt werden
+	 * 	sollte.
+	 */
 	public static final GraphicsDevice getGraphicsDevice() {
 		// Wir suchen den Bildschirm, der derzeit den Mauszeiger enthält, um
 		// das Zeichenfenster dort zu zentrieren.
@@ -54,14 +70,14 @@ public class Zeichenfenster extends JFrame {
 	}
 
 	/**
-	 * Das Anzeigefenster, auf dem die ZM gestartet wurde (muss nicht gleich dem
-	 * Aktuellen sein, wenn das Fenster verschoben wurde).
+	 * Das Anzeigegerät, auf dem die Zeichenmaschine gestartet wurde (muss nicht
+	 * gleich dem Aktuellen sein, wenn das Fenster verschoben wurde).
 	 */
-	private GraphicsDevice displayDevice;
+	private final GraphicsDevice displayDevice;
 
 	/**
-	 * Bevorzugte Abmessungen der Zeichenleinwand. Für das Zeichenfenster hat
-	 * es Priorität die Leinwand auf dieser Größe zu halten. Gegebenenfalls unter
+	 * Bevorzugte Abmessungen der Zeichenleinwand. Für das Zeichenfenster hat es
+	 * Priorität die Leinwand auf dieser Größe zu halten. Gegebenenfalls unter
 	 * Missachtung anderer Größenvorgaben. Allerdings kann das Fenster keine
 	 * Garantie für die Größe der Leinwand übernehmen.
 	 */
@@ -78,30 +94,67 @@ public class Zeichenfenster extends JFrame {
 	 * verlassen. Wird von {@link #setFullscreen(boolean)} automatisch
 	 * hinzugefügt und entfernt.
 	 */
-	private KeyListener fullscreenExitListener = new KeyAdapter() {
+	private final KeyListener fullscreenExitListener = new KeyAdapter() {
 		@Override
 		public void keyPressed( KeyEvent e ) {
 			if( e.getKeyCode() == KeyEvent.VK_ESCAPE ) {
 				// canvas.removeKeyListener(this);
 				setFullscreen(false);
+				e.consume();
 			}
 		}
 	};
 
-	private Zeichenleinwand canvas;
+	// Die Zeichenleinwand dieses Fensters.
+	private final Zeichenleinwand canvas;
 
+	/**
+	 * Erstellt ein neues Zeichenfenster mit dem angegebenen Titel und einer
+	 * {@link Zeichenleinwand} in der angegebenen Größe.
+	 *
+	 * @param width Die Breite der Zeichenleinwand.
+	 * @param height Die Höhe der Zeichenleinwand.
+	 * @param title Der Titel des Fensters.
+	 */
+	@SuppressWarnings( "unused" )
 	public Zeichenfenster( int width, int height, String title ) {
 		this(new Zeichenleinwand(width, height), title, getGraphicsDevice());
 	}
 
+	/**
+	 * Erstellt ein neues Zeichenfenster mit dem angegebenen Titel und einer
+	 * {@link Zeichenleinwand} in der angegebenen Größe auf dem angegebenen
+	 * Anzeigegerät.
+	 *
+	 * @param width Die Breite der Zeichenleinwand.
+	 * @param height Die Höhe der Zeichenleinwand.
+	 * @param title Der Titel des Fensters.
+	 * @param displayDevice Das Anzeigegerät für das Fenster.
+	 */
+	@SuppressWarnings( "unused" )
 	public Zeichenfenster( int width, int height, String title, GraphicsDevice displayDevice ) {
 		this(new Zeichenleinwand(width, height), title, displayDevice);
 	}
 
+	/**
+	 * Erstellt ein neues Zeichenfenster mit dem angegebenen Titel und der
+	 * angegebene {@link Zeichenleinwand}.
+	 *
+	 * @param canvas Die Zeichenleinwand.
+	 * @param title Der Titel des Fensters.
+	 */
 	public Zeichenfenster( Zeichenleinwand canvas, String title ) {
 		this(canvas, title, getGraphicsDevice());
 	}
 
+	/**
+	 * Erstellt ein neues Zeichenfenster mit dem angegebenen Titel und der
+	 * angegebene {@link Zeichenleinwand} auf dem angegebenen Anzeigegerät.
+	 *
+	 * @param canvas Die Zeichenleinwand.
+	 * @param title Der Titel des Fensters.
+	 * @param displayDevice Das Anzeigegerät für das Fenster.
+	 */
 	public Zeichenfenster( Zeichenleinwand canvas, String title, GraphicsDevice displayDevice ) {
 		super(Validator.requireNotNull(displayDevice).getDefaultConfiguration());
 		this.displayDevice = displayDevice;
@@ -110,12 +163,11 @@ public class Zeichenfenster extends JFrame {
 
 		this.canvasPreferredWidth = canvas.getWidth();
 		this.canvasPreferredHeight = canvas.getHeight();
-		//this.add(canvas, BorderLayout.CENTER);
-		this.add(canvas);
+		this.add(canvas, BorderLayout.CENTER);
 		this.canvas = canvas;
 
 		// Konfiguration des Frames
-		this.setTitle(title == null ? "Zeichenfenster " + Constants.APP_VERSION: title);
+		this.setTitle(title == null ? "Zeichenfenster " + Constants.APP_VERSION : title);
 		// Kann vom Aufrufenden überschrieben werden
 		this.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
 
@@ -123,14 +175,19 @@ public class Zeichenfenster extends JFrame {
 		try {
 			if( Zeichenmaschine.MACOS ) {
 				URL iconUrl = Zeichenmaschine.class.getResource("icon_512.png");
+				if( iconUrl != null ) {
 					Image icon = ImageIO.read(iconUrl);
 					// Dock Icon in macOS setzen
 					Taskbar taskbar = Taskbar.getTaskbar();
 					taskbar.setIconImage(icon);
+				}
 			} else {
 				ArrayList<Image> icons = new ArrayList<>(4);
-				for( int size = 32; size <= 512; size *= size ) {
-					icons.add(ImageIO.read(new File("icon_" + size + ".png")));
+				for( int size : new int[]{32, 64, 128, 512} ) {
+					URL icnUrl = Zeichenmaschine.class.getResource("icon_" + size + ".png");
+					if( icnUrl != null ) {
+						icons.add(ImageIO.read(icnUrl));
+					}
 				}
 
 				this.setIconImages(icons);
@@ -144,25 +201,54 @@ public class Zeichenfenster extends JFrame {
 		// Fenster zusammenbauen, auf dem Bildschirm positionieren ...
 		this.pack();
 		this.setResizable(false);
+		this.setFocusable(true);
 		this.setLocationByPlatform(true);
 		// this.centerFrame();
 	}
 
+	/**
+	 * Liefert das Anzeigegerät, auf dem dieses Fenster erstellt wurde.
+	 * <p>
+	 * Das Anzeigegerät muss nicht unbedingt gleich dem sein, auf dem sich das
+	 * Fenster derzeit befindet, wenn das Fenster verschoben wurde.
+	 *
+	 * @return Das Anzeigegerät.
+	 */
+	@SuppressWarnings( "unused" )
 	public GraphicsDevice getDisplayDevice() {
 		return displayDevice;
 	}
 
+	/**
+	 * Liefert die Abmessungen des Anzeigegeräts, auf dem das Fenster gestartet
+	 * wurde.
+	 *
+	 * @return Die Abmessungen des Anzeigegeräts.
+	 */
 	public Rectangle getScreenBounds() {
+		// return GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds();
 		return displayDevice.getDefaultConfiguration().getBounds();
 	}
 
+	/**
+	 * Liefert die Zeichenleinwand dieses Fensters.
+	 *
+	 * @return Die Zeichenleinwand.
+	 */
+	@SuppressWarnings( "unused" )
 	public Zeichenleinwand getCanvas() {
 		return canvas;
 	}
 
+	/**
+	 * Liefert die Abmessungen der Zeichenleinwand zurück.
+	 *
+	 * @return Die Abmessungen der Zeichenleinwand.
+	 */
 	public Rectangle getCanvasBounds() {
 		return canvas.getBounds();
 	}
+
 	/**
 	 * Zentriert das Zeichenfenster auf dem aktuellen Bildschirm.
 	 */
@@ -175,8 +261,14 @@ public class Zeichenfenster extends JFrame {
 		);
 	}
 
+	/**
+	 * Setzt die Größe der Zeichenleinwand auf die angegebenen Werte.
+	 *
+	 * @param newWidth Neue Breite der Zeichenleinwand.
+	 * @param newHeight Neue Höhe der Zeichenleinwand.
+	 */
 	public void setCanvasSize( int newWidth, int newHeight ) {
-		// TODO: (ngb) Put constains on max/min frame/canvas size
+		// TODO: (ngb) Put constrains on max/min frame/canvas size
 		if( fullscreen ) {
 			canvasPreferredWidth = newWidth;
 			canvasPreferredHeight = newHeight;
@@ -205,30 +297,62 @@ public class Zeichenfenster extends JFrame {
 	public final void setFullscreen( boolean pEnable ) {
 		// See https://docs.oracle.com/javase/tutorial/extra/fullscreen/index.html
 		if( displayDevice.isFullScreenSupported() ) {
+			// Temporarily stop rendering
+			while( canvas.isRendering() ) {
+				try {
+					canvas.suspendRendering();
+				} catch( InterruptedException ex ) {
+					LOG.info(ex, "setFullsceen(true) was interrupted and canceled.");
+					return;
+				}
+			}
+
 			if( pEnable && !fullscreen ) {
-				// frame.setUndecorated(true);
-				this.setResizable(false); // Should be set anyway
+				// Activate fullscreen
+				dispose();
+				setUndecorated(true);
+				setResizable(false);
 				displayDevice.setFullScreenWindow(this);
 
-				java.awt.Rectangle bounds = getScreenBounds();
-				// TODO: (ngb) We need to switch layouts to allow the LayoutManger to maximize the canvas
-				canvas.setSize(bounds.width, bounds.height);
 				// Register ESC to exit fullscreen
 				canvas.addKeyListener(fullscreenExitListener);
 
+				// Reset canvas size to its new bounds to recreate buffer and drawing surface
+				java.awt.Rectangle canvasBounds = getCanvasBounds();
+				canvas.setSize(canvasBounds.width, canvasBounds.height);
+				//canvas.requestFocus();
+				canvas.requestFocus();
+
 				fullscreen = true;
 			} else if( !pEnable && fullscreen ) {
-				fullscreen = false;
+				displayDevice.setFullScreenWindow(null);
+				dispose();
+				setUndecorated(false);
+				setResizable(false);
 
 				canvas.removeKeyListener(fullscreenExitListener);
-				displayDevice.setFullScreenWindow(null);
 				canvas.setSize(canvasPreferredWidth, canvasPreferredHeight);
-				this.pack();
-				// frame.setUndecorated(false);
+
+				setVisible(true);
+				pack();
+
+				//canvas.requestFocus();
+				canvas.requestFocus();
+
+				fullscreen = false;
 			}
+
+			// Resume rendering
+			canvas.resumeRendering();
 		}
 	}
 
+	/**
+	 * Prüft, ob sich dieses Zeichenfenster im Vollbild befindet.
+	 *
+	 * @return {@code true}, wenn das Fenster im Vollbild ist, {@code false}
+	 * 	sonst.
+	 */
 	public boolean isFullscreen() {
 		Window win = displayDevice.getFullScreenWindow();
 		return fullscreen && win.equals(this);

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

@@ -1,16 +1,16 @@
 package schule.ngb.zm;
 
-import schule.ngb.zm.layers.ColorLayer;
-import schule.ngb.zm.layers.ShapesLayer;
 import schule.ngb.zm.util.Log;
 
-import java.awt.*;
+import java.awt.Canvas;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Toolkit;
 import java.awt.image.BufferStrategy;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
 
 /**
  * Eine Leinwand ist die Hauptkomponente einer Zeichenmaschine. Sie besteht aus
@@ -24,10 +24,14 @@ import java.util.concurrent.LinkedBlockingQueue;
  */
 public class Zeichenleinwand extends Canvas {
 
-	/**
-	 * Liste der hinzugefügten Ebenen.
-	 */
-	private LinkedList<Layer> layers;
+	// Lokales Lock für Rendervorgänge.
+	private final Object[] renderLock = new Object[0];
+
+	// Liste der hinzugefügten Ebenen.
+	private final List<Layer> layers;
+
+	// Status der Zeichenleinwand.
+	private boolean rendering = false, suspended = false;
 
 	/**
 	 * Erstellt eine neue Zeichenleinwand mit einer festen Größe.
@@ -41,11 +45,49 @@ public class Zeichenleinwand extends Canvas {
 		this.setMinimumSize(getSize());
 		this.setBackground(Constants.DEFAULT_BACKGROUND.getJavaColor());
 
-		// Liste der Ebenen initialisieren und die Standardebenen einfügen
-		layers = new LinkedList<>();
-		synchronized( layers ) {
-			layers.add(new ColorLayer(width, height, Constants.DEFAULT_BACKGROUND));
+		layers = Collections.synchronizedList(new LinkedList<>());
 	}
+
+	/**
+	 * Ob die Leinwand ihren Inhalt gerade zeichnet.
+	 *
+	 * @return {@code true}, wenn die Inhalte gerade gezeichnet werden.
+	 */
+	public boolean isRendering() {
+		return rendering;
+	}
+
+	/**
+	 * Pausiert das Zeichnen der Leinwand kurzzeitig.
+	 * <p>
+	 * Falls die Leinwand gerade beim Zeichnen ist
+	 * ({@code isRendering() == true}, blockt die Methode den aufrufenden Thread
+	 * so lange, bis das Rendern beendet ist. Danach wird die Ebene nicht mehr
+	 * neu gezeichnet, bis {@link #resumeRendering()} aufgerufen wird.
+	 * <p>
+	 * Das Zeichnen sollte nur dann unterbrochen werden, wenn sich der Kontext
+	 * der Canvas-Komponente in seinem Elterncontainer ändert, um Fehler bei
+	 * einer fehlenden Container-Hierarchie zu vermeiden.
+	 *
+	 * @throws InterruptedException Falls der Thread beim Warten unterbrochen
+	 *                              wird.
+	 */
+	public void suspendRendering() throws InterruptedException {
+		synchronized( renderLock ) {
+			if( isRendering() ) {
+				renderLock.wait();
+			}
+
+			suspended = true;
+		}
+	}
+
+	/**
+	 * Setzt das Zeichnen der Leinwand fort, falls es zuvor mit
+	 * {@link #suspendRendering()} ausgesetzt wurde.
+	 */
+	public void resumeRendering() {
+		suspended = false;
 	}
 
 	/**
@@ -78,26 +120,23 @@ public class Zeichenleinwand extends Canvas {
 	 */
 	public void addLayer( Layer layer ) {
 		if( layer != null ) {
-			synchronized( layers ) {
 			layer.setSize(getWidth(), getHeight());
 			layers.add(layer);
 		}
 	}
-	}
 
 	/**
 	 * Fügt der Zeichenleinwand eine Ebene an einem bestimmten Index hinzu. Wenn
 	 * der Index noch nicht existiert (also größer als die
-	 * {@link #getLayerCount() Anzahl der Ebenen} ist, dann wird die neue Ebene
+	 * {@link #getLayerCount() Anzahl der Ebenen} ist), dann wird die neue Ebene
 	 * als letzte eingefügt. Die aufrufende Methode kann also nicht sicher sein,
 	 * dass die neue Ebene am Ende wirklich am Index {@code i} steht.
 	 *
-	 * @param i Index der Ebene, beginnend mit 0.
+	 * @param i Index der Ebene beginnend mit 0.
 	 * @param layer Die neue Ebene.
 	 */
 	public void addLayer( int i, Layer layer ) {
 		if( layer != null ) {
-			synchronized( layers ) {
 			layer.setSize(getWidth(), getHeight());
 			if( i > layers.size() ) {
 				layers.add(layer);
@@ -106,7 +145,6 @@ public class Zeichenleinwand extends Canvas {
 			}
 		}
 	}
-	}
 
 	/**
 	 * Gibt die Anzahl der {@link Layer Ebenen} in dieser Leinwand zurück.
@@ -118,19 +156,19 @@ public class Zeichenleinwand extends Canvas {
 	}
 
 	/**
-	 * Gibt die Liste der bisher hinzugefügten Ebenen zurück.
+	 * Gibt eine Kopie der Liste der bisher hinzugefügten Ebenen zurück.
 	 *
 	 * @return Liste der Ebenen.
 	 */
-	public java.util.List<Layer> getLayers() {
-		return layers;
+	public List<Layer> getLayers() {
+		return List.copyOf(layers);
 	}
 
 	/**
-	 * Holt die Ebene am Index <var>i</var> (beginnend bei 0).
+	 * Holt die Ebene am Index {@code i} (beginnend bei 0).
 	 *
 	 * @param i Index der Ebene (beginnend bei 0).
-	 * @return Die Ebene am Index <var>i</var> oder {@code null}.
+	 * @return Die Ebene am Index {@code i} oder {@code null}.
 	 * @throws IndexOutOfBoundsException Falls der Index nicht existiert.
 	 */
 	public Layer getLayer( int i ) {
@@ -145,14 +183,16 @@ public class Zeichenleinwand extends Canvas {
 	 * Sucht die erste Ebene des angegebenen Typs aus der Liste der Ebenen.
 	 * Existiert keine solche Ebene, wird {@code null} zurückgegeben.
 	 *
-	 * @param clazz Typ der Ebene.
-	 * @param <L>
+	 * @param type Klasse der Ebenen, die abgefragt werden.
+	 * @param <L> Typ der Ebenen, die abgefragt werden.
 	 * @return Erste Ebene vom angegeben Typ.
 	 */
-	public <L extends Layer> L getLayer( Class<L> clazz ) {
+	public <L extends Layer> L getLayer( Class<L> type ) {
+		synchronized( layers ) {
 			for( Layer layer : layers ) {
-			if( layer.getClass().equals(clazz) ) {
-				return clazz.cast(layer);
+				if( layer.getClass().equals(type) ) {
+					return type.cast(layer);
+				}
 			}
 		}
 		return null;
@@ -163,44 +203,67 @@ public class Zeichenleinwand extends Canvas {
 	 * gibt diese als Liste zurück. Die Reihenfolge in der Liste entspricht der
 	 * Reihenfolge der Ebenen in der Leinwand (von unten nach oben).
 	 *
-	 * @param pClazz
-	 * @param <L>
-	 * @return
+	 * @param type Klasse der Ebenen, die abgefragt werden.
+	 * @param <L> Typ der Ebenen, die abgefragt werden.
+	 * @return Eine Liste mit den vorhandenen Ebenen des abgefragten Typs.
 	 */
-	public <L extends Layer> java.util.List<L> getLayers( Class<L> pClazz ) {
+	@SuppressWarnings( "unused" )
+	public <L extends Layer> List<L> getLayers( Class<L> type ) {
 		ArrayList<L> result = new ArrayList<>(layers.size());
+		synchronized( layers ) {
 			for( Layer layer : layers ) {
-			if( layer.getClass().equals(pClazz) ) {
-				result.add(pClazz.cast(layer));
+				if( layer.getClass().equals(type) ) {
+					result.add(type.cast(layer));
+				}
 			}
 		}
 		return result;
 	}
 
+	/**
+	 * Entfernt die angegebene Ebene von dieser Zeichenleinwand.
+	 *
+	 * @param pLayer Die Ebene, die entfernt werden soll.
+	 * @return {@code true}, wenn die Liste vorhanden war und entfernt wurde,
+	 *    {@code false} sonst.
+	 */
+	@SuppressWarnings( "unused" )
 	public boolean removeLayer( Layer pLayer ) {
-		synchronized( layers ) {
 		return layers.remove(pLayer);
 	}
-	}
 
-	public void removeLayers( Layer... pLayers ) {
+	/**
+	 * Entfernt alle angegebenen Ebenen von dieser Zeichenleinwand.
+	 *
+	 * @param removeLayers Die Ebenen, die entfernt werden sollen.
+	 */
+	@SuppressWarnings( "unused" )
+	public void removeLayers( Layer... removeLayers ) {
 		synchronized( layers ) {
-			for( Layer layer : pLayers ) {
+			for( Layer layer : removeLayers ) {
 				layers.remove(layer);
 			}
 		}
 	}
 
+	/**
+	 * Entfernt alle vorhandenen Ebenen von dieser Zeichenleinwand.
+	 */
+	@SuppressWarnings( "unused" )
 	public void clearLayers() {
-		synchronized( layers ) {
 		layers.clear();
 	}
-	}
 
+	/**
+	 * Aktualisiert alle {@link Layer Ebenen}, die dieser Zeichenleinwand
+	 * hinzugefügt wurden.
+	 *
+	 * @param delta Die Zeit seit dem letzten Aufruf in Sekunden.
+	 * @see Layer#update(double)
+	 */
 	public void updateLayers( double delta ) {
 		synchronized( layers ) {
-			List<Layer> it = List.copyOf(layers);
-			for( Layer layer : it ) {
+			for( Layer layer : List.copyOf(layers) ) {
 				layer.update(delta);
 			}
 		}
@@ -230,15 +293,14 @@ public class Zeichenleinwand extends Canvas {
 	}
 
 	/**
-	 * Zeichnet den Inhalt aller {@link Layer Ebenen} in den Grafik-Kontext.
+	 * Zeichnet den Inhalt aller {@link Layer Ebenen} in den Grafikkontext.
 	 *
-	 * @param graphics
+	 * @param graphics Der Grafikkontext.
 	 */
 	public void draw( Graphics graphics ) {
 		Graphics2D g2d = (Graphics2D) graphics.create();
 		synchronized( layers ) {
-			List<Layer> it = List.copyOf(layers);
-			for( Layer layer : it ) {
+			for( Layer layer : layers ) {
 				layer.draw(g2d);
 			}
 		}
@@ -249,11 +311,13 @@ public class Zeichenleinwand extends Canvas {
 	 * Zeigt den aktuellen Inhalt der Zeichenleinwand an.
 	 */
 	public void render() {
+		if( !suspended && isDisplayable() ) {
 			if( getBufferStrategy() == null ) {
 				allocateBuffer();
 			}
 
-		if( isDisplayable() ) {
+			synchronized( renderLock ) {
+				rendering = true;
 				BufferStrategy strategy = this.getBufferStrategy();
 				if( strategy != null ) {
 					do {
@@ -262,8 +326,7 @@ public class Zeichenleinwand extends Canvas {
 							g2d.clearRect(0, 0, getWidth(), getHeight());
 
 							synchronized( layers ) {
-							List<Layer> it = List.copyOf(layers);
-							for( Layer layer : it ) {
+								for( Layer layer : List.copyOf(layers) ) {
 									layer.draw(g2d);
 								}
 							}
@@ -281,6 +344,9 @@ public class Zeichenleinwand extends Canvas {
 						// Repeat the rendering if the drawing buffer was lost
 					} while( strategy.contentsLost() );
 				}
+				rendering = false;
+				renderLock.notifyAll();
+			}
 		}
 	}
 

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

@@ -17,6 +17,7 @@ import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * Hauptklasse der Zeichenmaschine.
@@ -37,43 +38,6 @@ public class Zeichenmaschine extends Constants {
 		IN_BLUEJ = System.getProperty("java.class.path").contains("bluej");
 	}
 
-	/**
-	 * Gibt an, ob die Zeichenmaschine unter macOS gestartet wurde.
-	 */
-	public static final boolean MACOS;
-
-	/**
-	 * Gibt an, ob die Zeichenmaschine unter Windows gestartet wurde.
-	 */
-	public static final boolean WINDOWS;
-
-	/**
-	 * Gibt an, ob die Zeichenmaschine unter Linux gestartet wurde.
-	 */
-	public static final boolean LINUX;
-
-	static {
-		final String name = System.getProperty("os.name");
-
-		if( name.contains("Mac") ) {
-			MACOS = true;
-			WINDOWS = false;
-			LINUX = false;
-		} else if( name.contains("Windows") ) {
-			MACOS = false;
-			WINDOWS = true;
-			LINUX = false;
-		} else if( name.equals("Linux") ) {  // true for the ibm vm
-			MACOS = false;
-			WINDOWS = false;
-			LINUX = true;
-		} else {
-			MACOS = false;
-			WINDOWS = false;
-			LINUX = false;
-		}
-	}
-
 	/*
 	 * Objektvariablen, die von Unterklassen benutzt werden können.
 	 */
@@ -111,14 +75,14 @@ public class Zeichenmaschine extends Constants {
 	/**
 	 * Das Zeichenfenster der Zeichenmaschine
 	 */
-	private Zeichenfenster frame;
+	protected Zeichenfenster frame;
 
 	// Aktueller Zustand der Zeichenmaschine.
 
 	/**
 	 * Zustand der Zeichenmaschine insgesamt
 	 */
-	private Options.AppState state = Options.AppState.INITIALIZING;
+	private Options.AppState state;
 
 	/**
 	 * Zustand des update/draw Threads
@@ -128,7 +92,7 @@ public class Zeichenmaschine extends Constants {
 	/**
 	 * Ob der Zeichenthread noch laufen soll, oder beendet.
 	 */
-	private boolean running = false;
+	private boolean running;
 
 	private boolean terminateImediately = false;
 
@@ -141,7 +105,7 @@ public class Zeichenmaschine extends Constants {
 	 * Ob die ZM bei nicht überschriebener update() Methode stoppen soll,
 	 * oder trotzdem weiterläuft.
 	 */
-	private boolean run_once = true;
+	private final boolean run_once;
 
 	/**
 	 * Aktuelle Frames pro Sekunde der Zeichenmaschine.
@@ -151,17 +115,17 @@ public class Zeichenmaschine extends Constants {
 	/**
 	 * Hauptthread der Zeichenmaschine.
 	 */
-	private Thread mainThread;
+	private final Thread mainThread;
 
 	/**
 	 * Queue für geplante Aufgaben
 	 */
-	private DelayQueue<DelayedTask> taskQueue = new DelayQueue<>();
+	private final DelayQueue<DelayedTask> taskQueue = new DelayQueue<>();
 
 	/**
 	 * Queue für abgefangene InputEvents
 	 */
-	private BlockingQueue<InputEvent> eventQueue = new LinkedBlockingQueue<>();
+	private final BlockingQueue<InputEvent> eventQueue = new LinkedBlockingQueue<>();
 
 	/**
 	 * Gibt an, ob nach Ende des Hauptthreads das Programm beendet werden soll,
@@ -274,9 +238,15 @@ public class Zeichenmaschine extends Constants {
 	 * @param run_once {@code true} beendet die Zeichenmaschine nach einem
 	 * 	Aufruf von {@code draw()}.
 	 */
+	@SuppressWarnings("static-access")
 	public Zeichenmaschine( int width, int height, String title, boolean run_once ) {
 		LOG.info("Starting " + APP_NAME + " " + APP_VERSION);
 
+		// Register Cmd+Q on macOS
+		if( Constants.MACOS ) {
+			System.setProperty("apple.eawt.quitStrategy", "CLOSE_ALL_WINDOWS");
+		}
+
 		// Erstellen der Leinwand
 		canvas = new Zeichenleinwand(width, height);
 
@@ -312,8 +282,15 @@ public class Zeichenmaschine extends Constants {
 		canvas.addMouseWheelListener(inputListener);
 		canvas.addKeyListener(inputListener);
 
+		/*KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(new KeyEventDispatcher() {
+			@Override
+			public boolean dispatchKeyEvent( KeyEvent e ) {
+				enqueueEvent(e);
+				return false;
+			}
+		});*/
+
 		// Programm beenden, wenn Fenster geschlossen wird
-		// TODO: (ngb) Der Listener hat zu viel FUnktionalität -> nach quit() / exit() auslagern
 		frame.addWindowListener(new WindowAdapter() {
 			@Override
 			public void windowClosing( WindowEvent e ) {
@@ -350,17 +327,15 @@ public class Zeichenmaschine extends Constants {
 	 *
 	 * @param title
 	 */
-	private final Zeichenfenster createFrame( Zeichenleinwand c, String title ) {
+	private Zeichenfenster createFrame( Zeichenleinwand c, String title ) {
 		while( frame == null ) {
 			try {
-				TaskRunner.invokeLater(new Runnable() {
-					@Override
-					public void run() {
+				TaskRunner.invokeLater(() -> {
 					Zeichenfenster.setLookAndFeel();
 					frame = new Zeichenfenster(canvas, title);
-					}
 				}).get();
 			} catch( InterruptedException e ) {
+				// Keep waiting
 			} catch( ExecutionException e ) {
 				LOG.error(e, "Error initializing application frame: %s", e.getMessage());
 				throw new RuntimeException(e);
@@ -392,10 +367,18 @@ public class Zeichenmaschine extends Constants {
 	public final void setFullscreen( boolean pEnable ) {
 		if( pEnable && !frame.isFullscreen() ) {
 			frame.setFullscreen(true);
+
+			canvasWidth = canvas.getWidth();
+			canvasHeight = canvas.getHeight();
+
 			if( frame.isFullscreen() )
 				fullscreenChanged();
 		} else if( !pEnable && frame.isFullscreen() ) {
 			frame.setFullscreen(false);
+
+			canvasWidth = canvas.getWidth();
+			canvasHeight = canvas.getHeight();
+
 			if( !frame.isFullscreen() )
 				fullscreenChanged();
 		}
@@ -444,9 +427,18 @@ public class Zeichenmaschine extends Constants {
 	 * im Zeichenfenster an.
 	 */
 	public final void redraw() {
-		if( state == Options.AppState.PAUSED ) {
+		if( state == Options.AppState.PAUSED
+			|| state == Options.AppState.TERMINATED ) {
 			draw();
 		}
+		render();
+	}
+
+	/**
+	 * Zeigt den aktuellen Inhalt der {@link Zeichenleinwand}
+	 * im Zeichenfenster an, ohne vorher {@link #draw()} aufzurufen.
+	 */
+	public final void render() {
 		canvas.render();
 		// canvas.invalidate();
 		// frame.repaint();
@@ -546,6 +538,11 @@ public class Zeichenmaschine extends Constants {
 	}
 
 	public final void exitNow() {
+		// Do nothing, when already quitting
+		if( state == Options.AppState.QUITING ) {
+			return;
+		}
+
 		if( running ) {
 			running = false;
 			terminateImediately = true;
@@ -584,6 +581,8 @@ public class Zeichenmaschine extends Constants {
 	 * @see System#exit(int)
 	 */
 	public final void quit( boolean exit ) {
+		state = Options.AppState.QUITING;
+		TaskRunner.invokeLater(() -> {
 			frame.setVisible(false);
 			canvas.dispose();
 			frame.dispose();
@@ -591,6 +590,7 @@ public class Zeichenmaschine extends Constants {
 			if( exit ) {
 				System.exit(0);
 			}
+		});
 	}
 
 	/**
@@ -601,11 +601,11 @@ public class Zeichenmaschine extends Constants {
 	 * @see Zeichenleinwand#setSize(int, int)
 	 */
 	public final void setSize( int width, int height ) {
-		frame.setSize(width, height);
+		frame.setCanvasSize(width, height);
 
 		java.awt.Rectangle canvasBounds = frame.getCanvasBounds();
-		canvasWidth = (int) canvasBounds.getWidth();
-		canvasHeight = (int) canvasBounds.getHeight();
+		canvasWidth = canvasBounds.width;
+		canvasHeight = canvasBounds.height;
 	}
 
 	/**
@@ -679,9 +679,9 @@ public class Zeichenmaschine extends Constants {
 	 * Gibt die erste (unterste) {@link Layer Ebene} der angegebenen Klasse
 	 * zurück.
 	 *
-	 * <pre>
+	 * <pre><code>
 	 * DrawingLayer draw = getLayer(DrawingLayer.class);
-	 * </pre>
+	 * </code></pre>
 	 *
 	 * @param layerClass
 	 * @param <LT>
@@ -947,9 +947,9 @@ public class Zeichenmaschine extends Constants {
 	 * <p>
 	 * Die Konstanten der Klasse {@link Cursor} definieren 13 Standardzeiger,
 	 * die durch angabe der Nummer geladen werden können.
-	 * <pre>
+	 * <pre><code>
 	 * setCursor(Cursor.HAND_CURSOR);
-	 * </pre>
+	 * </code></pre>
 	 *
 	 * @param pPredefinedCursor Eine der Cursor-Konstanten.
 	 * @see Cursor
@@ -1022,9 +1022,9 @@ public class Zeichenmaschine extends Constants {
 	 * {@code delta} wird in Sekunden angegeben. Um eine Form zum Beispiel um
 	 * {@code 50} Pixel pro Sekunde in {@code x}-Richtung zu bewegen, kann so
 	 * vorgegangen werden:
-	 * <pre>
+	 * <pre><code>
 	 * shape.move(50*delta, 0.0);
-	 * </pre>
+	 * </code></pre>
 	 *
 	 * @param delta
 	 */
@@ -1100,6 +1100,9 @@ public class Zeichenmaschine extends Constants {
 		}
 
 		if( isPaused() || isTerminated() ) {
+			if( MouseEvent.class.isInstance(evt) ) {
+				saveMousePosition((MouseEvent)evt);
+			}
 			dispatchEvents();
 		}
 	}
@@ -1327,7 +1330,7 @@ public class Zeichenmaschine extends Constants {
 			long overslept = 0L;
 			// Interne Zähler für tick und runtime
 			int _tick = 0;
-			long _runtime = 0;
+			long _runtime;
 			// Öffentliche Zähler für Unterklassen
 			tick = 0;
 			runtime = 0;
@@ -1390,7 +1393,7 @@ public class Zeichenmaschine extends Constants {
 					}
 
 					// Display the current buffer content
-					if( canvas != null ) {
+					if( canvas != null && frame.isDisplayable() ) {
 						canvas.render();
 						// canvas.invalidate();
 						// frame.repaint();
@@ -1444,7 +1447,11 @@ public class Zeichenmaschine extends Constants {
 				Thread.yield();
 			}
 			updateThreadExecutor.shutdownNow();
+			try {
+				updateThreadExecutor.awaitTermination(500, TimeUnit.MILLISECONDS);
+			} catch( InterruptedException ex ) {
 
+			} finally {
 				// Cleanup
 				shutdown();
 				cleanup();
@@ -1454,11 +1461,12 @@ public class Zeichenmaschine extends Constants {
 					quit();
 				}
 			}
+		}
 
 	}
 
 	// TODO: Remove
-	class DelayedTask implements Delayed {
+	static class DelayedTask implements Delayed {
 
 		long startTime; // in ms
 
@@ -1547,6 +1555,7 @@ public class Zeichenmaschine extends Constants {
 
 	}
 
+	// TODO: (ngb) exception handling when update/draw throws ex
 	class UpdateThreadExecutor extends ThreadPoolExecutor {
 
 		private Thread updateThread;
@@ -1555,7 +1564,18 @@ public class Zeichenmaschine extends Constants {
 
 		public UpdateThreadExecutor() {
 			super(1, 1, 0L,
-				TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
+				TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(),
+				new ThreadFactory() {
+					private final AtomicInteger threadNumber = new AtomicInteger(1);
+					@Override
+					public Thread newThread( Runnable r ) {
+						Thread t = new Thread(mainThread.getThreadGroup(), r,
+							"updateThread-" + threadNumber.getAndIncrement(),
+							0);
+						t.setDaemon(true);
+						return t;
+					}
+				});
 			updateState = Options.AppState.IDLE;
 		}
 

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

@@ -11,9 +11,13 @@ import java.awt.RadialGradientPaint;
 /**
  * Eine Ebene, die nur aus einer Farbe (oder einem Farbverlauf) besteht.
  * <p>
+ * Ein {@code ColorLayer} ist eine der drei Standardebenen der
+ * {@link schule.ngb.zm.Zeichenmaschine}.
+ * <p>
  * Die Farbe der Ebene kann beliebig gesetzt werden und kann gut als
- * Hintergundfarbe für eine Szene dienen, oder als halbtransparente "Abdeckung",
- * wenn ein {@code ColorLayer} über den anderen Ebenen eingefügt wird.
+ * Hintergrundfarbe für eine Szene dienen, oder als halbtransparente
+ * "Abdeckung", wenn ein {@code ColorLayer} über den anderen Ebenen eingefügt
+ * wird.
  */
 @SuppressWarnings( "unused" )
 public class ColorLayer extends Layer {
@@ -53,9 +57,6 @@ public class ColorLayer extends Layer {
 		clear();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void setSize( int width, int height ) {
 		super.setSize(width, height);
@@ -63,16 +64,14 @@ public class ColorLayer extends Layer {
 	}
 
 	/**
-	 * Gibt die Hintergrundfarbe der Ebene zurück.
-	 *
-	 * @return Die aktuelle Hintergrundfarbe.
+	 * @return Die aktuelle Hintergrundfarbe der Ebene.
 	 */
 	public Color getColor() {
 		return color;
 	}
 
 	/**
-	 * Setzt die Farbe der Ebene neu.
+	 * Setzt die Farbe der Ebene auf die angegebene Farbe.
 	 *
 	 * @param color Die neue Hintergrundfarbe.
 	 */
@@ -82,22 +81,69 @@ public class ColorLayer extends Layer {
 		clear();
 	}
 
+	/**
+	 * Setzt die Farbe der Ebene auf einen Grauwert mit der angegebenen
+	 * Intensität. 0 entspricht schwarz, 255 entspricht weiß.
+	 *
+	 * @param gray Ein Grauwert zwischen 0 und 255.
+	 * @see Color#Color(int)
+	 */
 	public void setColor( int gray ) {
 		setColor(gray, gray, gray, 255);
 	}
 
+	/**
+	 * Setzt die Farbe der Ebene auf einen Grauwert mit der angegebenen
+	 * Intensität und dem angegebenen Transparenzwert. Der Grauwert 0 entspricht
+	 * schwarz, 255 entspricht weiß.
+	 *
+	 * @param gray Ein Grauwert zwischen 0 und 255.
+	 * @param alpha Ein Transparenzwert zwischen 0 und 255.
+	 * @see Color#Color(int, int)
+	 */
 	public void setColor( int gray, int alpha ) {
 		setColor(gray, gray, gray, alpha);
 	}
 
+	/**
+	 * Setzt die Farbe der Ebene auf die Farbe mit den angegebenen Rot-, Grün-
+	 * und Blauanteilen.
+	 *
+	 * @param red Der Rotanteil der Farbe zwischen 0 und 255.
+	 * @param green Der Grünanteil der Farbe zwischen 0 und 255.
+	 * @param blue Der Blauanteil der Farbe zwischen 0 und 255.
+	 * @see Color#Color(int, int, int)
+	 * @see <a
+	 * 	href="https://de.wikipedia.org/wiki/RGB-Farbraum">https://de.wikipedia.org/wiki/RGB-Farbraum</a>
+	 */
 	public void setColor( int red, int green, int blue ) {
 		setColor(red, green, blue, 255);
 	}
 
+	/**
+	 * Setzt die Farbe der Ebene auf die Farbe mit den angegebenen Rot-, Grün-
+	 * und Blauanteilen und dem angegebenen Transparenzwert.
+	 *
+	 * @param red Der Rotanteil der Farbe zwischen 0 und 255.
+	 * @param green Der Grünanteil der Farbe zwischen 0 und 255.
+	 * @param blue Der Blauanteil der Farbe zwischen 0 und 255.
+	 * @param alpha Ein Transparenzwert zwischen 0 und 25
+	 * @see Color#Color(int, int, int, int)
+	 * @see <a
+	 * 	href="https://de.wikipedia.org/wiki/RGB-Farbraum">https://de.wikipedia.org/wiki/RGB-Farbraum</a>
+	 */
 	public void setColor( int red, int green, int blue, int alpha ) {
 		setColor(new Color(red, green, blue, alpha));
 	}
 
+	/**
+	 * Setzt die Füllung der Ebene auf einen linearen Farbverlauf, der in die
+	 * angegebene Richtung verläuft.
+	 *
+	 * @param from Farbe am Startpunkt.
+	 * @param to Farbe am Endpunkt.
+	 * @param dir Richtung des Farbverlaufs.
+	 */
 	public void setGradient( Color from, Color to, Options.Direction dir ) {
 		double halfW = getWidth() * .5;
 		double halfH = getHeight() * .5;
@@ -112,6 +158,18 @@ public class ColorLayer extends Layer {
 		setGradient(fromX, fromY, from, toX, toY, to);
 	}
 
+	/**
+	 * Setzt die Füllung der Ebene auf einen linearen Farbverlauf, der am Punkt
+	 * ({@code fromX}, {@code fromY}) mit der Farbe {@code from} startet und am
+	 * Punkt (({@code toX}, {@code toY}) mit der Farbe {@code to} endet.
+	 *
+	 * @param fromX x-Koordinate des Startpunktes.
+	 * @param fromY y-Koordinate des Startpunktes.
+	 * @param from Farbe am Startpunkt.
+	 * @param toX x-Koordinate des Endpunktes.
+	 * @param toY y-Koordinate des Endpunktes.
+	 * @param to Farbe am Endpunkt.
+	 */
 	public void setGradient( double fromX, double fromY, Color from, double toX, double toY, Color to ) {
 		this.color = from;
 		background = new GradientPaint(
@@ -121,10 +179,30 @@ public class ColorLayer extends Layer {
 		clear();
 	}
 
+	/**
+	 * Setzt die Füllung der Ebene auf einen kreisförmigen (radialen)
+	 * Farbverlauf, der im Zentrum beginnt.
+	 *
+	 * @param from Farbe im Zentrum.
+	 * @param to Farbe am Rand.
+	 */
 	public void setGradient( Color from, Color to ) {
 		setGradient(getWidth() * .5, getHeight() * .5, Math.min(getWidth() * .5, getHeight() * .5), from, to);
 	}
 
+	/**
+	 * Setzt die Füllung der Ebene auf einen kreisförmigen (radialen)
+	 * Farbverlauf, mit dem Zentrum im Punkt ({@code centerX}, {@code centerY})
+	 * und dem angegebenen Radius. Der Verlauf starte im Zentrum mit der Farbe
+	 * {@code from} und endet am Rand des durch den Radius beschriebenen Kreises
+	 * mit der Farbe {@code to}.
+	 *
+	 * @param centerX x-Koordinate des Kreismittelpunktes.
+	 * @param centerY y-Koordinate des Kreismittelpunktes.
+	 * @param radius Radius des Kreises.
+	 * @param from Farbe im Zentrum des Kreises.
+	 * @param to Farbe am Rand des Kreises.
+	 */
 	public void setGradient( double centerX, double centerY, double radius, Color from, Color to ) {
 		this.color = from;
 		background = new RadialGradientPaint(
@@ -134,6 +212,9 @@ public class ColorLayer extends Layer {
 		clear();
 	}
 
+	/**
+	 * Zeichnet den Hintergrund der Ebene mit der gesetzten Füllung neu.
+	 */
 	@Override
 	public void clear() {
 		drawing.setPaint(background);

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

@@ -8,55 +8,99 @@ import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
+/**
+ * Ein Layer um {@link Drawable} Objekte zu zeichnen.
+ * <p>
+ * Objekte, die das {@code Drawable} Interface implementieren, können der Ebene
+ * hinzugefügt werden. Die Ebene sorgt dafür, dass alle {@code Drawable}s einmal
+ * pro Frame über ihre {@link Drawable#draw(Graphics2D)} Methode gezeichnet.
+ */
+@SuppressWarnings( "unused" )
 public class DrawableLayer extends Layer {
 
-	protected List<Drawable> drawables = new LinkedList<>();
+	/**
+	 * Liste der {@link Drawable}s.
+	 */
+	protected final List<Drawable> drawables;
 
+	/**
+	 * Ob die Ebene bei jedem Aufruf von {@link #draw(Graphics2D)} geleert
+	 * werden soll.
+	 */
 	protected boolean clearBeforeDraw = true;
 
+	/**
+	 * Erstellt eine Ebene in der Standardgröße.
+	 */
 	public DrawableLayer() {
+		drawables = new LinkedList<>();
 	}
 
+	/**
+	 * Erstellt eine Ebene mit der angegebenen Größe.
+	 *
+	 * @param width Die Breite der Ebene.
+	 * @param height Die Höhe der Ebene.
+	 */
 	public DrawableLayer( int width, int height ) {
 		super(width, height);
+		drawables = new LinkedList<>();
 	}
 
+	/**
+	 * Fügt alle angegebenen {@code Drawable}s der Ebene hinzu.
+	 *
+	 * @param drawables Die {@code Drawable} Objekte.
+	 */
 	public void add( Drawable... drawables ) {
-		synchronized( drawables ) {
-			for( Drawable d : drawables ) {
-				this.drawables.add(d);
-			}
+		synchronized( this.drawables ) {
+			Collections.addAll(this.drawables, drawables);
 		}
 	}
 
+	/**
+	 * Gibt eine Liste aller {@code Drawable} Objekte dieser Ebene zurück.
+	 *
+	 * @return Die Liste der {@code Drawable} Objekte.
+	 */
 	public java.util.List<Drawable> getDrawables() {
 		return drawables;
 	}
 
+	/**
+	 * Ob die Ebene bei jedem Frame automatisch gelöscht wird.
+	 *
+	 * @return {@code true}, wenn die Ebene vorm Zeichnen gelöscht wird,
+	 *    {@code false} sonst.
+	 */
 	public boolean isClearBeforeDraw() {
 		return clearBeforeDraw;
 	}
 
+	/**
+	 * Stellt ein, ob die Ebene vorm Zeichnen gelöscht werden soll.
+	 *
+	 * @param pClearBeforeDraw Ob die Ebene vorm Zeichnen gelöscht werden
+	 * 	soll.
+	 */
 	public void setClearBeforeDraw( boolean pClearBeforeDraw ) {
 		this.clearBeforeDraw = pClearBeforeDraw;
 	}
 
 	@Override
-	public void draw( Graphics2D pGraphics ) {
+	public void draw( Graphics2D graphics ) {
 		if( clearBeforeDraw ) {
 			clear();
 		}
 
-		synchronized( drawables ) {
 		List<Drawable> it = List.copyOf(drawables);
 		for( Drawable d : it ) {
 			if( d.isVisible() ) {
 				d.draw(drawing);
 			}
 		}
-		}
 
-		super.draw(pGraphics);
+		super.draw(graphics);
 	}
 
 }

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

@@ -1,57 +1,126 @@
 package schule.ngb.zm.layers;
 
-import java.awt.Graphics2D;
-import java.awt.Image;
-
 import schule.ngb.zm.Layer;
 import schule.ngb.zm.util.io.ImageLoader;
 
+import java.awt.Graphics2D;
+import java.awt.Image;
+
+/**
+ * Eine Ebene, die ein statisches Bild anzeigt.
+ * <p>
+ * Die Ebene wird mit einem Bild initialisiert und zeigt dieses Bild als
+ * einzigen Inhalt an. Optional kann die Position des Bildes verändert werden,
+ * sodass es nicht im Ursprung der Ebene gezeichnet wird.
+ */
+@SuppressWarnings( "unused" )
 public class ImageLayer extends Layer {
 
+	/**
+	 * Das Bild, das angezeigt wird.
+	 */
 	protected Image image;
 
+	/**
+	 * x-Koordinate der oberen linken Ecke auf der Ebene.
+	 */
 	protected double x = 0;
 
+	/**
+	 * y-Koordinate der oberen linken Ecke auf der Ebene.
+	 */
 	protected double y = 0;
 
+	/**
+	 * Interner Schalter, ob die Ebene neu gezeichnet werden muss.
+	 */
 	protected boolean redraw = true;
 
-	public ImageLayer(String source) {
+	/**
+	 * Erstellt eine Bildebene in der Standardgröße aus der angegebenen
+	 * Bildquelle.
+	 *
+	 * @param source Eine Bildquelle.
+	 * @see ImageLoader#loadImage(String)
+	 */
+	public ImageLayer( String source ) {
 		image = ImageLoader.loadImage(source);
 	}
 
-	public ImageLayer(Image image) {
+	/**
+	 * Erstellt eine Bildebene in der Standardgröße aus dem angegebenen Bild.
+	 *
+	 * @param image Ein Bild-Objekt.
+	 */
+	public ImageLayer( Image image ) {
 		this.image = image;
 	}
 
-	public ImageLayer(int width, int height, Image image) {
+	/**
+	 * Erstellt eine Bildebene in der angegebenen Größe aus dem angegebenen
+	 * Bild.
+	 *
+	 * @param width Breite der Bildebene.
+	 * @param height Höhe der Bildebene.
+	 * @param image Ein Bild-Objekt.
+	 */
+	public ImageLayer( int width, int height, Image image ) {
 		super(width, height);
 		this.image = image;
 	}
 
-	public void setImage(Image image) {
+	/**
+	 * Setzt das Bild der Ebene auf das angegebene Bild-Objekt.
+	 *
+	 * @param image Ein Bild-Objekt.
+	 */
+	public void setImage( Image image ) {
 		this.image = image;
 		redraw = true;
 	}
 
+	/**
+	 * @return Die x-Koordinate des Bildes in der Ebene.
+	 */
 	public double getX() {
 		return x;
 	}
 
-	public void setX(double pX) {
+	/**
+	 * Setzt die {@code x}-Koordinate des BIldes in der Ebene auf den
+	 * angegebenen Wert.
+	 *
+	 * @param pX Die x-Koordinate des Bildes.
+	 */
+	public void setX( double pX ) {
 		this.x = pX;
 		redraw = true;
 	}
 
+	/**
+	 * @return Die y-Koordinate des Bildes in der Ebene.
+	 */
 	public double getY() {
 		return y;
 	}
 
-	public void setY(double pY) {
+	/**
+	 * Setzt die {@code y}-Koordinate des BIldes in der Ebene auf den
+	 * angegebenen Wert.
+	 *
+	 * @param pY Die y-Koordinate des Bildes.
+	 */
+	public void setY( double pY ) {
 		this.y = pY;
 		redraw = true;
 	}
 
+	/**
+	 * Löscht die Ebene und zeichnet das Bild neu.
+	 * <p>
+	 * In der Regel muss die Ebene nicht gelöscht werden, da sie automatisch neu
+	 * gezeichnet wird, sobald sich das zugrundeliegende Bild ändert.
+	 */
 	@Override
 	public void clear() {
 		super.clear();
@@ -59,8 +128,8 @@ public class ImageLayer extends Layer {
 	}
 
 	@Override
-	public void draw(Graphics2D graphics) {
-		if (redraw && visible) {
+	public void draw( Graphics2D graphics ) {
+		if( redraw && visible ) {
 			drawing.drawImage(image, (int) x, (int) y, null);
 			redraw = false;
 		}

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

@@ -4,42 +4,46 @@ import schule.ngb.zm.Color;
 import schule.ngb.zm.Layer;
 import schule.ngb.zm.Options;
 
-import java.awt.*;
+import java.awt.BasicStroke;
+import java.awt.Graphics2D;
+import java.awt.Shape;
+import java.awt.Stroke;
 import java.util.LinkedList;
 
+@SuppressWarnings( "unused" )
 public final class Shape2DLayer extends Layer {
 
-	protected schule.ngb.zm.Color strokeColor = DEFAULT_STROKECOLOR;
+	private schule.ngb.zm.Color strokeColor = DEFAULT_STROKECOLOR;
 
-	protected schule.ngb.zm.Color fillColor = DEFAULT_FILLCOLOR;
+	private schule.ngb.zm.Color fillColor = DEFAULT_FILLCOLOR;
 
-	protected double strokeWeight = DEFAULT_STROKEWEIGHT;
+	private double strokeWeight = DEFAULT_STROKEWEIGHT;
 
-	protected Options.StrokeType strokeType = SOLID;
+	private Options.StrokeType strokeType = SOLID;
 
-	private LinkedList<java.awt.Shape> shapes;
+	private final LinkedList<java.awt.Shape> shapes;
 
 	private boolean instantDraw = false;
 
 	public Shape2DLayer() {
 		super();
-		shapes = new LinkedList<java.awt.Shape>();
+		shapes = new LinkedList<>();
 	}
 
 	public Shape2DLayer( boolean instantDraw ) {
 		super();
-		shapes = new LinkedList<java.awt.Shape>();
+		shapes = new LinkedList<>();
 		this.instantDraw = instantDraw;
 	}
 
 	public Shape2DLayer( int width, int height ) {
 		super(width, height);
-		shapes = new LinkedList<java.awt.Shape>();
+		shapes = new LinkedList<>();
 	}
 
 	public Shape2DLayer( int width, int height, boolean instantDraw ) {
 		super(width, height);
-		shapes = new LinkedList<java.awt.Shape>();
+		shapes = new LinkedList<>();
 		this.instantDraw = instantDraw;
 	}
 
@@ -106,7 +110,7 @@ public final class Shape2DLayer extends Layer {
 		drawing.setStroke(createStroke());
 	}
 
-	protected Stroke createStroke() {
+	private Stroke createStroke() {
 		switch( strokeType ) {
 			case DOTTED:
 				return new BasicStroke(
@@ -153,7 +157,7 @@ public final class Shape2DLayer extends Layer {
 	}
 
 	@Override
-	public void draw( Graphics2D pGraphics ) {
+	public void draw( Graphics2D graphics ) {
 		if( !instantDraw ) {
 			for( Shape shape : shapes ) {
 				drawing.setColor(fillColor.getJavaColor());
@@ -164,7 +168,7 @@ public final class Shape2DLayer extends Layer {
 			}
 		}
 
-		super.draw(pGraphics);
+		super.draw(graphics);
 	}
 
 }

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

@@ -10,13 +10,23 @@ import java.awt.Graphics2D;
 import java.util.*;
 import java.util.function.DoubleUnaryOperator;
 
+/**
+ * Eine Ebene um {@link Shape} Objekte zu zeichnen.
+ * <p>
+ * Ein {@code ShapesLayer} ist eine der drei Standardebenen der
+ * {@link schule.ngb.zm.Zeichenmaschine}.
+ */
+@SuppressWarnings( "unused" )
 public class ShapesLayer extends Layer {
 
+	/**
+	 *
+	 */
 	protected boolean clearBeforeDraw = true;
 
-	private List<Shape> shapes;
+	private final List<Shape> shapes;
 
-	private List<Animation<? extends Shape>> animations;
+	private final List<Animation<? extends Shape>> animations;
 
 	public ShapesLayer() {
 		super();
@@ -37,7 +47,7 @@ public class ShapesLayer extends Layer {
 	public <ST extends Shape> ST getShape( Class<ST> shapeClass ) {
 		for( Shape s : shapes ) {
 			if( shapeClass.isInstance(s) ) {
-				return (ST) s;
+				return shapeClass.cast(s);
 			}
 		}
 		return null;
@@ -51,7 +61,7 @@ public class ShapesLayer extends Layer {
 		List<ST> result = new LinkedList<>();
 		for( Shape s : shapes ) {
 			if( shapeClass.isInstance(s) ) {
-				result.add((ST) s);
+				result.add(shapeClass.cast(s));
 			}
 		}
 		return result;
@@ -59,17 +69,13 @@ public class ShapesLayer extends Layer {
 
 	public void add( Shape... shapes ) {
 		synchronized( this.shapes ) {
-			for( Shape s : shapes ) {
-				this.shapes.add(s);
-			}
+			Collections.addAll(this.shapes, shapes);
 		}
 	}
 
 	public void add( Collection<Shape> shapes ) {
 		synchronized( this.shapes ) {
-			for( Shape s : shapes ) {
-				this.shapes.add(s);
-			}
+			this.shapes.addAll(shapes);
 		}
 	}
 
@@ -83,9 +89,7 @@ public class ShapesLayer extends Layer {
 
 	public void remove( Collection<Shape> shapes ) {
 		synchronized( this.shapes ) {
-			for( Shape s : shapes ) {
-				this.shapes.remove(s);
-			}
+			this.shapes.removeAll(shapes);
 		}
 	}
 
@@ -116,9 +120,9 @@ public class ShapesLayer extends Layer {
 		anim.start();
 	}
 
-
-	public void play( Animation<? extends Shape>... anims ) {
-		for( Animation<? extends Shape> anim: anims ) {
+	@SafeVarargs
+	public final void play( Animation<? extends Shape>... anims ) {
+		for( Animation<? extends Shape> anim : anims ) {
 			this.animations.add(anim);
 			anim.start();
 		}
@@ -141,13 +145,13 @@ public class ShapesLayer extends Layer {
 			anim.update(delta);
 
 			if( !anim.isActive() ) {
-				animations.remove(anim);
+				it.remove();
 			}
 		}
 	}
 
 	@Override
-	public void draw( Graphics2D pGraphics ) {
+	public void draw( Graphics2D graphics ) {
 		if( clearBeforeDraw ) {
 			clear();
 		}
@@ -161,7 +165,7 @@ public class ShapesLayer extends Layer {
 			}
 		}
 
-		super.draw(pGraphics);
+		super.draw(graphics);
 	}
 
 }

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

@@ -1,18 +1,25 @@
 package schule.ngb.zm.layers;
 
+import schule.ngb.zm.*;
 import schule.ngb.zm.Color;
-import schule.ngb.zm.Layer;
-import schule.ngb.zm.Options;
-import schule.ngb.zm.Vector;
-import schule.ngb.zm.shapes.FilledShape;
+import schule.ngb.zm.Fillable;
+import schule.ngb.zm.Strokeable;
 
 import java.awt.*;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Path2D;
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Stack;
 
-public class TurtleLayer extends Layer {
+/**
+ * Eine Ebene, auf der eine Turtle gesteuert werden kann, die Grafiken plottet.
+ * <p>
+ * Die Turtle verhält sich ähnlich zu ihren Entsprechungen in Logo oder
+ * TigerJython.
+ */
+@SuppressWarnings( "unused" )
+public class TurtleLayer extends Layer implements Strokeable, Fillable {
 
 	// Rotating by the clock
 	public static final int H1 = 30;
@@ -39,7 +46,7 @@ public class TurtleLayer extends Layer {
 
 	public static final int H12 = 360;
 
-	private static Stack<Color> turtleColors;
+	private final static Stack<Color> turtleColors;
 
 	static {
 		turtleColors = new Stack<>();
@@ -51,9 +58,9 @@ public class TurtleLayer extends Layer {
 		turtleColors.add(Color.BLUE);
 	}
 
-	private Turtle mainTurtle = null;
+	private final Turtle mainTurtle;
 
-	private ArrayList<Turtle> turtles = new ArrayList<Turtle>(6);
+	private final List<Turtle> turtles = new ArrayList<>(6);
 
 	public TurtleLayer() {
 		super();
@@ -117,7 +124,20 @@ public class TurtleLayer extends Layer {
 		}
 	}
 
-	// Begin of delegate methods (auto-generated)
+	// begin of delegate methods (auto-generated)
+
+	@Override
+	public boolean isVisible() {
+		return mainTurtle.isVisible();
+	}
+
+	public void beginPath() {
+		mainTurtle.beginPath();
+	}
+
+	public void closePath() {
+		mainTurtle.closePath();
+	}
 
 	public void fill() {
 		mainTurtle.fill();
@@ -175,100 +195,196 @@ public class TurtleLayer extends Layer {
 		mainTurtle.moveTo(x, y);
 	}
 
-	public Color getFillColor() {
-		return mainTurtle.getFillColor();
+	@Override
+	public void setFill( Paint fill ) {
+		mainTurtle.setFill(fill);
 	}
 
+	@Override
+	public Paint getFill() {
+		return mainTurtle.getFill();
+	}
+
+	@Override
 	public void setFillColor( Color color ) {
 		mainTurtle.setFillColor(color);
 	}
 
-	public void setFillColor( int gray ) {
-		mainTurtle.setFillColor(gray);
-	}
-
-	public void noFill() {
-		mainTurtle.noFill();
-	}
-
-	public void setFillColor( int gray, int alpha ) {
-		mainTurtle.setFillColor(gray, alpha);
-	}
-
-	public void setFillColor( int red, int green, int blue ) {
-		mainTurtle.setFillColor(red, green, blue);
-	}
-
-	public void setFillColor( int red, int green, int blue, int alpha ) {
-		mainTurtle.setFillColor(red, green, blue, alpha);
-	}
-
-	public void resetFill() {
-		mainTurtle.resetFill();
-	}
-
-	public Color getStrokeColor() {
-		return mainTurtle.getStrokeColor();
+	@Override
+	public Color getFillColor() {
+		return mainTurtle.getFillColor();
 	}
 
+	@Override
 	public void setStrokeColor( Color color ) {
 		mainTurtle.setStrokeColor(color);
 	}
 
-	public void setStrokeColor( int gray ) {
-		mainTurtle.setStrokeColor(gray);
-	}
-
-	public void noStroke() {
-		mainTurtle.noStroke();
-	}
-
-	public void setStrokeColor( int gray, int alpha ) {
-		mainTurtle.setStrokeColor(gray, alpha);
-	}
-
-	public void setStrokeColor( int red, int green, int blue ) {
-		mainTurtle.setStrokeColor(red, green, blue);
-	}
-
-	public void setStrokeColor( int red, int green, int blue, int alpha ) {
-		mainTurtle.setStrokeColor(red, green, blue, alpha);
-	}
-
-	public double getStrokeWeight() {
-		return mainTurtle.getStrokeWeight();
-	}
-
+	@Override
 	public void setStrokeWeight( double weight ) {
 		mainTurtle.setStrokeWeight(weight);
 	}
 
+	@Override
 	public Options.StrokeType getStrokeType() {
 		return mainTurtle.getStrokeType();
 	}
 
+	@Override
 	public void setStrokeType( Options.StrokeType type ) {
 		mainTurtle.setStrokeType(type);
 	}
 
+	@Override
+	public void setGradient( Color from, Color to, Options.Direction dir ) {
+		mainTurtle.setGradient(from, to, dir);
+	}
+
+	@Override
+	public void setGradient( Color from, Color to ) {
+		mainTurtle.setGradient(from, to);
+	}
+
+	@Override
+	public boolean hasFill() {
+		return mainTurtle.hasFill();
+	}
+
+	@Override
+	public boolean hasFillColor() {
+		return mainTurtle.hasFillColor();
+	}
+
+	@Override
+	public boolean hasGradient() {
+		return mainTurtle.hasGradient();
+	}
+
+	@Override
+	public void setFillColor( Color color, int alpha ) {
+		mainTurtle.setFillColor(color, alpha);
+	}
+
+	@Override
+	public void setFillColor( int gray ) {
+		mainTurtle.setFillColor(gray);
+	}
+
+	@Override
+	public void setFillColor( int gray, int alpha ) {
+		mainTurtle.setFillColor(gray, alpha);
+	}
+
+	@Override
+	public void setFillColor( int red, int green, int blue ) {
+		mainTurtle.setFillColor(red, green, blue);
+	}
+
+	@Override
+	public void setFillColor( int red, int green, int blue, int alpha ) {
+		mainTurtle.setFillColor(red, green, blue, alpha);
+	}
+
+	@Override
+	public void noFill() {
+		mainTurtle.noFill();
+	}
+
+	@Override
+	public void resetFill() {
+		mainTurtle.resetFill();
+	}
+
+	@Override
+	public MultipleGradientPaint getGradient() {
+		return mainTurtle.getGradient();
+	}
+
+	@Override
+	public void setGradient( double fromX, double fromY, Color from, double toX, double toY, Color to ) {
+		mainTurtle.setGradient(fromX, fromY, from, toX, toY, to);
+	}
+
+	@Override
+	public void setGradient( double centerX, double centerY, double radius, Color from, Color to ) {
+		mainTurtle.setGradient(centerX, centerY, radius, from, to);
+	}
+
+	@Override
+	public void noGradient() {
+		mainTurtle.noGradient();
+	}
+
+	@Override
+	public void setStroke( Stroke stroke ) {
+		mainTurtle.setStroke(stroke);
+	}
+
+	@Override
+	public Stroke getStroke() {
+		return mainTurtle.getStroke();
+	}
+
+	@Override
+	public boolean hasStroke() {
+		return mainTurtle.hasStroke();
+	}
+
+	@Override
+	public Color getStrokeColor() {
+		return mainTurtle.getStrokeColor();
+	}
+
+	@Override
+	public void setStrokeColor( Color color, int alpha ) {
+		mainTurtle.setStrokeColor(color, alpha);
+	}
+
+	@Override
+	public void setStrokeColor( int gray ) {
+		mainTurtle.setStrokeColor(gray);
+	}
+
+	@Override
+	public void setStrokeColor( int gray, int alpha ) {
+		mainTurtle.setStrokeColor(gray, alpha);
+	}
+
+	@Override
+	public void setStrokeColor( int red, int green, int blue ) {
+		mainTurtle.setStrokeColor(red, green, blue);
+	}
+
+	@Override
+	public void setStrokeColor( int red, int green, int blue, int alpha ) {
+		mainTurtle.setStrokeColor(red, green, blue, alpha);
+	}
+
+	@Override
+	public void noStroke() {
+		mainTurtle.noStroke();
+	}
+
+	@Override
 	public void resetStroke() {
 		mainTurtle.resetStroke();
 	}
 
-	public void addPosToPath() {
-		mainTurtle.addPosToPath();
+	@Override
+	public double getStrokeWeight() {
+		return mainTurtle.getStrokeWeight();
 	}
 
-	public void closePath() {
-		mainTurtle.closePath();
-	}
 
-	// End of delegate methods (auto-generated)
+	// end of delegate methods (auto-generated)
 
 
-	public class Turtle extends FilledShape {
+	/**
+	 * Die Turtle der Zeichenmaschine.
+	 */
+	public class Turtle extends BasicDrawable {
 
-		private static final int STD_SIZE = 12;
+		private static final int DEFAULT_SIZE = 12;
 
 		boolean penDown = true;
 
@@ -282,7 +398,31 @@ public class TurtleLayer extends Layer {
 
 		boolean pathOpen = false;
 
-		Turtle() {}
+		/**
+		 * Path-Objekt für die Darstellung der Turtle.
+		 */
+		Path2D.Double turtlePath;
+
+		Turtle() {
+		}
+
+		public boolean isVisible() {
+			return visible;
+		}
+
+		public void beginPath() {
+			pathOpen = false;
+			addPosToPath();
+		}
+
+		public void closePath() {
+			if( pathOpen ) {
+				addPosToPath();
+				path.closePath();
+				path.trimToSize();
+				pathOpen = false;
+			}
+		}
 
 		private void addPosToPath() {
 			if( !pathOpen ) {
@@ -294,53 +434,39 @@ public class TurtleLayer extends Layer {
 			}
 		}
 
-		private void closePath() {
-			if( pathOpen ) {
-				addPosToPath();
-				path.closePath();
-				path.trimToSize();
-				pathOpen = false;
-			}
-		}
-
 		public void fill() {
 			closePath();
 
-			if( fillColor != null && fillColor.getAlpha() > 0 ) {
-				drawing.setColor(fillColor.getJavaColor());
+			if( hasFill() ) {
+				drawing.setPaint(getFill());
 				drawing.fill(path);
 			}
 		}
 
-		public boolean isVisible() {
-			return visible;
-		}
-
 		@Override
 		public void draw( Graphics2D graphics ) {
-			/*Shape shape = new RoundRectangle2D.Double(
-				-12, -5, 16, 10, 5, 3
-			);*/
-			Path2D path = new Path2D.Double();
-			path.moveTo(STD_SIZE, 0);
-			path.lineTo(-STD_SIZE, -STD_SIZE/2);
-			path.lineTo(-STD_SIZE, STD_SIZE/2);
-			path.lineTo(STD_SIZE, 0);
+			if( turtlePath == null ) {
+				turtlePath = new Path2D.Double();
+				path.moveTo(DEFAULT_SIZE, 0);
+				path.lineTo(-DEFAULT_SIZE, -DEFAULT_SIZE / 2.0);
+				path.lineTo(-DEFAULT_SIZE, DEFAULT_SIZE / 2.0);
+				path.lineTo(DEFAULT_SIZE, 0);
+			}
 
 			AffineTransform verzerrung = new AffineTransform();
 			verzerrung.translate(position.x, position.y);
 			verzerrung.rotate(Math.toRadians(direction.angle()));
 
-			Shape shape = verzerrung.createTransformedShape(path);
+			java.awt.Shape shape = verzerrung.createTransformedShape(turtlePath);
 
-			if( strokeColor != null ) {
+			if( hasStroke() ) {
 				graphics.setColor(strokeColor.getJavaColor());
 			} else {
 				graphics.setColor(DEFAULT_STROKECOLOR.getJavaColor());
 			}
 			graphics.fill(shape);
 			graphics.setColor(Color.BLACK.getJavaColor());
-			graphics.setStroke(createStroke());
+			graphics.setStroke(getStroke());
 			graphics.draw(shape);
 		}
 
@@ -354,9 +480,9 @@ public class TurtleLayer extends Layer {
 			Vector positionStart = position.copy();
 			position.add(Vector.setLength(direction, dist));
 
-			if( penDown && strokeColor != null ) {
+			if( penDown && hasStroke() ) {
 				drawing.setColor(strokeColor.getJavaColor());
-				drawing.setStroke(createStroke());
+				drawing.setStroke(getStroke());
 				drawing.drawLine((int) positionStart.x, (int) positionStart.y, (int) position.x, (int) position.y);
 			}
 		}
@@ -407,9 +533,9 @@ public class TurtleLayer extends Layer {
 			position.x = x;
 			position.y = y;
 
-			if( penDown && strokeColor != null ) {
+			if( penDown && hasStroke() ) {
 				drawing.setColor(strokeColor.getJavaColor());
-				drawing.setStroke(createStroke());
+				drawing.setStroke(getStroke());
 				drawing.drawLine((int) x, (int) y, (int) position.x, (int) position.y);
 			}
 		}

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
-	 * Audio-Medium wird einmal abgespielt und stoppt dann.
+	 * Startet die Wiedergabe des Mediums. Das Audio-Medium wird einmal
+	 * 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,21 +82,36 @@ public interface Audio {
 
 	/**
 	 * Spielt das Medium in einer kontinuierlichen Schleife ab. Die Methode
-	 * startet die Wiedergabe und beendet dann direkt die Methode. Um die
-	 * Wiedergabe zu stoppen muss {@link #stop()} aufgerufen werden.
+	 * startet die Wiedergabe im Hintergrund und beendet dann sofort. Um die
+	 * 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 angegebene Objekt als {@code AudioListener} hinzu,
+	 * der bei Start und Stopp der Wiedergabe informiert wird.
+	 *
+	 * @param listener Das Listener-Objekt.
+	 */
+	void addAudioListener( AudioListener listener );
+
+	/**
+	 * Entfernt den angegebenen {@code AudioListener} vom Medium.
+	 *
+	 * @param listener Das Listener-Objekt.
+	 */
+	void removeAudioListener( AudioListener listener );
+
 }

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

@@ -2,10 +2,33 @@ package schule.ngb.zm.media;
 
 import schule.ngb.zm.util.events.Listener;
 
+/**
+ * Interface für Klassen, die auf das starten und stoppen der Wiedergabe von
+ * {@link Audio}-Objekten reagieren möchten.
+ * <p>
+ * Implementierende Klassen können sich bei einem Auido-Objekt mittels
+ * {@link Audio#addAudioListener(AudioListener)} anmelden und werden über die
+ * jeweilige Methode informiert, sobald die Wiedergabe gestartet oder gestoppt
+ * wird.
+ */
 public interface AudioListener extends Listener<Audio> {
 
-	void start( Audio source );
+	/**
+	 * Wird aufgerufen, sobald die Wiedergabe eines Audio-Mediums startet, dem
+	 * dieses Objekt mittels {@link Audio#addAudioListener(AudioListener)}
+	 * hinzugefügt wurde.
+	 *
+	 * @param source Das Audio-Medium, dessen Wiedergabe gestartet wurde.
+	 */
+	void playbackStarted( Audio source );
 
-	void stop( Audio source );
+	/**
+	 * Wird aufgerufen, sobald die Wiedergabe eines Audio-Mediums stoppt, dem
+	 * dieses Objekt mittels {@link Audio#addAudioListener(AudioListener)}
+	 * hinzugefügt wurde.
+	 *
+	 * @param source Das Audio-Medium, dessen Wiedergabe gestoppt wurde.
+	 */
+	void playbackStopped( Audio source );
 
 }

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

@@ -1,9 +1,11 @@
 package schule.ngb.zm.media;
 
 import schule.ngb.zm.Constants;
+import schule.ngb.zm.util.events.EventDispatcher;
 import schule.ngb.zm.util.tasks.TaskRunner;
 
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
 
 /**
@@ -18,24 +20,14 @@ import java.util.List;
  * Darüber hinaus kann ein Mixer Effekte wie einen
  * {@link #fade(double, int) fadeIn} auf die Medien anwenden.
  */
-public class Mixer implements Audio {
+@SuppressWarnings( "unused" )
+public class Mixer implements Audio, AudioListener {
 
 	private List<AudioWrapper> audios;
 
 	private float volume = 0.8f;
 
-	class AudioWrapper {
-
-		Audio audio;
-
-		float volumeFactor;
-
-		public AudioWrapper( Audio audio, float volumeFactor ) {
-			this.audio = audio;
-			this.volumeFactor = volumeFactor;
-		}
-
-	}
+	EventDispatcher<Audio, AudioListener> eventDispatcher;
 
 	public Mixer() {
 		this.audios = new ArrayList<>(4);
@@ -45,66 +37,93 @@ public class Mixer implements Audio {
 		return "";
 	}
 
-	public void add( Audio pAudio ) {
-		add(pAudio, 1f);
+	private AudioWrapper findWrapper( Audio pAudio ) {
+		for( AudioWrapper aw: audios ) {
+			if( aw.audio == pAudio ) {
+				return aw;
+			}
+		}
+		return null;
 	}
 
+	public boolean contains( Audio pAudio ) {
+		return findWrapper(pAudio) != null;
+	}
+
+	public void add( Audio pAudio ) {
+		add(pAudio, 1);
+	}
+
+	/**
+	 * Fügt ein Audio-Objekt dem Mixer mit dem angegebenen Lautstärke-Faktor
+	 * hinzu.
+	 * <p>
+	 * Der Lautstärke-Faktor setzt die Lautstärke des Audio-Objektes relativ zur
+	 * Lautstärke des Mixers. Bei einem Faktor von 1.0 wird die Lautstärke des
+	 * Mixers übernommen. Bei einem Wert von 0.5 wird das Objekt halb so laut
+	 * abgespielt. Auf diese Weise lässt sich die Lautstärke aller Audio-Objekte
+	 * des Mixers gleichzeitig anpassen, während ihre relative Lautstärke
+	 * zueinander gleich bleibt.
+	 *
+	 * @param pAudio Ein Audio-Objekt.
+	 * @param pVolumeFactor Der Lautstärke-Faktor.
+	 */
 	public void add( Audio pAudio, double pVolumeFactor ) {
+		if( !contains(pAudio) ) {
 			audios.add(new AudioWrapper(pAudio, (float) pVolumeFactor));
+		} else {
+			findWrapper(pAudio).volumeFactor = (float) pVolumeFactor;
+		}
 		pAudio.setVolume(pVolumeFactor * volume);
 	}
 
+	/**
+	 * Entfernt die das angegebene Audio-Objekt aus dem Mixer. Ist das Objekt
+	 * nicht Teil des Mixers, passiert nichts.
+	 *
+	 * @param pAudio Ein Audio-Objekt.
+	 */
 	public void remove( Audio pAudio ) {
+		Iterator<AudioWrapper> it = audios.listIterator();
+		while( it.hasNext() ) {
+			AudioWrapper aw = it.next();
+			if( aw.audio == pAudio ) {
+				it.remove();
+				break;
+			}
+		}
 	}
 
 	public void removeAll() {
 		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 ) {
-		volume = (float) pVolume;
-		audios.stream().forEach(aw -> aw.audio.setVolume(aw.volumeFactor * pVolume));
+	public void setVolume( double volume ) {
+		this.volume = volume < 0 ? 0f : (float) volume;
+		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());
@@ -117,25 +136,16 @@ public class Mixer implements Audio {
 		}
 	}
 
-	/**
-	 * {@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() ) {
@@ -178,4 +188,58 @@ public class Mixer implements Audio {
 		});
 	}
 
+	@Override
+	public void playbackStarted( Audio source ) {
+		if( eventDispatcher != null ) {
+			eventDispatcher.dispatchEvent("start", Mixer.this);
+		}
+	}
+
+	@Override
+	public void playbackStopped( Audio source ) {
+		if( !isPlaying() ) {
+			if( eventDispatcher != null ) {
+				eventDispatcher.dispatchEvent("stop", Mixer.this);
+			}
+		}
+	}
+
+	@Override
+	public void addAudioListener( AudioListener listener ) {
+		initializeEventDispatcher().addListener(listener);
+	}
+
+	@Override
+	public void removeAudioListener( AudioListener listener ) {
+		initializeEventDispatcher().removeListener(listener);
+	}
+
+	/**
+	 * Interne Methode, um den Listener-Mechanismus zu initialisieren. Wird erst
+	 * aufgerufen, sobald sich auch ein Listener registrieren möchte.
+	 *
+	 * @return
+	 */
+	private EventDispatcher<Audio, AudioListener> initializeEventDispatcher() {
+		if( eventDispatcher == null ) {
+			eventDispatcher = new EventDispatcher<>();
+			eventDispatcher.registerEventType("start", (a,l) -> l.playbackStarted(a));
+			eventDispatcher.registerEventType("stop", (a,l) -> l.playbackStopped(a));
+		}
+		return eventDispatcher;
+	}
+
+	class AudioWrapper {
+
+		Audio audio;
+
+		float volumeFactor;
+
+		public AudioWrapper( Audio audio, float volumeFactor ) {
+			this.audio = audio;
+			this.volumeFactor = volumeFactor;
+		}
+
+	}
+
 }

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

@@ -1,83 +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,
- * die zum Beispiel als Hintergrundmusik ablaufen sollen. Die Musik wird daher
- * nicht komplett in den Speicher geladen, sondern direkt aus der Audioquelle
- * gestreamt und wiedergegeben.
+ * Im Gegensatz zu einem {@link Sound} wird {@code Music} für längere
+ * Audiodateien benutzt, die zum Beispiel als Hintergrundmusik gespielt werden.
+ * Die Audiodaten werden daher nicht vollständig in den Speicher geladen,
+ * 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.
  */
+// 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
-	 * wurde. Sonst {@code null}.
+	 * Der {@link AudioInputStream}, um die Audiosdaten zu lesen. {@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
-	 * {@code null}.
+	 * Die {@link SourceDataLine} für die Ausgabe. {@code null}, falls die
+	 * 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);
-		this.audioSource = source;
+	/**
+	 * Erstellt eine Musik aus der angegebenen Audioquelle.
+	 *
+	 * @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 ) {
@@ -86,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
-	 * anzuwenden.
+	 * Wendet die Lautstärke vor dem Abspielen auf den Audiostream an.
 	 */
 	private void applyVolume() {
 		FloatControl gainControl =
@@ -118,24 +131,13 @@ public class Music implements Audio {
 		gainControl.setValue(vol);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void play() {
 		if( openLine() ) {
-			TaskRunner.run(new Runnable() {
-				@Override
-				public void run() {
-					stream();
-				}
-			});
+			TaskRunner.run(this::stream);
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void playAndWait() {
 		if( openLine() ) {
@@ -143,18 +145,12 @@ public class Music implements Audio {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void loop() {
 		looping = true;
 		play();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void stop() {
 		playing = false;
@@ -162,9 +158,6 @@ public class Music implements Audio {
 		dispose();
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public synchronized void dispose() {
 		if( audioLine != null ) {
@@ -188,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 ) {
@@ -225,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;
@@ -261,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();
 
@@ -276,24 +296,27 @@ public class Music implements Audio {
 		}
 	}
 
-	public void addListener( AudioListener listener ) {
+	@Override
+	public void addAudioListener( AudioListener listener ) {
 		initializeEventDispatcher().addListener(listener);
 	}
 
-	public void removeListener( AudioListener listener ) {
+	@Override
+	public void removeAudioListener( AudioListener listener ) {
 		initializeEventDispatcher().removeListener(listener);
 	}
 
 	/**
 	 * Interne Methode, um den Listener-Mechanismus zu initialisieren. Wird erst
-	 * aufgerufen, soblad sich auch ein Listener registrieren möchte.
-	 * @return
+	 * aufgerufen, sobald sich der erste Listener anmelden möchte.
+	 *
+	 * @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.start(a));
-			eventDispatcher.registerEventType("stop", (a,l) -> l.stop(a));
+			eventDispatcher.registerEventType("start", ( a, l ) -> l.playbackStarted(a));
+			eventDispatcher.registerEventType("stop", ( a, l ) -> l.playbackStopped(a));
 		}
 		return eventDispatcher;
 	}

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

@@ -2,6 +2,7 @@ package schule.ngb.zm.media;
 
 import schule.ngb.zm.util.Log;
 import schule.ngb.zm.util.Validator;
+import schule.ngb.zm.util.events.EventDispatcher;
 import schule.ngb.zm.util.io.ResourceStreamProvider;
 
 import javax.sound.sampled.*;
@@ -9,78 +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,
- * die zusammen mit bestimmten Aktionen wiedergegeben werden (zum Beispiel, wenn
- * die Spielfigur springt, wenn zwei Objekte kollidieren, usw.). Sounds werden
- * komplett in den Speicher geladen und können dadurch immer wieder, als
- * Schleife oder auch nur Abschnittsweise abgespielt werden.
+ * In Spielen und anderen Projekten gibt es oftmals eine Reihe kurzer
+ * Soundclips, die zusammen mit bestimmten Aktionen wiedergegeben werden (zum
+ * Beispiel, wenn die Spielfigur springt, wenn zwei Objekte kollidieren, usw.).
+ * Sounds werden vollständig in den Speicher geladen und können immer wieder,
+ * als Schleife oder auch nur Abschnittsweise, abgespielt werden.
  * <p>
- * Für längre Musikstücke (beispielsweise Hintergrundmusik) bietet sich eher die
- * KLasse {@link Music} an.
+ * Für längere Musikstücke (beispielsweise Hintergrundmusik) bietet sich eher
+ * 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 ) {
@@ -89,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
-	 * anzuwenden.
+	 * Wendet die Lautstärke vor dem Abspielen auf den Clip an.
 	 */
 	private void applyVolume() {
 		FloatControl gainControl =
@@ -121,9 +124,6 @@ public class Sound implements Audio {
 		gainControl.setValue(vol);
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void stop() {
 		looping = false;
@@ -133,9 +133,6 @@ public class Sound implements Audio {
 		playing = false;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void play() {
 		if( this.openClip() ) {
@@ -144,9 +141,6 @@ public class Sound implements Audio {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public void playAndWait() {
 		this.play();
@@ -165,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
@@ -182,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
@@ -196,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
-	 * stoppt die Wiedergabe dann.
+	 * Wiederholt den Sound die angegebene Anzahl an Wiederholungen und stoppt
+	 * 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.
 	 */
@@ -228,20 +223,24 @@ public class Sound implements Audio {
 		}
 	}
 
-	/**
-	 * {@inheritDoc}
-	 */
 	@Override
 	public synchronized void dispose() {
 		if( audioClip != null ) {
 			if( audioClip.isRunning() ) {
-				audioClip.stop();
+				stop();
 			}
 			audioClip.close();
 			audioClip = null;
 		}
 	}
 
+	/**
+	 * 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);
@@ -259,8 +258,16 @@ public class Sound implements Audio {
 				audioClip.addLineListener(new LineListener() {
 					@Override
 					public void update( LineEvent event ) {
-						if( event.getType() == LineEvent.Type.STOP ) {
+						if( event.getType() == LineEvent.Type.START ) {
+							if( eventDispatcher != null ) {
+								eventDispatcher.dispatchEvent("start", Sound.this);
+							}
+						} else if( event.getType() == LineEvent.Type.STOP ) {
 							playbackStopped();
+
+							if( eventDispatcher != null ) {
+								eventDispatcher.dispatchEvent("stop", Sound.this);
+							}
 						}
 					}
 				});
@@ -296,18 +303,47 @@ public class Sound implements Audio {
 	}*/
 
 	/**
-	 * Interne Methode, die aufgerufen wird, wenn die Wiedergabe gestoppt wird.
-	 * Entweder durch einen Aufruf von {@link #stop()} oder, weil die Wiedergabe
-	 * nach {@link #playOnce()} beendet wurde.
+	 * Wird aufgerufen, wenn die Wiedergabe beendet wurde. Entweder durch einen
+	 * Aufruf von {@link #stop()} oder, weil die Wiedergabe nach
+	 * {@link #playOnce()} beendet wurde.
+	 * <p>
+	 * Falls {@link #disposeAfterPlay} gesetzt ist, wird nach dem Ende der
+	 * Wiedergabe {@link #dispose()} aufgerufen.
 	 */
 	private void playbackStopped() {
 		playing = false;
+
 		if( disposeAfterPlay ) {
 			this.dispose();
 			disposeAfterPlay = false;
 		}
 	}
 
+	@Override
+	public void addAudioListener( AudioListener listener ) {
+		initializeEventDispatcher().addListener(listener);
+	}
+
+	@Override
+	public void removeAudioListener( AudioListener listener ) {
+		initializeEventDispatcher().removeListener(listener);
+	}
+
+	/**
+	 * Interne Methode, um den Listener-Mechanismus zu initialisieren. Wird erst
+	 * aufgerufen, sobald sich der erste Listener anmelden möchte.
+	 *
+	 * @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("stop", ( a, l ) -> l.playbackStopped(a));
+		}
+		return eventDispatcher;
+	}
+
 	private static final Log LOG = Log.getLogger(Sound.class);
 
 }

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/FilledShape.java

@@ -1,202 +0,0 @@
-package schule.ngb.zm.shapes;
-
-import schule.ngb.zm.Color;
-
-import java.awt.GradientPaint;
-import java.awt.Graphics2D;
-import java.awt.Paint;
-import java.awt.RadialGradientPaint;
-
-/**
- * Basisklasse für Formen, die eine Füllung besitzen können.
- * <p>
- * Formen mit einer Füllung können auch immer eine Konturlinie besitzen.
- */
-public abstract class FilledShape extends StrokedShape {
-
-	/**
-	 * Die aktuelle Füllfarbe der Form oder {@code null}, wenn die Form nicht
-	 * gefüllt werden soll.
-	 */
-	protected Color fillColor = DEFAULT_FILLCOLOR;
-
-	/**
-	 * Der aktuelle Farbverlauf der Form oder {@code null}, wenn die Form keinen
-	 * Farbverlauf besitzt.
-	 */
-	protected Paint fill = null;
-
-	/**
-	 * Gibt die aktuelle Füllfarbe der Form zurück.
-	 *
-	 * @return Die aktuelle Füllfarbe oder {@code null}.
-	 */
-	public Color getFillColor() {
-		return fillColor;
-	}
-
-	/**
-	 * Setzt die Füllfarbe auf die angegebene Farbe.
-	 *
-	 * @param color Die neue Füllfarbe oder {@code null}.
-	 * @see Color
-	 */
-	public void setFillColor( Color color ) {
-		fillColor = color;
-	}
-
-	/**
-	 * Setzt die Füllfarbe auf die angegebene Farbe und setzt die Transparenz
-	 * auf den angegebenen Wert. 0 is komplett durchsichtig und 255 komplett
-	 * deckend.
-	 *
-	 * @param color Die neue Füllfarbe oder {@code null}.
-	 * @param alpha Ein Transparenzwert zwischen 0 und 255.
-	 * @see Color#Color(Color, int)
-	 */
-	public void setFillColor( Color color, int alpha ) {
-		setFillColor(new Color(color, alpha));
-	}
-
-	/**
-	 * Setzt die Füllfarbe auf einen Grauwert mit der angegebenen Intensität. 0
-	 * entspricht schwarz, 255 entspricht weiß.
-	 *
-	 * @param gray Ein Grauwert zwischen 0 und 255.
-	 * @see Color#Color(int)
-	 */
-	public void setFillColor( int gray ) {
-		setFillColor(gray, gray, gray, 255);
-	}
-
-	/**
-	 * Setzt die Füllfarbe auf einen Grauwert mit der angegebenen Intensität und
-	 * dem angegebenen Transparenzwert. Der Grauwert 0 entspricht schwarz, 255
-	 * entspricht weiß.
-	 *
-	 * @param gray Ein Grauwert zwischen 0 und 255.
-	 * @param alpha Ein Transparenzwert zwischen 0 und 255.
-	 * @see Color#Color(int, int)
-	 */
-	public void setFillColor( int gray, int alpha ) {
-		setFillColor(gray, gray, gray, alpha);
-	}
-
-	/**
-	 * Setzt die Füllfarbe auf die Farbe mit den angegebenen Rot-, Grün- und
-	 * Blauanteilen.
-	 *
-	 * @param red Der Rotanteil der Farbe zwischen 0 und 255.
-	 * @param green Der Grünanteil der Farbe zwischen 0 und 255.
-	 * @param blue Der Blauanteil der Farbe zwischen 0 und 255.
-	 * @see Color#Color(int, int, int)
-	 * @see <a
-	 * 	href="https://de.wikipedia.org/wiki/RGB-Farbraum">https://de.wikipedia.org/wiki/RGB-Farbraum</a>
-	 */
-	public void setFillColor( int red, int green, int blue ) {
-		setFillColor(red, green, blue, 255);
-	}
-
-	/**
-	 * Setzt die Füllfarbe auf die Farbe mit den angegebenen Rot-, Grün- und
-	 * Blauanteilen und dem angegebenen Transparenzwert.
-	 *
-	 * @param red Der Rotanteil der Farbe zwischen 0 und 255.
-	 * @param green Der Grünanteil der Farbe zwischen 0 und 255.
-	 * @param blue Der Blauanteil der Farbe zwischen 0 und 255.
-	 * @param alpha Ein Transparenzwert zwischen 0 und 25
-	 * @see Color#Color(int, int, int, int)
-	 * @see <a
-	 * 	href="https://de.wikipedia.org/wiki/RGB-Farbraum">https://de.wikipedia.org/wiki/RGB-Farbraum</a>
-	 */
-	public void setFillColor( int red, int green, int blue, int alpha ) {
-		setFillColor(new Color(red, green, blue, alpha));
-	}
-
-	/**
-	 * Entfernt die Füllung der Form.
-	 */
-	public void noFill() {
-		setFillColor(null);
-		noGradient();
-	}
-
-	/**
-	 * Setzt die Füllfarbe auf den Standardwert zurück.
-	 *
-	 * @see schule.ngb.zm.Constants#DEFAULT_FILLCOLOR
-	 */
-	public void resetFill() {
-		setFillColor(DEFAULT_FILLCOLOR);
-		noGradient();
-	}
-
-	/**
-	 * Setzt die Füllung auf einen linearen Farbverlauf, der am Punkt
-	 * ({@code fromX}, {@code fromY}) mit der Farbe {@code from} startet und am
-	 * Punkt (({@code toX}, {@code toY}) mit der Farbe {@code to} endet.
-	 *
-	 * @param fromX x-Koordinate des Startpunktes.
-	 * @param fromY y-Koordinate des Startpunktes.
-	 * @param from Farbe am Startpunkt.
-	 * @param toX x-Koordinate des Endpunktes.
-	 * @param toY y-Koordinate des Endpunktes.
-	 * @param to Farbe am Endpunkt.
-	 */
-	public void setGradient( double fromX, double fromY, Color from, double toX, double toY, Color to ) {
-		setFillColor(from);
-		fill = new GradientPaint(
-			(float) fromX, (float) fromY, from.getJavaColor(),
-			(float) toX, (float) toY, to.getJavaColor()
-		);
-	}
-
-	/**
-	 * Setzt die Füllung auf einen kreisförmigen (radialen) Farbverlauf, mit dem
-	 * Zentrum im Punkt ({@code centerX}, {@code centerY}) und dem angegebenen
-	 * Radius. Der Verlauf starte im Zentrum mit der Farbe {@code from} und
-	 * endet am Rand des durch den Radius beschriebenen Kreises mit der Farbe
-	 * {@code to}.
-	 *
-	 * @param centerX x-Koordinate des Kreismittelpunktes.
-	 * @param centerY y-Koordinate des Kreismittelpunktes.
-	 * @param radius Radius des Kreises.
-	 * @param from Farbe im Zentrum des Kreises.
-	 * @param to Farbe am Rand des Kreises.
-	 */
-	public void setGradient( double centerX, double centerY, double radius, Color from, Color to ) {
-		setFillColor(from);
-		fill = new RadialGradientPaint(
-			(float) centerX, (float) centerY, (float) radius,
-			new float[]{0f, 1f},
-			new java.awt.Color[]{from.getJavaColor(), to.getJavaColor()});
-	}
-
-	/**
-	 * Entfernt den Farbverlauf von der Form.
-	 */
-	public void noGradient() {
-		fill = null;
-	}
-
-	/**
-	 * Hilfsmethode für Unterklassen, um die angegebene Form mit der aktuellen
-	 * Füllung auf den Grafik-Kontext zu zeichnen. Die Methode verändert
-	 * gegebenenfalls die aktuelle Farbe des Grafikobjekts und setzt sie nicht
-	 * auf den Ursprungswert zurück, wie von {@link #draw(Graphics2D)}
-	 * gefordert. Dies sollte die aufrufende Unterklasse übernehmen.
-	 *
-	 * @param shape Die zu zeichnende Java-AWT Form
-	 * @param graphics Das Grafikobjekt.
-	 */
-	protected void fillShape( java.awt.Shape shape, Graphics2D graphics ) {
-		if( fill != null ) {
-			graphics.setPaint(fill);
-			graphics.fill(shape);
-		} else if( fillColor != null && fillColor.getAlpha() > 0 ) {
-			graphics.setColor(fillColor.getJavaColor());
-			graphics.fill(shape);
-		}
-	}
-
-}

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

@@ -1,8 +1,10 @@
 package schule.ngb.zm.shapes;
 
+import schule.ngb.zm.BasicDrawable;
+import schule.ngb.zm.Fillable;
 import schule.ngb.zm.Options;
+import schule.ngb.zm.Strokeable;
 
-import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.geom.AffineTransform;
 import java.awt.geom.Point2D;
@@ -14,7 +16,7 @@ import java.awt.geom.Point2D;
  * <p>
  * Neben den abstrakten Methoden implementieren Unterklassen mindestens zwei
  * Konstruktoren. Einen Konstruktor, der die Form mit vom Nutzer gegebenen
- * Parametern initialisiert und einen, der die Werten einer anderen Form
+ * Parametern initialisiert und einen, der die Werte einer anderen Form
  * desselben Typs übernimmt. In der Klasse {@link Circle} sind die Konstruktoren
  * beispielsweise so implementiert:
  *
@@ -34,7 +36,7 @@ import java.awt.geom.Point2D;
  * eine {@link #equals(Object)} Methode.
  */
 @SuppressWarnings( "unused" )
-public abstract class Shape extends FilledShape {
+public abstract class Shape extends BasicDrawable {
 
 	/**
 	 * x-Koordinate der Form.
@@ -56,11 +58,6 @@ public abstract class Shape extends FilledShape {
 	 */
 	protected double scale = 1.0;
 
-	/**
-	 * Ob die Form angezeigt werden soll.
-	 */
-	protected boolean visible = true;
-
 	/**
 	 * Ankerpunkt der Form.
 	 */
@@ -84,38 +81,6 @@ public abstract class Shape extends FilledShape {
 		this.y = y;
 	}
 
-	/**
-	 * Ob die Form angezeigt wird oder nicht.
-	 *
-	 * @return {@code true}, wenn die From angezeigt werden soll, {@code false}
-	 * 	sonst.
-	 */
-	public boolean isVisible() {
-		return visible;
-	}
-
-	/**
-	 * Versteckt die Form.
-	 */
-	public void hide() {
-		visible = false;
-	}
-
-	/**
-	 * Zeigt die Form an.
-	 */
-	public void show() {
-		visible = true;
-	}
-
-	/**
-	 * Versteckt die Form, wenn sie derzeit angezeigt wird und zeigt sie
-	 * andernfalls an.
-	 */
-	public void toggle() {
-		visible = !visible;
-	}
-
 	/**
 	 * Gibt die x-Koordinate der Form zurück.
 	 *
@@ -180,6 +145,19 @@ public abstract class Shape extends FilledShape {
 	 */
 	public abstract double getHeight();
 
+	@Override
+	public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to, Options.Direction dir ) {
+		Point2D apDir = getAbsAnchorPoint(dir);
+		Point2D apInv = getAbsAnchorPoint(dir.inverse());
+		setGradient(apInv.getX(), apInv.getY(), from, apDir.getX(), apDir.getY(), to);
+	}
+
+	@Override
+	public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to ) {
+		Point2D ap = getAbsAnchorPoint(CENTER);
+		setGradient(ap.getX(), ap.getY(), Math.min(ap.getX(), ap.getY()), from, to);
+	}
+
 	/**
 	 * Gibt die Rotation in Grad zurück.
 	 *
@@ -191,6 +169,7 @@ public abstract class Shape extends FilledShape {
 
 	/**
 	 * Dreht die Form um den angegebenen Winkel um ihren Ankerpunkt.
+	 *
 	 * @param angle Drehwinkel in Grad.
 	 */
 	public void rotate( double angle ) {
@@ -227,6 +206,7 @@ public abstract class Shape extends FilledShape {
 	public double getScale() {
 		return scale;
 	}
+
 	public void scale( double factor ) {
 		scale = factor;
 	}
@@ -235,17 +215,6 @@ public abstract class Shape extends FilledShape {
 		scale(scale * factor);
 	}
 
-	public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to, Options.Direction dir ) {
-		Point2D apDir = getAbsAnchorPoint(dir);
-		Point2D apInv = getAbsAnchorPoint(dir.inverse());
-		setGradient(apInv.getX(), apInv.getY(), from, apDir.getX(), apDir.getY(), to);
-	}
-
-	public void setGradient( schule.ngb.zm.Color from, schule.ngb.zm.Color to ) {
-		Point2D ap = getAbsAnchorPoint(CENTER);
-		setGradient(ap.getX(), ap.getY(), Math.min(ap.getX(), ap.getY()), from, to);
-	}
-
 	public Options.Direction getAnchor() {
 		return anchor;
 	}
@@ -268,28 +237,25 @@ public abstract class Shape extends FilledShape {
 	}
 
 	/**
-	 * Bestimmt die relativen Koordinaten des angegebenen Ankerpunkt basierend
+	 * Bestimmt die relativen Koordinaten des angegebenen Ankerpunkts basierend
 	 * auf der angegebenen Breite und Höhe des umschließenden Rechtecks.
 	 * <p>
-	 * Die Koordinaten des Ankerpunkt werden relativ zur oberen linken Ecke des
-	 * Rechtecks mit der Breite {@code width} und der Höhe {@code height}
+	 * Die Koordinaten des Ankerpunktes werden relativ zur oberen linken Ecke
+	 * des Rechtecks mit der Breite {@code width} und der Höhe {@code height}
 	 * bestimmt.
 	 *
-	 * @param width Breite des umschließdenden Rechtecks.
-	 * @param height Höhe des umschließdenden Rechtecks.
+	 * @param width Breite des umschließenden Rechtecks.
+	 * @param height Höhe des umschließenden Rechtecks.
 	 * @param anchor Gesuchter Ankerpunkt.
 	 * @return Ein {@link Point2D} mit den relativen Koordinaten.
 	 */
-	protected static Point2D.Double getAnchorPoint( double width, double height, Options.Direction anchor ) {
+	public static Point2D.Double getAnchorPoint( double width, double height, Options.Direction anchor ) {
 		double wHalf = width * .5, hHalf = height * .5;
 
-		// anchor == CENTER
-		Point2D.Double anchorPoint = new Point2D.Double(
+		return new Point2D.Double(
 			wHalf + wHalf * anchor.x,
 			hHalf + hHalf * anchor.y
 		);
-
-		return anchorPoint;
 	}
 
 	/**
@@ -303,12 +269,10 @@ public abstract class Shape extends FilledShape {
 		double wHalf = getWidth() * .5, hHalf = getHeight() * .5;
 
 		// anchor == CENTER
-		Point2D.Double anchorPoint = new Point2D.Double(
+		return new Point2D.Double(
 			wHalf * (anchor.x - this.anchor.x),
 			hHalf * (anchor.y - this.anchor.y)
 		);
-
-		return anchorPoint;
 	}
 
 	/**
@@ -352,8 +316,8 @@ public abstract class Shape extends FilledShape {
 			setStrokeWeight(shape.getStrokeWeight());
 			setStrokeType(shape.getStrokeType());
 			visible = shape.isVisible();
-			rotation = shape.rotation;
-			scale(shape.scale);
+			rotation = shape.getRotation();
+			scale(shape.getScale());
 			setAnchor(shape.getAnchor());
 		}
 	}
@@ -384,19 +348,10 @@ public abstract class Shape extends FilledShape {
 	 * zurück. Intern werden die AWT Shapes benutzt, um sie auf den
 	 * {@link Graphics2D Grafikkontext} zu zeichnen.
 	 * <p>
-	 * Da die AWT-Shape bei jedem Zeichnen (also mindestens einmal pro Frame)
-	 * benötigt wird, wird das aktuelle Shape-Objekt in {@link #awtShape}
-	 * zwischengespeichert. Bei Änderungen der Objekteigenschaften muss daher
-	 * intern {@link #invalidate()} aufgerufen werden, damit beim nächsten
-	 * Aufruf von {@link #draw(Graphics2D)} die Shape mit einem Aufurf von
-	 * {@code getShape()} neu erzeugt wird. Unterklassen können aber auch die
-	 * zwischengespeicherte Shape direkt modifizieren, um eine Neugenerierung zu
-	 * vermeiden.
-	 * <p>
-	 * Wenn diese Form nicht durch eine AWT-Shape dargstellt wird, kann die
+	 * Wenn diese Form nicht durch eine AWT-Shape dargestellt wird, kann die
 	 * Methode {@code null} zurückgeben.
 	 *
-	 * @return Eine Java-AWT {@code Shape} die diess Form repräsentiert oder
+	 * @return Eine Java-AWT {@code Shape} die diese Form repräsentiert oder
 	 *    {@code null}.
 	 */
 	public abstract java.awt.Shape getShape();
@@ -560,7 +515,7 @@ public abstract class Shape extends FilledShape {
 				shape = transform.createTransformedShape(shape);
 			}
 
-			Color currentColor = graphics.getColor();
+			java.awt.Color currentColor = graphics.getColor();
 			fillShape(shape, graphics);
 			strokeShape(shape, graphics);
 			graphics.setColor(currentColor);
@@ -573,8 +528,8 @@ public abstract class Shape extends FilledShape {
 	 * verglichen. Unterklassen überschreiben die Methode, um weitere
 	 * Eigenschaften zu berücksichtigen.
 	 * <p>
-	 * Die Eigenschaften von {@link FilledShape} und {@link StrokedShape} werden
-	 * nicht verglichen.
+	 * Die Eigenschaften, die durch {@link Fillable} und {@link Strokeable}
+	 * impliziert werden, werden nicht verglichen.
 	 *
 	 * @param o Ein anderes Objekt.
 	 * @return
@@ -590,4 +545,43 @@ public abstract class Shape extends FilledShape {
 			Double.compare(pShape.scale, scale) == 0;
 	}
 
+	/**
+	 * Hilfsmethode für Unterklassen, um die angegebene Form mit den aktuellen
+	 * Kontureigenschaften auf den Grafik-Kontext zu zeichnen. Die Methode
+	 * verändert gegebenenfalls die aktuelle Farbe des Grafikobjekts und setzt
+	 * sie nicht auf den Ursprungswert zurück, wie von {@link #draw(Graphics2D)}
+	 * gefordert. Dies sollte die aufrufende Unterklasse übernehmen.
+	 *
+	 * @param shape Die zu zeichnende Java-AWT Form
+	 * @param graphics Das Grafikobjekt.
+	 */
+	protected void strokeShape( java.awt.Shape shape, Graphics2D graphics ) {
+		if( strokeColor != null && strokeColor.getAlpha() > 0
+			&& strokeWeight > 0.0 ) {
+			graphics.setColor(strokeColor.getJavaColor());
+			graphics.setStroke(getStroke());
+			graphics.draw(shape);
+		}
+	}
+
+	/**
+	 * Hilfsmethode für Unterklassen, um die angegebene Form mit der aktuellen
+	 * Füllung auf den Grafik-Kontext zu zeichnen. Die Methode verändert
+	 * gegebenenfalls die aktuelle Farbe des Grafikobjekts und setzt sie nicht
+	 * auf den Ursprungswert zurück, wie von {@link #draw(Graphics2D)}
+	 * gefordert. Dies sollte die aufrufende Unterklasse übernehmen.
+	 *
+	 * @param shape Die zu zeichnende Java-AWT Form
+	 * @param graphics Das Grafikobjekt.
+	 */
+	protected void fillShape( java.awt.Shape shape, Graphics2D graphics ) {
+		if( fill != null ) {
+			graphics.setPaint(fill);
+			graphics.fill(shape);
+		} else if( fillColor != null && fillColor.getAlpha() > 0 ) {
+			graphics.setColor(fillColor.getJavaColor());
+			graphics.fill(shape);
+		}
+	}
+
 }

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

@@ -7,6 +7,7 @@ import java.awt.geom.AffineTransform;
 import java.awt.geom.Path2D;
 import java.awt.geom.Point2D;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -35,7 +36,7 @@ import java.util.List;
  * {@link #arrangeInGrid(int, Options.Direction, double, int)} und
  * {@link #align(Options.Direction)} verwendet werden, die jeweils die Position
  * der Formen in der Gruppe ändern und nicht die Position der Gruppe selbst (so
- * wie z.B. {@link #alignTo(Shape, Options.Direction)}.
+ * wie z.B. {@link #alignTo(Shape, Options.Direction)}).
  */
 public class ShapeGroup extends Shape {
 
@@ -43,7 +44,7 @@ public class ShapeGroup extends Shape {
 
 	public static final int ARRANGE_COLS = 1;
 
-	private List<Shape> shapes;
+	private final List<Shape> shapes;
 
 	private double groupWidth = -1.0;
 
@@ -51,7 +52,7 @@ public class ShapeGroup extends Shape {
 
 	public ShapeGroup() {
 		super();
-		shapes = new ArrayList<>(10);
+		shapes = Collections.synchronizedList(new ArrayList<>(10));
 	}
 
 	public ShapeGroup( double x, double y ) {
@@ -62,9 +63,7 @@ public class ShapeGroup extends Shape {
 	public ShapeGroup( double x, double y, Shape... shapes ) {
 		super(x, y);
 		this.shapes = new ArrayList<>(shapes.length);
-		for( Shape pShape : shapes ) {
-			this.shapes.add(pShape);
-		}
+		Collections.addAll(this.shapes, shapes);
 	}
 
 	public Shape copy() {
@@ -99,9 +98,11 @@ public class ShapeGroup extends Shape {
 
 	public <ShapeType extends Shape> List<ShapeType> getShapes( Class<ShapeType> typeClass ) {
 		LinkedList<ShapeType> list = new LinkedList<>();
-		for( Shape s : shapes ) {
-			if( typeClass.isInstance(s) ) {
-				list.add((ShapeType) s);
+		synchronized( shapes ) {
+			for( Shape shape : shapes ) {
+				if( typeClass.isInstance(shape) ) {
+					list.add(typeClass.cast(shape));
+				}
 			}
 		}
 		return list;
@@ -170,19 +171,15 @@ public class ShapeGroup extends Shape {
 		int rows, cols;
 		if( mode == ARRANGE_ROWS ) {
 			rows = n;
-			cols = (int) ceil(shapes.size() / n);
+			cols = (int) ceil(shapes.size() / (double)n);
 		} else {
 			cols = n;
-			rows = (int) ceil(shapes.size() / n);
+			rows = (int) ceil(shapes.size() / (double)n);
 		}
 
 		// Calculate grid cell size
-		double maxHeight = shapes.stream().mapToDouble(
-			( s ) -> s.getHeight()
-		).reduce(0.0, Double::max);
-		double maxWidth = shapes.stream().mapToDouble(
-			( s ) -> s.getWidth()
-		).reduce(0.0, Double::max);
+		double maxHeight = shapes.stream().mapToDouble(Shape::getHeight).reduce(0.0, Double::max);
+		double maxWidth = shapes.stream().mapToDouble(Shape::getWidth).reduce(0.0, Double::max);
 		double halfHeight = maxHeight * .5;
 		double halfWidth = maxWidth * .5;
 

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

@@ -24,6 +24,7 @@ public class Text extends Shape {
 	public Text( double x, double y, String text ) {
 		this(x, y, text, new Font(Font.SANS_SERIF, Font.PLAIN, DEFAULT_FONTSIZE));
 	}
+
 	public Text( double x, double y, String text, String fontname ) {
 		super(x, y);
 		Font userfont = FontLoader.loadFont(fontname);
@@ -60,29 +61,58 @@ public class Text extends Shape {
 		return height;
 	}
 
-	public void setFont( String fontname ) {
-		Font newFont = FontLoader.loadFont(fontname);
+	public Font getFont() {
+		return font;
+	}
+
+	public void setFont( Font newFont ) {
+		//font = newFont.deriveFont(font.getStyle(), font.getSize2D());
+		font = new Font(newFont.getFontName(), newFont.getStyle(), newFont.getSize());
+		//font = newFont;
+		calculateBounds();
+	}
+
+	public void setFont( String fontName ) {
+		Font newFont = FontLoader.loadFont(fontName);
 		if( newFont != null ) {
 			setFont(newFont);
 		}
 	}
 
-	public void setFont( Font newFont ) {
-		font = newFont.deriveFont(font.getSize2D());
+	public void setFont( String fontName, double fontSize ) {
+		Font newFont = FontLoader.loadFont(fontName);
+		if( newFont != null ) {
+			setFont(newFont);
+		}
+		font = newFont.deriveFont((float) fontSize);
 		calculateBounds();
 	}
 
-	public Font getFont() {
-		return font;
+	public void setFont( String fontName, double fontSize, int style ) {
+		Font newFont = FontLoader.loadFont(fontName);
+		if( newFont != null ) {
+			setFont(newFont);
+		}
+		font = newFont.deriveFont(style, (float) fontSize);
+		calculateBounds();
 	}
 
-	public void setFontsize( double size ) {
+	public double getFontSize() {
+		return font.getSize2D();
+	}
+
+	public void setFontSize( double size ) {
 		font = font.deriveFont((float) size);
 		calculateBounds();
 	}
 
-	public double getFontsize() {
-		return font.getSize2D();
+	public int getFontStyle() {
+		return font.getStyle();
+	}
+
+	public void setFontStyle( int fontStyle ) {
+		font = font.deriveFont(fontStyle);
+		calculateBounds();
 	}
 
 	public String getText() {
@@ -151,19 +181,19 @@ public class Text extends Shape {
 
 	@Override
 	public void copyFrom( Shape shape ) {
-		super.copyFrom(shape);
 		if( shape instanceof Text ) {
 			Text pText = (Text) shape;
 			this.text = pText.getText();
 			this.font = pText.getFont();
-			calculateBounds();
 		}
+		super.copyFrom(shape);
+		calculateBounds();
 	}
 
 	@Override
 	public void scale( double factor ) {
 		super.scale(factor);
-		setFontsize(font.getSize2D() * factor);
+		setFontSize(font.getSize2D() * factor);
 	}
 
 	@Override
@@ -191,7 +221,7 @@ public class Text extends Shape {
 		if( strokeColor != null && strokeColor.getAlpha() > 0
 			&& strokeWeight > 0.0 ) {
 			graphics.setColor(strokeColor.getJavaColor());
-			graphics.setStroke(createStroke());
+			graphics.setStroke(getStroke());
 			graphics.drawRect(0, 0, width, height);
 		}
 

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

@@ -9,6 +9,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 
+@SuppressWarnings("unused")
 public class BarChart extends Rectangle {
 
 	public static String DEFAULT_LABEL = "%.2f";
@@ -105,10 +106,10 @@ public class BarChart extends Rectangle {
 	}
 
 	public void addValue( double pValue, Color pColor ) {
-		addValue(pValue, pColor, String.format(DEFAULT_LABEL, pValue));
+		addValue(pValue, String.format(DEFAULT_LABEL, pValue), pColor);
 	}
 
-	public void addValue( double pValue, Color pColor, String pLabel ) {
+	public void addValue( double pValue, String pLabel, Color pColor ) {
 		addValue(new BasicChartValue(pValue, pLabel, pColor));
 	}
 
@@ -288,7 +289,7 @@ public class BarChart extends Rectangle {
 			barY += barHeight + gap;
 		}
 		graphics.setColor(getStrokeColor().getJavaColor());
-		graphics.setStroke(createStroke());
+		graphics.setStroke(getStroke());
 		if( inverted ) {
 			graphics.drawLine((int) width, 0, (int) width, (int) height);
 		} else {
@@ -360,7 +361,7 @@ public class BarChart extends Rectangle {
 		}
 
 		graphics.setColor(getStrokeColor().getJavaColor());
-		graphics.setStroke(createStroke());
+		graphics.setStroke(getStroke());
 		if( inverted ) {
 			graphics.drawLine(0, 0, (int) width, 0);
 		} else {

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/shapes/charts/ChartAxes.java

@@ -52,7 +52,7 @@ public class ChartAxes extends Rectangle {
 		}
 
 		graphics.setColor(strokeColor.getJavaColor());
-		graphics.setStroke(createStroke());
+		graphics.setStroke(getStroke());
 		graphics.drawLine(0, (int)(height), (int)((xMax-xMin) * xUnit), (int)(height));
 		graphics.drawLine(0, (int)(height), 0, (int)(height - (yMax-yMin) * yUnit));
 		if( showArrows ) {

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

@@ -91,7 +91,7 @@ public class LineChart extends Rectangle {
 		for( ChartValue lcv : val ) {
 			if( drawLines && lastLcv != null ) {
 				graphics.setColor(getStrokeColor().getJavaColor());
-				graphics.setStroke(createStroke());
+				graphics.setStroke(getStroke());
 				graphics.drawLine((int)(lastLcv.getX()*xUnit), (int)(height - lastLcv.getValue()*yUnit), (int)(lcv.getX()*xUnit), (int)(height - lcv.getValue()*yUnit));
 				drawDot(graphics, lastLcv, xUnit, yUnit);
 			}

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

@@ -326,7 +326,7 @@ public class PieChart extends Circle {
 		}
 
 		graphics.setColor(getStrokeColor().getJavaColor());
-		graphics.setStroke(createStroke());
+		graphics.setStroke(getStroke());
 		graphics.drawOval(0, 0, (int) (radius * 2), (int) (radius * 2));
 
 		graphics.setTransform(originalTransform);

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

@@ -4,55 +4,134 @@ import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
+/**
+ * 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
+ * Methoden verändert werden kann.
+ * <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 Objekte abgerufen werden.
+ * <p>
+ * Handelt es sich bei den Objekten um Zahlen, dann merkt sich ein
+ * {@code Counter} auch das Maximum, das Minimum, die Summe und den Durchschnitt
+ * der gezählten Werte.
+ * <p>
+ * Ein Zähler kann auch komplette Arrays oder Listen von Zahlen zählen und die
+ * obigen Statistiken auswerten.
+ */
 @SuppressWarnings( "unused" )
 public final class Counter {
 
+	/**
+	 * Erstellt einen neuen {@code Counter}, der alle Integer im angegebenen
+	 * Array gezählt hat.
+	 *
+	 * @param values Die zu zählenden Werte.
+	 * @return Ein neuer {@code Counter}.
+	 */
+	public static Counter fromArray( int[] values ) {
+		return new Counter().countAll(values);
+	}
+
+	/**
+	 * Erstellt einen neuen {@code Counter}, der alle Doubles im angegebenen
+	 * Array gezählt hat.
+	 *
+	 * @param values Die zu zählenden Werte.
+	 * @return Ein neuer {@code Counter}.
+	 */
 	public static Counter fromArray( double[] values ) {
 		return new Counter().countAll(values);
 	}
 
+	/**
+	 * Erstellt einen neuen {@code Counter}, der alle Zahlen im angegebenen
+	 * Array gezählt hat.
+	 *
+	 * @param values Die zu zählenden Werte.
+	 * @return Ein neuer {@code Counter}.
+	 */
 	public static Counter fromArray( Number[] values ) {
 		return new Counter().countAll(values);
 	}
 
+	/**
+	 * Erstellt einen neuen {@code Counter}, der alle Zahlen in der angegebenen
+	 * Liste gezählt hat.
+	 *
+	 * @param values Die zu zählenden Werte.
+	 * @return Ein neuer {@code Counter}.
+	 */
 	public static Counter fromList( List<Number> values ) {
 		return new Counter().countAll(values);
 	}
 
-	private AtomicInteger count = new AtomicInteger(0);
+	/**
+	 * Aktuelle Anzahl gezählter Werte.
+	 */
+	private final AtomicInteger count = new AtomicInteger(0);
 
+	/**
+	 * Statistiken zu den gezählten Werten.
+	 */
 	private double min = Double.NaN, max = Double.NaN, sum = Double.NaN;
 
-	public void Counter() {
-
+	/**
+	 * Erstellt einen neuen, leeren {@code Counter}.
+	 */
+	public Counter() {
 	}
 
-	public void Counter( int initial ) {
+	/**
+	 * Ertstellt einen neuen {@code Counter}, der mit dem angegebenen Wert
+	 * initialisiert ist.
+	 *
+	 * @param initial Wert des Zählers zu Beginn.
+	 */
+	public Counter( int initial ) {
 		count.set(initial);
 	}
 
+	/**
+	 * @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;
@@ -61,11 +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);
@@ -77,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();
@@ -97,17 +214,33 @@ public final class Counter {
 			sum = Double.isNaN(sum) ? value : sum + value;
 			if( Double.isNaN(max) || max < value )
 				max = value;
-			if( Double.isNaN(min) ||min > value )
+			if( Double.isNaN(min) || min > value )
 				min = value;
 		}
 		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 ) {
@@ -118,25 +251,61 @@ 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 ) {
+		for( double value : values ) {
 			count(value);
 		}
 		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 ) {
+			count(value);
+		}
+		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 ) {
+		for( Number value : values ) {
 			count(value);
 		}
 		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 ) {
+		for( Number value : values ) {
 			count(value);
 		}
 		return this;

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

@@ -0,0 +1,327 @@
+package schule.ngb.zm.util;
+
+import schule.ngb.zm.Color;
+import schule.ngb.zm.Constants;
+import schule.ngb.zm.util.io.ImageLoader;
+
+import java.awt.Font;
+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 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 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 count Anzahl der Beispieldaten.
+	 * @return Ein Array mit den Beispieldaten.
+	 */
+	public static String[][] fakeUsers( int count ) {
+		return randomSample("users", count, ( line ) -> line.split(","), String[].class);
+	}
+
+	/**
+	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Vornamen.
+	 *
+	 * @param count Anzahl der Beispieldaten.
+	 * @return Ein Array mit den Beispieldaten.
+	 */
+	public static String[] fakeNames( int count ) {
+		return randomSample("users", count, ( line ) -> line.split(",")[0], String.class);
+	}
+
+
+	/**
+	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Namen (Vor- und
+	 * Nachname).
+	 *
+	 * @param count Anzahl der Beispieldaten.
+	 * @return Ein Array mit den Beispieldaten.
+	 */
+	public static String[] fakeFullnames( int count ) {
+		return randomSample("users", count, ( line ) -> {
+			String[] parts = line.split(",");
+			return parts[0] + " " + parts[1];
+		}, String.class);
+	}
+
+
+	/**
+	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Nutzernamen.
+	 *
+	 * @param count Anzahl der Beispieldaten.
+	 * @return Ein Array mit den Beispieldaten.
+	 */
+	public static String[] fakeUsernames( int count ) {
+		return randomSample("users", count, ( line ) -> line.split(",")[3], String.class);
+	}
+
+	/**
+	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger Passwörter.
+	 *
+	 * @param count Anzahl der Beispieldaten.
+	 * @return Ein Array mit den Beispieldaten.
+	 */
+	public static String[] fakePasswords( int count ) {
+		return randomSample("users", count, ( line ) -> line.split(",")[4], String.class);
+	}
+
+	/**
+	 * Erzeugt ein Array mit den angegebenen Anzahl zufälliger E-Mail-Adressen.
+	 *
+	 * @param count Anzahl der Beispieldaten.
+	 * @return Ein Array mit den Beispieldaten.
+	 */
+	public static String[] fakeEmails( int count ) {
+		return randomSample("users", count, ( line ) -> line.split(",")[5], String.class);
+	}
+
+	/**
+	 * 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;
+	}
+
+
+	/**
+	 * Erzeugt ein Platzhalter-Bild in der angegebenen Größe.
+	 * <p>
+	 * Das Bild ist ein aus dem Internet geladenes, zufälliges Motiv, dass unter
+	 * einer freien Lizenz (Creative Commons) steht.
+	 *
+	 * @param width Breite des Bildes.
+	 * @param height Höhe des Bildes.
+	 * @return Ein zufälliges Bild in der angegebenen Größe.
+	 */
+	public static BufferedImage fakeImage( int width, int height ) {
+		return fakeImage(width, height, true);
+	}
+
+	/**
+	 * Erzeugt ein Platzhalter-Bild in der angegebenen Größe.
+	 * <p>
+	 * Wenn {@code fromWeb} auf {@code true} gesetzt ist, wird ein zufälliges
+	 * Motiv, das unter einer freien Lizenz (Creative Commons) steht, geladen.
+	 * Bei {@code false} wird das Bild lokal generiert.
+	 *
+	 * @param width Breite des Bildes.
+	 * @param height Höhe des Bildes.
+	 * @param fromWeb Bei {@code true} wird das Bild aus dem Internet geladen,
+	 * 	bei {@code false} wird das Bild lokal erzeugt.
+	 * @return Ein zufälliges Bild in der angegebenen Größe.
+	 */
+	public static BufferedImage fakeImage( int width, int height, boolean fromWeb ) {
+		if( !fromWeb ) {
+			BufferedImage img = ImageLoader.createImage(width, height);
+			Graphics2D graphics = (Graphics2D) img.getGraphics().create();
+
+			String text = width + " x " + height;
+
+			Color clr = Constants.randomNiceColor();
+
+			graphics.setBackground(clr.getJavaColor());
+			graphics.clearRect(0, 0, width, height);
+
+			graphics.setColor(clr.textcolor().getJavaColor());
+			graphics.setFont(new Font(Font.SANS_SERIF, Font.PLAIN, (int) ((width + height) * 0.05)));
+			FontMetrics fontMerics = graphics.getFontMetrics();
+			LineMetrics lineMetrics = fontMerics.getLineMetrics(text, graphics);
+			graphics.drawString(text,
+				(width - fontMerics.stringWidth(text)) / 2,
+				(int) (height / 2 - lineMetrics.getDescent() + lineMetrics.getAscent() / 2)
+			);
+			graphics.dispose();
+
+			return img;
+		} else {
+			return ImageLoader.loadImage(String.format(FAKE_IMG_URL, width, height), false);
+		}
+	}
+
+	private Faker() {
+	}
+
+	private static final Log LOG = Log.getLogger(Faker.class);
+
+}

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

@@ -26,7 +26,8 @@ import static java.util.logging.Level.*;
  * Klasse nur genau ein {@code Log}-Objekt erstellt. Mehrere {@code Log}s nutzen
  * dann aber denselben {@code Logger}.
  * <p>
- * Die API orientiert sich lose an <a href="#">Log4j</a> und vereinfacht die
+ * Die API orientiert sich lose an <a
+ * href="https://logging.apache.org/log4j/2.x/">Log4j</a> und vereinfacht die
  * Nutzung der Java logging API für die häufigsten Anwendungsfälle.
  */
 public final class Log {
@@ -133,23 +134,13 @@ public final class Log {
 
 		if( System.getProperty("java.util.logging.SimpleFormatter.format") == null
 			&& LogManager.getLogManager().getProperty("java.util.logging.SimpleFormatter.format") == null ) {
-			// System.setProperty("java.util.logging.SimpleFormatter.format", DEFAULT_LOG_FORMAT);
 			rootLogger.addHandler(new StreamHandler(System.err, new LogFormatter()) {
 				@Override
-				public synchronized void publish(final LogRecord record) {
+				public synchronized void publish( final LogRecord record ) {
 					super.publish(record);
 					flush();
 				}
 			});
-			// rootLogger.setUseParentHandlers(false);
-		}
-		if( rootLogger.getUseParentHandlers() ) {
-			// This logger was not configured somewhere else
-			// Add a Handler and Formatter
-
-			//StreamHandler rootHandler = new StreamHandler(System.out, new SimpleFormatter());
-			//rootLogger.addHandler(rootHandler);
-			//rootLogger.setUseParentHandlers(false);
 		}
 
 		LOGGING_INIT = true;
@@ -208,26 +199,15 @@ public final class Log {
 		}
 	}
 
-	private String inferCallerName() {
-		StackTraceElement[] trace = new Throwable().getStackTrace();
-		for( int i = 0; i < trace.length; i++ ) {
-			/// if( trace[i].getClassName().equals(sourceClass.getName()) ) {
-			if( !trace[i].getClassName().equals(Log.class.getName()) ) {
-				return trace[i].getMethodName();
-			}
-		}
-		return "unknown";
-	}
-
 	private void doLog( Level level, final Throwable throwable, final Supplier<String> msgSupplier ) {
 		String clazz = sourceClass.getName();
 		String method = "unknown";
 
 		StackTraceElement[] trace = new Throwable().getStackTrace();
-		for( int i = 0; i < trace.length; i++ ) {
-			if( !trace[i].getClassName().equals(Log.class.getName()) ) {
-				clazz = trace[i].getClassName();
-				method = trace[i].getMethodName();
+		for( StackTraceElement stackTraceElement : trace ) {
+			if( !stackTraceElement.getClassName().equals(Log.class.getName()) ) {
+				clazz = stackTraceElement.getClassName();
+				method = stackTraceElement.getMethodName();
 				break;
 			}
 		}
@@ -350,9 +330,9 @@ public final class Log {
 			ZonedDateTime zdt = ZonedDateTime.ofInstant(
 				record.getInstant(), ZoneId.systemDefault());
 			String source;
-			if (record.getSourceClassName() != null) {
+			if( record.getSourceClassName() != null ) {
 				source = record.getSourceClassName();
-				if (record.getSourceMethodName() != null) {
+				if( record.getSourceMethodName() != null ) {
 					source += " " + record.getSourceMethodName();
 				}
 			} else {
@@ -360,7 +340,7 @@ public final class Log {
 			}
 			String message = formatMessage(record);
 			String throwable = "";
-			if (record.getThrown() != null) {
+			if( record.getThrown() != null ) {
 				StringWriter sw = new StringWriter();
 				PrintWriter pw = new PrintWriter(sw);
 				pw.println();
@@ -368,7 +348,7 @@ public final class Log {
 				pw.close();
 				throwable = sw.toString();
 			}
-			return String.format(DEFAULT_LOG_FORMAT,
+			return String.format(DEFAULT_DEBUG_FORMAT,
 				zdt,
 				source,
 				record.getLoggerName(),

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

@@ -3,13 +3,14 @@ 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
  * href="https://adrianb.io/2014/08/09/perlinnoise.html">Beschreibung von
  * FLAFLA2</a> implementiert.
  */
+@SuppressWarnings( "unused" )
 public class Noise {
 
 	private static final int N = 256;
@@ -17,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;
 
@@ -42,7 +43,7 @@ public class Noise {
 	/**
 	 * Initialisiert diesen Perlin-Noise mit dem angegebenen Zufallsgenerator.
 	 *
-	 * @param rand
+	 * @param rand Ein Zufallsgenerator-Objekt.
 	 */
 	public Noise( Random rand ) {
 		init(rand);

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

@@ -2,77 +2,189 @@ package schule.ngb.zm.util;
 
 import java.util.concurrent.TimeUnit;
 
+/**
+ * Helferklasse zur Zeitmessung im Nanosekundenbereich.
+ * <p>
+ * Mit einem {@code Timer} kann zum Beispiel die Laufzeit eines Algorithmus
+ * gemessen werden. Wie eine echte Stoppuhr läuft der {@code Timer} weiter, wenn
+ * nach einem {@link #stop()} wieder {@link #start()} aufgerufen wird. Soll die
+ * Zeitmessung wieder bei null beginnen, muss vorher {@link #reset()} genutzt
+ * werden.
+ * <p>
+ * Die gemessene Zeit kann in {@link #getMillis() Millisekunden} oder
+ * {@link #getSeconds() Sekunden} abgerufen werden. Wird eine noch größere
+ * Genauigkeit benötigt, können mit {@link #getTime(TimeUnit)} beliebige
+ * Zeiteinheiten (zum Beispiel {@link TimeUnit#NANOSECONDS Nanosekunden})
+ * abgerufen werden.
+ * <p>
+ * Die Zeit kann auch bei laufender Uhr abgefragt werden. In dem Fall wird die
+ * bis zu diesem Zeitpunkt gemessene Zeit zurückgegeben.
+ */
 @SuppressWarnings( "unused" )
 public final class Timer {
 
+	/**
+	 * Die Basiseinheit für die Zeitmessung.
+	 */
 	private final TimeUnit baseUnit;
 
+	/**
+	 * Ob die Zeitmessung gerade läuft.
+	 */
 	private boolean running = false;
 
-	private long starttime = -1;
+	/**
+	 * Startzeit der Zeitmessung. -1, wenn noch keine Messung gestartet wurde.
+	 */
+	private long start = -1;
 
+	/**
+	 * Zeit, die bisher bei allen Zeitmessungen, die gestoppt wurden, insgesamt
+	 * vergangen ist.
+	 */
 	private long elapsed = 0;
 
+	/**
+	 * Erstellt einen neuen {@code Timer} mit Millisekunden als Basiseinheit.
+	 */
 	public Timer() {
 		this(TimeUnit.MILLISECONDS);
 	}
 
+	/**
+	 * Erstellt einen {@code Timer}, der die angegebene Einheit als Basiseinheit
+	 * für {@link #getTime()} benutzt.
+	 * <p>
+	 * Um eine Zeitmessung in Nanosekunden durchzuführen, kann der {@code Timer}
+	 * beispielsweise so instanziiert werden:
+	 * <pre><code>
+	 * Timer clock = new Timer(TimeUnit.NANOSECONDS);
+	 * </code></pre>
+	 *
+	 * @param baseUnit Die Basiseinheit für die Zeitmessung.
+	 */
 	public Timer( TimeUnit baseUnit ) {
 		this.baseUnit = baseUnit;
 	}
 
+	/**
+	 * Ob die Zeitmessung gerade läuft.
+	 *
+	 * @return {@code true}, wenn die Zeitmessung mit {@link #start()} gestartet
+	 * 	wurde.
+	 */
 	public boolean isRunning() {
 		return running;
 	}
 
+	/**
+	 * Startet die Zeitmessung.
+	 * <p>
+	 * Wenn zuvor schon eine Zeitmessung gestartet wurde, wird die neue Messung
+	 * zur Summe aller Messungen hinzuaddiert. Soll die Messung bei null
+	 * starten, muss vorher {@link #reset()} verwendet werden:
+	 *
+	 * <pre><code>
+	 * // Timer auf null stellen und sofort starten
+	 * timer.reset().start();
+	 * </code></pre>
+	 *
+	 * @return Dieser {@code Timer} selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Timer start() {
-		starttime = System.nanoTime();
+		start = System.nanoTime();
 		running = true;
 
 		return this;
 	}
 
+	/**
+	 * 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).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Timer stop() {
+		if( running ) {
 			running = false;
-		elapsed += System.nanoTime() - starttime;
-
+			elapsed += System.nanoTime() - start;
+		}
 		return this;
 	}
 
+	/**
+	 * Setzt den {@code Timer} auf den Startzustand und löscht alle bisher
+	 * gemessenen Zeiten. Falls die Zeitmessung gerade läuft, stoppt sie nicht,
+	 * sondern startet vom Zeitpunkt des Aufrufs neu.
+	 *
+	 * @return Dieser {@code Timer} selbst (method chaining).
+	 */
 	@SuppressWarnings( "UnusedReturnValue" )
 	public Timer reset() {
-		running = false;
-		starttime = -1;
 		elapsed = 0;
+		start = -1;
+
+		if( running ) {
+			start = System.nanoTime();
+		}
 
 		return this;
 	}
 
+	/**
+	 * Gibt die Zeit in der Basiseinheit zurück.
+	 *
+	 * @return Die bisher insgesamt gemessene Zeit.
+	 */
 	public long getTime() {
 		return getTime(baseUnit);
 	}
 
+	/**
+	 * Gibt die Zeit in der angegebenen Einheit zurück.
+	 * <p>
+	 * Größere Zeiteinheiten werden gerundet und verlieren daher an Genauigkeit.
+	 * Eine Zeitmessung von 999 Millisekunden wird als 0 Sekunden
+	 * zurückgegeben.
+	 * <p>
+	 * Um genauere Ergebnisse zu erhalten, kann mit {@link #getMillis()} und
+	 * {@link #getSeconds()} die gemessene Zeit in Minuten beziehungsweise
+	 * Sekunden als Kommazahl abgefragt werden.
+	 *
+	 * @param unit Zeiteinheit
+	 * @return Die bisher insgesamt gemessene Zeit in der gewählten Zeiteinheit.
+	 */
 	public long getTime( TimeUnit unit ) {
 		if( running ) {
-			return unit.convert(System.nanoTime() - starttime + elapsed, TimeUnit.NANOSECONDS);
+			return unit.convert(System.nanoTime() - start + elapsed, TimeUnit.NANOSECONDS);
 		} else {
 			return unit.convert(elapsed, TimeUnit.NANOSECONDS);
 		}
 	}
 
+	/**
+	 * Gibt die gemessene Zeit in Millisekunden (gerundet) zurück.
+	 *
+	 * @return Die gemessene Zeit in ms.
+	 */
 	public int getMillis() {
 		if( running ) {
-			return (int) ((System.nanoTime() - starttime + elapsed) / 1000000);
+			return (int) ((System.nanoTime() - start + elapsed) / 1000000);
 		} else {
 			return (int) (elapsed / 1000000);
 		}
 	}
 
+	/**
+	 * Gibt die gemessene Zeit in Sekunden zurück.
+	 *
+	 * @return Die gemessene Zeit in s.
+	 */
 	public double getSeconds() {
 		if( running ) {
-			return (System.nanoTime() - starttime + elapsed) / 1000000000.0;
+			return (System.nanoTime() - start + elapsed) / 1000000000.0;
 		} else {
 			return elapsed / 1000000000.0;
 		}

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

@@ -1,9 +1,12 @@
 package schule.ngb.zm.util;
 
 import java.util.Objects;
-import java.util.function.Predicate;
 import java.util.function.Supplier;
 
+/**
+ * Statische Methoden, um Methodenparameter auf Gültigkeit zu prüfen.
+ */
+@SuppressWarnings( "UnusedReturnValue" )
 public class Validator {
 
 	public static final <T> T requireNotNull( T obj ) {
@@ -19,7 +22,7 @@ public class Validator {
 	}
 
 	public static final String requireNotEmpty( String str ) {
-		return requireNotEmpty(str, (Supplier<String>)null);
+		return requireNotEmpty(str, (Supplier<String>) null);
 	}
 
 	public static final String requireNotEmpty( String str, CharSequence msg ) {
@@ -33,7 +36,7 @@ public class Validator {
 	}
 
 	public static final int requirePositive( int i ) {
-		return requirePositive(i, (Supplier<String>)null);
+		return requirePositive(i, (Supplier<String>) null);
 	}
 
 	public static final int requirePositive( int i, CharSequence msg ) {
@@ -47,7 +50,7 @@ public class Validator {
 	}
 
 	public static final int requireNotNegative( int i ) {
-		return requireNotNegative(i, (Supplier<String>)null);
+		return requireNotNegative(i, (Supplier<String>) null);
 	}
 
 	public static final int requireNotNegative( int i, CharSequence msg ) {
@@ -61,7 +64,7 @@ public class Validator {
 	}
 
 	public static final int requireInRange( int i, int min, int max ) {
-		return requireInRange(i, min, max, (Supplier<String>)null);
+		return requireInRange(i, min, max, (Supplier<String>) null);
 	}
 
 	public static final int requireInRange( int i, int min, int max, CharSequence msg ) {
@@ -75,7 +78,7 @@ public class Validator {
 	}
 
 	public static final double requirePositive( double i ) {
-		return requirePositive(i, (Supplier<String>)null);
+		return requirePositive(i, (Supplier<String>) null);
 	}
 
 	public static final double requirePositive( double i, CharSequence msg ) {
@@ -89,7 +92,7 @@ public class Validator {
 	}
 
 	public static final double requireNotNegative( double i ) {
-		return requireNotNegative(i, (Supplier<String>)null);
+		return requireNotNegative(i, (Supplier<String>) null);
 	}
 
 	public static final double requireNotNegative( double i, CharSequence msg ) {
@@ -103,7 +106,7 @@ public class Validator {
 	}
 
 	public static final double requireInRange( double i, double min, double max ) {
-		return requireInRange(i, min, max, (Supplier<String>)null);
+		return requireInRange(i, min, max, (Supplier<String>) null);
 	}
 
 	public static final double requireInRange( double i, double min, double max, CharSequence msg ) {
@@ -138,7 +141,7 @@ public class Validator {
 
 
 	public static final <T> T[] requireNotEmpty( T[] arr ) {
-		return requireNotEmpty(arr, (Supplier<String>)null);
+		return requireNotEmpty(arr, (Supplier<String>) null);
 	}
 
 	public static final <T> T[] requireNotEmpty( T[] arr, CharSequence msg ) {
@@ -147,12 +150,12 @@ public class Validator {
 
 	public static final <T> T[] requireNotEmpty( T[] arr, Supplier<String> msg ) {
 		if( arr.length == 0 )
-			throw new IllegalArgumentException(msg == null ? String.format("Parameter array may not be empty") : msg.get());
+			throw new IllegalArgumentException(msg == null ? "Parameter array may not be empty" : msg.get());
 		return arr;
 	}
 
 	public static final <T> T[] requireSize( T[] arr, int size ) {
-		return requireSize(arr, size, (Supplier<String>)null);
+		return requireSize(arr, size, (Supplier<String>) null);
 	}
 
 	public static final <T> T[] requireSize( T[] arr, int size, CharSequence msg ) {
@@ -161,21 +164,21 @@ public class Validator {
 
 	public static final <T> T[] requireSize( T[] arr, int size, Supplier<String> msg ) {
 		if( arr.length != size )
-			throw new IllegalArgumentException(msg == null ? String.format("Parameter array must have <%d> elements (<%d> provided)", size) : msg.get());
+			throw new IllegalArgumentException(msg == null ? String.format("Parameter array must have <%d> elements (<%d> provided)", size, arr.length) : msg.get());
 		return arr;
 	}
 
 	public static final <T> T[] requireValid( T[] arr ) {
-		return requireValid(arr, (Supplier<String>)null);
+		return requireValid(arr, (Supplier<String>) null);
 	}
 
-	public static final<T> T[] requireValid( T[] arr, CharSequence msg ) {
+	public static final <T> T[] requireValid( T[] arr, CharSequence msg ) {
 		return requireValid(arr, msg::toString);
 	}
 
 	public static final <T> T[] requireValid( T[] arr, Supplier<String> msg ) {
 		if( arr == null || arr.length > 0 )
-			throw new IllegalArgumentException(msg == null ? String.format("Parameter array may not be null or empty") : msg.get());
+			throw new IllegalArgumentException(msg == null ? "Parameter array may not be null or empty" : msg.get());
 		return arr;
 	}
 

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

@@ -7,11 +7,65 @@ 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 CopyOnWriteArraySet<L> listeners;
+	private final CopyOnWriteArraySet<L> listeners;
 
-	private ConcurrentMap<String, BiConsumer<E, L>> eventRegistry;
+	private final ConcurrentMap<String, BiConsumer<E, L>> eventRegistry;
 
 	public EventDispatcher() {
 		listeners = new CopyOnWriteArraySet<>();
@@ -35,6 +89,7 @@ public class EventDispatcher<E, L extends Listener<E>> {
 		listeners.remove(listener);
 	}
 
+	@SuppressWarnings("unused")
 	public boolean hasListeners() {
 		return !listeners.isEmpty();
 	}
@@ -49,9 +104,7 @@ public class EventDispatcher<E, L extends Listener<E>> {
 
 		if( eventRegistered(eventKey) ) {
 			final BiConsumer<E, L> dispatcher = eventRegistry.get(eventKey);
-			listeners.forEach(( listener ) -> {
-				dispatcher.accept(event, listener);
-			});
+			listeners.forEach(( listener ) -> dispatcher.accept(event, listener));
 		}
 	}
 

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

@@ -1,7 +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

@@ -2,86 +2,196 @@ package schule.ngb.zm.util.io;
 
 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.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 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 Die Quelle der Textdatei.
+	 * @param charset Das zu verwendene {@code Charset}.
+	 * @return Eine Liste mit den Zeilen der Textdatei.
+	 */
 	public static List<String> loadLines( String source, Charset charset ) {
-		try {
-			return Files.readAllLines(Paths.get(ResourceStreamProvider.getResourceURL(source).toURI()), charset);
-		} catch( IOException | URISyntaxException ex ) {
+		try( BufferedReader reader = ResourceStreamProvider.getReader(source, charset) ) {
+			List<String> result = new ArrayList<>();
+
+			String line;
+			while( (line = reader.readLine()) != null ) {
+				result.add(line);
+			}
+
+			return result;
+		} catch( IOException ex ) {
 			LOG.error(ex, "Error while loading lines from source <%s>", source);
+			return Collections.emptyList();
+		}
 	}
 
-		return Collections.EMPTY_LIST;
-	}
-
+	/**
+	 * 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 {
-			return Files.readString(Paths.get(ResourceStreamProvider.getResourceURL(source).toURI()), charset);
-		} catch( IOException | URISyntaxException ex ) {
-			LOG.error(ex, "Error while loading text from source <%s>", source);
+		try( BufferedReader reader = ResourceStreamProvider.getReader(source, charset) ) {
+			StringBuilder result = new StringBuilder();
+
+			String line;
+			while( (line = reader.readLine()) != null ) {
+				result.append(line).append('\n');
 			}
 
+			return result.toString();
+		} catch( IOException ex ) {
+			LOG.error(ex, "Error while loading string from source <%s>", source);
 			return "";
 		}
+	}
 
+	/**
+	 * Lädt die Daten aus einer CSV-Datei in ein zweidimensionales
+	 * String-Array.
+	 * <p>
+	 * Der Aufruf entspricht
+	 * <pre><code>
+	 * FileLoader.loadCsv(source, ',', skipFirst, UTF8);
+	 * </code></pre>
+	 *
+	 * @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)
+	 */
 	public static String[][] loadCsv( String source, boolean skipFirst ) {
 		return loadCsv(source, ',', skipFirst, UTF8);
 	}
 
+	/**
+	 * 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 werden Inhalte, die das Trennzeichen {@code separator}
+	 * 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.)
+	 * <p>
+	 * Es wird auch keine erweiterte Inhaltserkennung ausgeführt, sondern alle
+	 * Inhalte als {@code String} gelesen. Die weitere Verarbeitung mit den
+	 * passenden Parser-Methoden (beispielsweise
+	 * {@link Double#parseDouble(String)}) obligt dem Nutzer.
+	 *
+	 * @param source Die Quelle der CSV-Daten.
+	 * @param separator Das verwendete Trennzeichen.
+	 * @param skipFirst Ob die erste Zeile übersprungen werden soll.
+	 * @param charset Die zu verwendende Zeichenkodierung.
+	 * @return Ein Array mit den Daten als {@code String}s.
+	 */
 	public static String[][] loadCsv( String source, char separator, boolean skipFirst, Charset charset ) {
-		try {
 		int n = skipFirst ? 1 : 0;
-			return Files
-				.lines(Paths.get(ResourceStreamProvider.getResourceURL(source).toURI()), charset)
-				.skip(n)
-				.map(
-					( line ) -> line.split(Character.toString(separator))
+		List<String> lines = loadLines(source, charset);
+		return lines.stream().skip(n).map(
+			//( line ) -> line.split(Character.toString(separator))
+			( line ) -> line.split("\\s*" + separator + "\\s*")
 		).toArray(String[][]::new);
-		} catch( IOException | URISyntaxException ex ) {
-			LOG.error(ex, "Error while loading csv source <%s>", source);
-		}
-
-		return new String[0][0];
 	}
 
 	public static double[][] loadValues( String source, char separator, boolean skipFirst ) {
 		return loadValues(source, separator, skipFirst, UTF8);
 	}
 
+	/**
+	 * Lädt Double-Werte aus einer CSV Datei in ein zweidimensionales Array.
+	 * <p>
+	 * Die gelesenen Strings werden mit {@link Double#parseDouble(String)} in
+	 * {@code double} umgeformt. Es leigt in der Verantwortung des Nutzers
+	 * sicherzustellen, dass die CSV-Datei auch nur Zahlen enthält, die korrekt
+	 * in {@code double} umgewandelt werden können. Zellen für die die
+	 * Umwandlung fehlschlägt werden mit 0.0 befüllt.
+	 * <p>
+	 * Die Methode unterliegt denselben Einschränkungen wie
+	 * {@link #loadCsv(String, char, boolean, Charset)}.
+	 *
+	 * @param source Die Quelle der CSV-Daten.
+	 * @param separator Das verwendete Trennzeichen.
+	 * @param skipFirst Ob die erste Zeile übersprungen werden soll.
+	 * @param charset Die zu verwendende Zeichenkodierung.
+	 * @return Ein Array mit den Daten als {@code String}s.
+	 */
 	public static double[][] loadValues( String source, char separator, boolean skipFirst, Charset charset ) {
-		try {
 		int n = skipFirst ? 1 : 0;
-			return Files
-				.lines(Paths.get(ResourceStreamProvider.getResourceURL(source).toURI()), charset)
-				.skip(n)
-				.map(
+		List<String> lines = loadLines(source, charset);
+		return lines.stream().skip(n).map(
 			( line ) -> Arrays
 				.stream(line.split(Character.toString(separator)))
 				.mapToDouble(
@@ -94,14 +204,9 @@ public final class FileLoader {
 					}
 				).toArray()
 		).toArray(double[][]::new);
-		} catch( IOException | URISyntaxException ex ) {
-			LOG.error(ex, "Error while loading double values from csv source <%s>", source);
 	}
 
-		return new double[0][0];
-	}
-
-	public FileLoader() {
+	private FileLoader() {
 	}
 
 	private static final Log LOG = Log.getLogger(FileLoader.class);

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

@@ -1,12 +1,14 @@
 package schule.ngb.zm.util.io;
 
 import schule.ngb.zm.util.Log;
+import schule.ngb.zm.util.Validator;
 
 import java.awt.Font;
 import java.awt.FontFormatException;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.MalformedURLException;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
@@ -18,23 +20,29 @@ public class FontLoader {
 	/**
 	 * Lädt eine Schrift aus einer Datei.
 	 * <p>
-	 * Die Schrift wird unter ihrem Dateinamen in den Schriftenspeicher geladen
-	 * und kann danach in der Zeichenmaschine benutzt werden.
-	 *
-	 * Ein Datei mit dem Namen "fonts/Font-Name.ttf" würde mit dem Namen
+	 * Die Methode kann eine Liste von Schriften bekommen und probiert diese
+	 * nacheinander zu laden. Die erste Schrift, die Fehlerfrei geladen werden
+	 * kann, wird zurückgegeben. Kann keine der Schriften geladen werden, ist das
+	 * Ergebnis {@code null}.
+	 * <p>
+	 * Die gefundene Schrift wird unter ihrem Dateinamen in den Schriftenspeicher
+	 * geladen und kann danach in der Zeichenmaschine benutzt werden.
+	 * <p>
+	 * Eine Datei mit dem Namen "fonts/Font-Name.ttf" würde mit dem Namen
 	 * "Font-Name" geladen und kann danach zum Beispiel in einem
 	 * {@link schule.ngb.zm.shapes.Text} mit {@code text.setFont("Font-Name");}
 	 * verwendet werden.
 	 *
 	 * @param source
-	 * @return
+	 * @return Die erste geladene Schrift oder {@code null}.
+	 * @see #loadFont(String, String)
 	 */
 	public static Font loadFont( String source ) {
 		String name = source;
 		// Dateipfad entfernen
 		int lastIndex = source.lastIndexOf(File.separatorChar);
 		if( lastIndex > -1 ) {
-			source.substring(lastIndex + 1);
+			source = source.substring(lastIndex + 1);
 		}
 		// Dateiendung entfernen
 		lastIndex = name.lastIndexOf('.');
@@ -45,10 +53,8 @@ public class FontLoader {
 	}
 
 	public static Font loadFont( String name, String source ) {
-		Objects.requireNonNull(source, "Font source may not be null");
-		if( source.length() == 0 ) {
-			throw new IllegalArgumentException("Font source may not be empty.");
-		}
+		Validator.requireNotNull(source,"Font source may not be null");
+		Validator.requireNotEmpty(source, "Font source may not be empty.");
 
 		if( fontCache.containsKey(name) ) {
 			LOG.trace("Retrieved font <%s> from font cache.", name);
@@ -57,7 +63,7 @@ public class FontLoader {
 
 		// Look for System fonts
 		Font font = Font.decode(source);
-		if( font != null && source.toLowerCase().contains(font.getFamily().toLowerCase()) ) {
+		if( source.toLowerCase().contains(font.getFamily().toLowerCase()) ) {
 			fontCache.put(name, font);
 			fontCache.put(source, font);
 			LOG.debug("Loaded system font for <%s>.", source);
@@ -85,6 +91,38 @@ public class FontLoader {
 		return font;
 	}
 
+	/**
+	 * Lädt eine Schrift aus einer Datei.
+	 * <p>
+	 * Die Methode kann eine Liste von Schriften bekommen und probiert diese
+	 * nacheinander zu laden. Die erste Schrift, die Fehlerfrei geladen werden
+	 * kann, wird zurückgegeben. Kann keine der Schriften geladen werden, ist das
+	 * Ergebnis {@code null}.
+	 * <p>
+	 * Die gefundene Schrift wird unter ihrem Dateinamen in den Schriftenspeicher
+	 * geladen und kann danach in der Zeichenmaschine benutzt werden.
+	 * <p>
+	 * Eine Datei mit dem Namen "fonts/Font-Name.ttf" würde mit dem Namen
+	 * "Font-Name" geladen und kann danach zum Beispiel in einem
+	 * {@link schule.ngb.zm.shapes.Text} mit {@code text.setFont("Font-Name");}
+	 * verwendet werden.
+	 *
+	 * @param name
+	 * @param sources
+	 * @return Die erste geladene Schrift oder {@code null}.
+	 * @see #loadFont(String, String)
+	 */
+	public static Font loadFonts( String name, String... sources ) {
+		for( String fontSource: sources ) {
+			// TODO: Ignore exceptions in this case and throw own at end?
+			Font font = loadFont(name, fontSource);
+			if( font != null ) {
+				return font;
+			}
+		}
+		return null;
+	}
+
 	private FontLoader() {
 	}
 

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

@@ -22,9 +22,9 @@ public final class ImageLoader {
 
 	public static boolean caching = true;
 
-	private static Map<String, SoftReference<BufferedImage>> imageCache = new ConcurrentHashMap<>();
+	private static final Map<String, SoftReference<BufferedImage>> imageCache = new ConcurrentHashMap<>();
 
-	private static SoftReference<BufferedImage> NOCACHE = new SoftReference<>(null);
+	private static final SoftReference<BufferedImage> NOCACHE = new SoftReference<>(null);
 
 	/**
 	 * Lädt ein Bild von der angegebenen Quelle {@code source}.
@@ -48,12 +48,12 @@ public final class ImageLoader {
 
 	/**
 	 * Lädt ein Bild von der angegebenen Quelle <var>source</var> und gibt das
-	 * Bild zurück oder {@code null}, wenn das Bild nicht geladen werden
-	 * konnte. Ist ein Bild mit der angegebenen Quelle im Cache, wird das
-	 * gespeicherte Bild zurückgegeben. Dies kann mit {@code caching = false}
-	 * verhindert werden.
+	 * Bild zurück oder {@code null}, wenn das Bild nicht geladen werden konnte.
+	 * Ist ein Bild mit der angegebenen Quelle im Cache, wird das gespeicherte
+	 * Bild zurückgegeben. Dies kann mit {@code caching = false} verhindert
+	 * werden.
 	 * <p>
-	 * Wurde das Chaching global deaktiviert, kann mit <code>caching =
+	 * Wurde das Caching global deaktiviert, kann mit <code>caching =
 	 * true</code> das Bild trotzdem aus dem Cache geladen werden, wenn es
 	 * vorhanden ist.
 	 *
@@ -113,9 +113,9 @@ public final class ImageLoader {
 	}
 
 	/**
-	 * Speiechert das angegebene Bild unter dem angegebenen Namen im Cache.
+	 * Speichert das angegebene Bild unter dem angegebenen Namen im Cache.
 	 * <p>
-	 * Exisitert zu {@code name} schon ein Bild im Zwischenspeicher
+	 * Existiert zu {@code name} schon ein Bild im Zwischenspeicher
 	 * ({@code ImageLoader.isCached(name) == true}), dann wird dieses
 	 * überschrieben.
 	 * <p>
@@ -149,10 +149,8 @@ public final class ImageLoader {
 	 * @param name Name des Bildes im Cache.
 	 */
 	public static void invalidateCache( final String name ) {
-		if( imageCache.containsKey(name) ) {
 		imageCache.remove(name);
 	}
-	}
 
 	/**
 	 * Speichert ein Bild als {@link SoftReference} im Cache.
@@ -211,7 +209,7 @@ public final class ImageLoader {
 	 * Bild zurückgegeben und nicht komplett neu geladen.
 	 * <p>
 	 * <b>Wichtig:</b> Bildreferenzen, die aus dem Cache geladen werden,
-	 * verweisen alle auf dasselbe Objekt. Änderungen schalgen sich daher in
+	 * verweisen alle auf dasselbe Objekt. Änderungen schlagen sich daher in
 	 * allen anderen Versionen des Bildes nieder (inklusive dem Bild im
 	 * Zwischenspeicher). Für Änderungen sollte daher immer
 	 * {@link #copyImage(BufferedImage) eine Kopie} des Bildes erstellt werden:
@@ -302,7 +300,7 @@ public final class ImageLoader {
 	 * @param file Die Zieldatei.
 	 * @param overwriteIfExists Bei {@code true} wird eine vorhandene Datei
 	 * 	überschrieben, bei {@code false} wird eine {@link IOException} geworfen,
-	 * 	wenn die Datei schon exisitiert.
+	 * 	wenn die Datei schon existiert.
 	 * @throws NullPointerException Falls {@code image} oder {@code file}
 	 *                              {@code null} ist.
 	 * @throws IOException          Falls es einen Fehler beim Speichern gab.
@@ -335,7 +333,7 @@ public final class ImageLoader {
 	 * @param file Die Zieldatei.
 	 * @param overwriteIfExists Bei {@code true} wird eine vorhandene Datei
 	 * 	überschrieben, bei {@code false} wird eine {@link IOException} geworfen,
-	 * 	wenn die Datei schon exisitiert.
+	 * 	wenn die Datei schon existiert.
 	 * @throws NullPointerException Falls {@code image} oder {@code file}
 	 *                              {@code null} ist.
 	 * @throws IOException          Falls es einen Fehler beim Speichern gab.

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

@@ -5,20 +5,72 @@ import schule.ngb.zm.util.Log;
 import schule.ngb.zm.util.Validator;
 
 import java.io.*;
+import java.net.URISyntaxException;
 import java.net.URL;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+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 {
 
 	/**
-	 * Sucht eine zur angegebenen Quelle passende Resource und öffnet einen
-	 * passenden {@link InputStream}. Die konkrete Art des Streams hängt davon
-	 * ab, welche Art an Resource gefunden wird:
+	 * Ermittelt zur angegebenen Quelle einen passenden {@link URL} (<em>Unified
+	 * 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}, dann wird ein
+	 *    ({@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} im Classpath enthalten ({@code getClassLoader().getResource(source) != null})?</li>
+	 * <li>Ansonsten erstelle ein {@link URL}-Objekt.</li>
+	 * </ol>
+	 * <p>
+	 * Ein {@code URL} für die erste gefundene Resource wird zurückgegeben.
+	 * <p>
+	 * 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 Ressource (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath oder Netzwerkressource)
+	 * @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 Ressource.
+	 */
+	public static URL getResourceURL( String source ) throws NullPointerException, IllegalArgumentException, IOException {
+		Validator.requireNotNull(source, "Resource source may not be null");
+		Validator.requireNotEmpty(source, "Resource source may not be empty.");
+
+		// Ist source ein valider Dateipfad?
+		File file = new File(source);
+		if( file.isFile() ) {
+			return file.toURI().toURL();
+		}
+		// Ist source im Classpath vorhanden?
+		URL url = Zeichenmaschine.class.getClassLoader().getResource(source);
+		if( url != null ) {
+			return url;
+		}
+		// Dann versuchen aus source direkt eine URL zu machen.
+		return new URL(source);
+	}
+
+	/**
+	 * 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 Ressource gefunden wird:
+	 * <ol>
+	 * <li>Ist {@code source} eine existierende Datei
+	 *    {@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>
@@ -28,153 +80,130 @@ 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,
-	 * 	Dateipfad im Classpath oder Netzwerkresource)
-	 * @return Ein {@code InputStream} für die Resource
+	 * @param source Eine Quelle für die Ressource (Absoluter Dateipfad,
+	 * 	Dateipfad im Classpath oder Netzwerkresource).
+	 * @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
-	 *                                  keine passende Resource gefunden wurde.
+	 * @throws IOException              Geworfen beim Öffnen des Streams zu
+	 *                                  einer bestehenden Ressource oder falls
+	 *                                  keine passende Ressource gefunden
+	 *                                  wurde.
 	 */
 	public static InputStream getInputStream( String source ) throws NullPointerException, IllegalArgumentException, IOException {
-		Validator.requireNotNull(source, "Resource source may not be null");
-		Validator.requireNotEmpty(source, "Resource source may not be empty.");
-
-		InputStream in = null;
-
-		// See if source is a readable file
-		File file = new File(source);
-		try {
-			if( file.isFile() ) {
-				in = new FileInputStream(file);
-			}
-		} catch( FileNotFoundException fnfex ) {
-			// Somehow an exception occurred, but we still try other sources
-			in = null;
-		}
-		// File does not exist, try other means
-		// load ressource relative to .class-file
-		if( in == null ) {
-			in = Zeichenmaschine.class.getResourceAsStream(source);
-		}
-
-		// relative to ClassLoader
-		if( in == null ) {
-			in = Zeichenmaschine.class.getClassLoader().getResourceAsStream(source);
-		}
-
-		// load form web or jar-file
-		if( in == null ) {
-			in = new URL(source).openStream();
-		}
-
-		// One of the above got a valid Stream,
-		// otherwise an Exception was thrown
-		return in;
-	}
-
-	public static InputStream getInputStream( File file ) throws IOException {
-		Validator.requireNotNull(file, "Provided file can't be null.");
-		return new FileInputStream(file);
-	}
-
-	public static InputStream getInputStream( URL url ) throws IOException {
-		Validator.requireNotNull(url, "Provided URL can't be null.");
-		return url.openStream();
+		return getResourceURL(source).openStream();
 	}
 
 	/**
-	 * Ermittelt zur angegebenen Quelle einen passenden {@link URL} (<em>Unified
-	 * Resource Locator</em>). Eine passende Datei-Resource 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} im Classpath enthalten ({@code getClassLoader().getResource(source) != null})?</li>
-	 * <li>Ansonten erstellt ein {@link URL}-Objekt.</li>
-	 * </ol>
+	 * Sucht eine zur angegebenen Quelle passende Ressource und öffnet einen
+	 * passenden {@link OutputStream}.
 	 * <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.
-	 * Eine {@link java.net.MalformedURLException} beim Konstruieren des {@code URL}
-	 * zu einer Datei verhindert daher, dass noch im Classpath gesucht wird.
+	 * 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 Resource (Absoluter Dateipfad,
-	 * 	Dateipfad im Classpath oder Netzwerkresource)
-	 * @return Ein {@code InputStream} für die Resource
-	 * @throws NullPointerException     Falls {@code source} {@code null} ist.
-	 * @throws IllegalArgumentException Falls {@code source} ein leerer String
-	 *                                  ist.
-	 * @throws IOException              Geworfen beim erzeugen eines URL zu
-	 *                                  einer bestehenden Resource.
-	 */
-	public static URL getResourceURL( String source ) throws NullPointerException, IllegalArgumentException, IOException {
-		Validator.requireNotNull(source, "Resource source may not be null");
-		Validator.requireNotEmpty(source, "Resource source may not be empty.");
-
-		File file = new File(source);
-		if( file.isFile() ) {
-			return file.toURI().toURL();
-		}
-
-		URL url;
-
-		url = Zeichenmaschine.class.getResource(source);
-		if( url != null ) {
-			return url;
-		}
-
-		url = Zeichenmaschine.class.getClassLoader().getResource(source);
-		if( url != null ) {
-			return url;
-		}
-
-		return new URL(source);
-	}
-
-	/**
-	 * Ver
-	 * @param source
-	 * @return
-	 * @throws IOException
+	 * @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 {
-		Validator.requireNotNull(source, "Resource source may not be null");
-		Validator.requireNotEmpty(source, "Resource source may not be empty.");
-		URL url = getResourceURL(source);
-		return getOutputStream(new File(url.getPath()));
+		try {
+			return Files.newOutputStream(Path.of(getResourceURL(source).toURI()));
+		} catch( URISyntaxException ex ) {
+			throw new IOException(ex);
+		}
 	}
 
-	public static OutputStream getOutputStream( File file ) throws IOException {
-		Validator.requireNotNull(file, "Provided file can't be null.");
-		return new FileOutputStream(file);
+	/**
+	 * 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);
 	}
 
-	public static Reader getReader( String source ) throws IOException {
-		return new InputStreamReader(getInputStream(source));
+	/**
+	 * 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()));
 	}
 
-	public static Writer getWriter( String source ) throws IOException {
-		return new OutputStreamWriter(getOutputStream(source));
+	/**
+	 * 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/java/schule/ngb/zm/util/tasks/FrameSynchronizedTask.java

@@ -5,35 +5,18 @@ import schule.ngb.zm.Zeichenmaschine;
 
 public abstract class FrameSynchronizedTask extends Task {
 
-	private static Thread mainThread;
-
-	private static final Thread getMainThread() {
-		if( mainThread == null ) {
-			mainThread = Thread.currentThread();
-			if( !mainThread.getName().equals(Constants.APP_NAME) ) {
-				// Need to search for main Zeichenthread ...
-			}
-		}
-		return mainThread;
-	}
-
 	@Override
 	public void run() {
 		initialize();
 		running = true;
 
-		Object lock = Zeichenmaschine.globalSyncLock;
+		final Object lock = Zeichenmaschine.globalSyncLock;
 
-		// start of thread in ms
-		final long start = System.currentTimeMillis();
 		// current time in ns
 		long beforeTime = System.nanoTime();
-		// store for deltas
-		long overslept = 0L;
-		// internal counters for tick and runtime
-		int _tick = 0;
-
-		double delta = 0.0;
+		// internal counters for tick and delta time
+		int _tick;
+		double delta;
 
 		while( running ) {
 			// delta in seconds
@@ -53,10 +36,7 @@ public abstract class FrameSynchronizedTask extends Task {
 				}
 			}
 		}
-
-		running = false;
 		done = true;
-
 		finish();
 	}
 

src/main/java/schule/ngb/zm/util/tasks/RateLimitedTask.java

@@ -17,7 +17,7 @@ public abstract class RateLimitedTask extends Task {
 		// store for deltas
 		long overslept = 0L;
 		// delta in ms
-		double delta = 0;
+		double delta;
 
 		running = true;
 		while( running ) {
@@ -47,10 +47,7 @@ public abstract class RateLimitedTask extends Task {
 			// Did we sleep to long?
 			overslept = (System.nanoTime() - afterTime) - sleep;
 		}
-
-		running = false;
 		done = true;
-
 		finish();
 	}
 

src/main/java/schule/ngb/zm/util/tasks/TaskRunner.java

@@ -10,11 +10,6 @@ import java.util.concurrent.*;
  */
 public class TaskRunner {
 
-	private static final int POOL_SIZE = 4;
-
-	private static final int SHUTDOWN_TIME = 100;
-
-
 	private static TaskRunner runner;
 
 	public static TaskRunner getTaskRunner() {

src/main/resources/schule/ngb/zm/colornames.csv

@@ -0,0 +1,342 @@
+algae green,#64e986
+aliceblue,#f0f8ff
+alien green,#6cc417
+antiquewhite,#faebd7
+aquamarine,#7fffd4
+army brown,#827b60
+ash gray,#666362
+avocado green,#b2c248
+aztech purple,#893bff
+azure,#f0ffff
+baby blue,#95b9c7
+bashful pink,#c25283
+basket ball orange,#f88158
+battleship gray,#848482
+bean red,#f75d59
+bee yellow,#e9ab17
+beer,#fbb117
+beetle green,#4c787e
+beige,#f5f5dc
+black cat,#413839
+black cow,#4c4646
+black eel,#463e3f
+black,#000000
+blanchedalmond,#ffebcd
+blonde,#fbf6d9
+blood red,#7e3517
+blossom pink,#f9b7ff
+blue angel,#b7ceec
+blue diamond,#4ee2ec
+blue dress,#157dec
+blue eyes,#1569c7
+blue gray,#98afc7
+blue green,#7bccb5
+blue hosta,#77bfc7
+blue ivy,#3090c7
+blue jay,#2b547e
+blue koi,#659ec7
+blue lagoon,#8eebec
+blue lotus,#6960ec
+blue orchid,#1f45fc
+blue ribbon,#306eff
+blue whale,#342d7e
+blue zircon,#57feff
+blueberry blue,#0041c2
+blush pink,#e6a9ec
+blush red,#e56e94
+brass,#b5a642
+bright gold,#fdd017
+bright neon pink,#f433ff
+bronze,#cd7f32
+brown bear,#835c3b
+brown sugar,#e2a76f
+bullet shell,#af9b60
+burgundy,#8c001a
+burlywood,#deb887
+burnt pink,#c12267
+butterfly blue,#38acec
+cadillac pink,#e38aae
+camel brown,#c19a6b
+camouflage green,#78866b
+cantaloupe,#ffa62f
+caramel,#c68e17
+carbon gray,#625d5d
+carnation pink,#f778a1
+celeste,#50ebec
+champagne,#f7e7ce
+charcoal,#34282c
+chartreuse,#8afb17
+cherry red,#c24641
+chestnut red,#c34a2c
+chestnut,#954535
+chilli pepper,#c11b17
+chocolate,#c85a17
+cinnamon,#c58917
+cloudy gray,#6d6968
+clover green,#3ea055
+cobalt blue,#0020c2
+coffee,#6f4e37
+columbia blue,#87afc7
+construction cone orange,#f87431
+cookie brown,#c7a317
+copper,#b87333
+coral blue,#afdcec
+coral,#ff7f50
+corn yellow,#fff380
+cornflower blue,#6495ed
+cornsilk,#fff8dc
+cotton candy,#fcdfff
+cranberry,#9f000f
+cream,#ffffcc
+crimson,#e238ec
+crocus purple,#9172ec
+crystal blue,#5cb3ff
+cyan opaque,#92c7c7
+cyan or aqua,#00ffff
+dark carnation pink,#c12283
+dark forest green,#254117
+dark goldenrod,#af7817
+dark orange,#f88017
+dark orchid,#7d1b7e
+dark salmon,#e18b6b
+dark sea green,#8bb381
+dark slate blue,#2b3856
+dark slate grey,#25383c
+dark turquoise,#3b9c9c
+dark violet,#842dce
+day sky blue,#82caff
+deep peach,#ffcba4
+deep pink,#f52887
+deep sky blue,#3bb9ff
+denim blue,#79baec
+denim dark blue,#151b8d
+desert sand,#edc9af
+dimorphotheca magenta,#e3319d
+dodger blue,#1589ff
+dollar bill green,#85bb65
+dragon green,#6afb92
+dull purple,#7f525d
+earth blue,#0000a0
+eggplant,#614051
+electric blue,#9afeff
+emerald green,#5ffb17
+fall leaf brown,#c8b560
+fern green,#667c26
+ferrari red,#f70d1a
+fire engine red,#f62817
+firebrick,#800517
+flamingo pink,#f9a7b0
+forest green,#4e9258
+frog green,#99c68e
+ginger brown,#c9be62
+glacial blue ice,#368bc1
+golden brown,#eac117
+goldenrod,#edda74
+granite,#837e7c
+grape,#5e5a80
+grapefruit,#dc381f
+gray cloud,#b6b6b4
+gray dolphin,#5c5858
+gray goose,#d1d0ce
+gray wolf,#504a4b
+gray,#736f6e
+grayish turquoise,#5e7d7e
+green apple,#4cc417
+green onion,#6aa121
+green peas,#89c35c
+green snake,#6cbb3c
+green thumb,#b5eaaa
+green yellow,#b1fb17
+green,#00ff00
+greenish blue,#307d7e
+gunmetal,#2c3539
+halloween orange,#e66c2c
+harvest gold,#ede275
+hazel green,#617c58
+heliotrope purple,#d462ff
+hot pink,#f660ab
+hummingbird green,#7fe817
+iceberg,#56a5ec
+iguana green,#9cb071
+indigo,#4b0082
+iridium,#3d3c3a
+jade green,#5efb6e
+jasmine purple,#a23bec
+jeans blue,#a0cfec
+jellyfish,#46c7c7
+jet gray,#616d7e
+jungle green,#347c2c
+kelly green,#4cc552
+khaki rose,#c5908e
+khaki,#ada96e
+lapis blue,#15317e
+lava red,#e42217
+lavender blue,#e3e4fa
+lavender pinocchio,#ebdde2
+lawn green,#87f717
+lemon chiffon,#fff8c6
+light aquamarine,#93ffe8
+light blue,#addfff
+light coral,#e77471
+light cyan,#e0ffff
+light jade,#c3fdb8
+light pink,#faafba
+light salmon,#f9966b
+light sea green,#3ea99f
+light sky blue,#82cafa
+light slate blue,#736aff
+light slate gray,#6d7b8d
+light slate,#ccffff
+light steel blue,#728fce
+lilac,#c8a2c8
+lime green,#41a317
+lipstick pink,#c48793
+love red,#e41b17
+lovely purple,#7f38ec
+macaroni and cheese,#f2bb66
+macaw blue green,#43bfc7
+magenta,#ff00ff
+mahogany,#c04000
+mango orange,#ff8040
+marble blue,#566d7e
+maroon,#810541
+mauve,#e0b0ff
+medium aquamarine,#348781
+medium forest green,#347235
+medium orchid,#b048b5
+medium purple,#8467d7
+medium sea green,#306754
+medium spring green,#348017
+medium turquoise,#48cccd
+medium violet red,#ca226b
+metallic silver,#bcc6cc
+midnight blue,#151b54
+midnight,#2b1b17
+milk white,#fefcff
+mint green,#98ff98
+mist blue,#646d7e
+misty rose,#fbbbb9
+moccasin,#827839
+mocha,#493d26
+mustard,#ffdb58
+navy blue,#000080
+nebula green,#59e817
+neon pink,#f535aa
+night,#0c090a
+northern lights blue,#78c7c7
+oak brown,#806517
+ocean blue,#2b65ec
+oil,#3b3131
+orange gold,#d4a017
+orange salmon,#c47451
+pale blue lily,#cfecec
+pale violet red,#d16587
+papaya orange,#e56717
+parchment,#ffffc2
+pastel blue,#b4cfec
+peach,#ffe5b4
+pearl,#fdeef4
+periwinkle,#e9cfec
+pig pink,#fdd7e4
+pine green,#387c44
+pink bow,#c48189
+pink bubblegum,#ffdfdd
+pink cupcake,#e45e9d
+pink daisy,#e799a3
+pink lemonade,#e4287c
+pink rose,#e7a1b0
+pink,#faafbe
+pistachio green,#9dc209
+platinum,#e5e4e2
+plum pie,#7d0541
+plum purple,#583759
+plum velvet,#7d0552
+plum,#b93b8f
+powder blue,#c6deff
+puce,#7f5a58
+pumpkin orange,#f87217
+purple amethyst,#6c2dc7
+purple daffodil,#b041ff
+purple dragon,#c38ec7
+purple flower,#a74ac7
+purple haze,#4e387e
+purple iris,#571b7e
+purple jam,#6a287e
+purple mimosa,#9e7bff
+purple monster,#461b7e
+purple sage bush,#7a5dc7
+purple,#8e35ef
+red dirt,#7f5217
+red fox,#c35817
+red wine,#990012
+red,#ff0000
+robin egg blue,#bdedff
+rogue pink,#c12869
+rose gold,#ecc5c0
+rose,#e8adaa
+rosy brown,#b38481
+rosy finch,#7f4e52
+royal blue,#2b60de
+rubber ducky yellow,#ffd801
+ruby red,#f62217
+rust,#c36241
+saffron,#fbb917
+sage green,#848b79
+salad green,#a1c935
+sand,#c2b280
+sandstone,#786d5f
+sandy brown,#ee9a4d
+sangria,#7e3817
+sapphire blue,#2554c7
+scarlet,#ff2400
+school bus yellow,#e8a317
+sea blue,#c2dfff
+sea green,#4e8975
+sea turtle green,#438d80
+seashell,#fff5ee
+seaweed green,#437c17
+sedona,#cc6600
+sepia,#7f462c
+shamrock green,#347c17
+shocking orange,#e55b3c
+sienna,#8a4117
+silk blue,#488ac7
+sky blue,#6698ff
+slate blue,#737ca1
+slate gray,#657383
+slime green,#bce954
+smokey gray,#726e6d
+spring green,#4aa02c
+steel blue,#4863a0
+stoplight go green,#57e964
+sun yellow,#ffe87c
+sunrise orange,#e67451
+tan brown,#ece5b6
+tangerine,#e78a61
+taupe,#483c32
+tea green,#ccfb5d
+teal,#008080
+thistle,#d2b9d3
+tiffany blue,#81d8d0
+tiger orange,#c88141
+tron blue,#7dfdfe
+tulip pink,#c25a7c
+turquoise,#43c6db
+tyrian purple,#c45aec
+valentine red,#e55451
+vampire gray,#565051
+vanilla,#f3e5ab
+velvet maroon,#7e354d
+venom green,#728c00
+viola purple,#7e587e
+violet red,#f6358a
+violet,#8d38c9
+water,#ebf4fa
+watermelon pink,#fc6c85
+white,#ffffff
+windows blue,#357ec7
+wisteria purple,#c6aec7
+wood,#966f33
+yellow green,#52d017
+yellow,#ffff00
+zombie green,#54c571

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/ColorTest.java

@@ -147,6 +147,36 @@ class ColorTest {
 
 	@Test
 	void parseHexcode() {
+		Color c;
+
+		c = Color.parseHexcode("#f05025");
+		assertEquals(Color.RED, c);
+
+		c = Color.parseHexcode("#F8EF22");
+		assertEquals(Color.YELLOW, c);
+
+		c = Color.parseHexcode("#FF40ff");
+		assertEquals(new Color(255, 64, 255), c);
+
+		// TODO: Test hexcodes of length 3, 6 and 9
+		// TODO: Test malformed hexcodes
+	}
+
+	@Test
+	void parseString() {
+		Color c;
+
+		c = Color.parseString("red");
+		assertEquals(new Color(255, 0, 0), c);
+
+		c = Color.parseString("zombie green");
+		assertEquals(Color.parseHexcode("#54c571"), c);
+
+		c = Color.parseString("algae green");
+		assertEquals(new Color(100, 233, 134), c);
+
+		c = Color.parseString("light slate gray");
+		assertEquals(Color.parseHexcode("#6d7b8d"), c);
 	}
 
 	@Test
@@ -173,10 +203,6 @@ class ColorTest {
 	void HSLtoRGB() {
 	}
 
-	@Test
-	void testHSLtoRGB() {
-	}
-
 	@Test
 	void copy() {
 	}

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

@@ -2,6 +2,9 @@ package schule.ngb.zm;
 
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+import java.util.stream.IntStream;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 class ConstantsTest {
@@ -22,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);
@@ -169,4 +190,30 @@ class ConstantsTest {
 		assertTrue(0.0 <= d && 1.0 >= d, "Noise should be in Range 0 to 1. Was <" + d + ">.");
 	}
 
+	@Test
+	void choice() {
+		int[] values = IntStream.range(0,1000).toArray();
+		int[] choosen = Constants.choice(values, 1, false);
+		assertEquals(1, choosen.length);
+		assertTrue(Arrays.stream(values).anyMatch((i) -> i == choosen[0]));
+
+		int[] choosen4 = Constants.choice(values, 2000, false);
+		assertEquals(2000, choosen4.length);
+
+		int[] choosen2 = Constants.choice(values, 400, false);
+		assertEquals(400, choosen2.length);
+		assertTrue(Arrays.stream(choosen2).allMatch((i) -> Arrays.binarySearch(values, i)>=0 ));
+
+		int[] choosen3 = Constants.choice(values, 999, true);
+		assertEquals(999, choosen3.length);
+		assertTrue(Arrays.stream(choosen3).allMatch((i) -> Arrays.binarySearch(values, i)>=0 ));
+		for( int i = 0; i < choosen3.length; i++ ) {
+			for( int j = i+1; j < choosen3.length; j++ ) {
+				assertNotEquals(choosen3[i], choosen3[j], "Item "+i+" also found at index "+j);
+			}
+		}
+
+		assertThrows(IllegalArgumentException.class, () -> Constants.choice(values, 2000, true));
+	}
+
 }

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

@@ -2,8 +2,6 @@ package schule.ngb.zm;
 
 import schule.ngb.zm.shapes.*;
 
-import java.awt.geom.Point2D;
-
 public class TestInput extends Zeichenmaschine {
 
 	public static void main( String[] args ) {
@@ -23,7 +21,7 @@ public class TestInput extends Zeichenmaschine {
 		shapes.getShape(1).setFillColor(PINK);
 
 		text = new Text(10, 42, "");
-		text.setFontsize(32);
+		text.setFontSize(32);
 		text.setAnchor(NORTHWEST);
 		shapes.add(text);
 	}

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 {