Fixed icon loading on windows

.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

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

@@ -5,10 +5,12 @@ 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;
 
@@ -65,7 +67,7 @@ public class Constants {
 	/**
 	 * Patchversion der Zeichenmaschine.
 	 */
-	public static final int APP_VERSION_REV = 31;
+	public static final int APP_VERSION_REV = 32;
 
 	/**
 	 * Version der Zeichenmaschine als Text-String.
@@ -442,6 +444,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
@@ -1387,7 +1404,12 @@ 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 double[] choice( double[] values, int n, boolean unique ) {
 		if( unique && values.length < n )
@@ -1416,8 +1438,13 @@ 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).
 	 * @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, boolean unique ) {
 		if( unique && values.length < n )
@@ -1441,6 +1468,53 @@ public class Constants {
 		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);
+	}
+
 	/**
 	 * Geteilte {@code Noise}-Instanz zur Erzeugung von Perlin-Noise.
 	 */

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

@@ -130,7 +130,7 @@ public class Zeichenfenster extends JFrame {
 				taskbar.setIconImage(icon);
 			} else {
 				ArrayList<Image> icons = new ArrayList<>(4);
-				for( int size = 32; size <= 512; size *= size ) {
+				for( int size: new int[]{32, 64, 128, 512} ) {
 					icons.add(ImageIO.read(new File("icon_" + size + ".png")));
 				}
 

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

@@ -427,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();
@@ -1091,6 +1100,9 @@ public class Zeichenmaschine extends Constants {
 		}
 
 		if( isPaused() || isTerminated() ) {
+			if( MouseEvent.class.isInstance(evt) ) {
+				saveMousePosition((MouseEvent)evt);
+			}
 			dispatchEvents();
 		}
 	}

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

@@ -466,10 +466,27 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 		rect(x, y, w, w, anchor);
 	}
 
+	/**
+	 * Zeichnet ein Rechteck in die Zeichenebene.
+	 *
+	 * @param x x-Koordinate des Rechtecks.
+	 * @param y y-Koordinate des Rechtecks.
+	 * @param w Breite des Rechtecks.
+	 * @param h Höhe des Rechtecks.
+	 */
 	public void rect( double x, double y, double w, double h ) {
 		rect(x, y, w, h, shapeDelegate.getAnchor());
 	}
 
+	/**
+	 * Zeichnet ein Rechteck mit in die Zeichenebene.
+	 *
+	 * @param x x-Koordinate des Rechtecks.
+	 * @param y y-Koordinate des Rechtecks.
+	 * @param w Breite des Rechtecks.
+	 * @param h Höhe des Rechtecks.
+	 * @param anchor Ankerpunkt de Rechtecks.
+	 */
 	public void rect( double x, double y, double w, double h, Options.Direction anchor ) {
 		Point2D.Double anchorPoint = this.getOriginPoint(x, y, w, h, anchor);
 		rect.setRect(anchorPoint.getX(), anchorPoint.getY(), w, h);
@@ -477,6 +494,42 @@ public class DrawingLayer extends Layer implements Strokeable, Fillable {
 		drawShape(rect);
 	}
 
+	/**
+	 * Zeichnet ein Rechteck mit abgerundeten Ecken in die Zeichenebene.
+	 * <p>
+	 * Jede Ecke wird als Viertelkreis eines Kreises mit dem Radius
+	 * {@code radius} gezeichnet.
+	 *
+	 * @param x x-Koordinate des Rechtecks.
+	 * @param y y-Koordinate des Rechtecks.
+	 * @param w Breite des Rechtecks.
+	 * @param h Höhe des Rechtecks.
+	 * @param radius Radius der Eckenkreise.
+	 */
+	public void roundedRect( double x, double y, double w, double h, double radius ) {
+		roundedRect(x, y, w, h, radius, shapeDelegate.getAnchor());
+	}
+
+	/**
+	 * Zeichnet ein Rechteck mit abgerundeten Ecken in die Zeichenebene.
+	 * <p>
+	 * Jede Ecke wird als Viertelkreis eines Kreises mit dem Radius
+	 * {@code radius} gezeichnet.
+	 *
+	 * @param x x-Koordinate des Rechtecks.
+	 * @param y y-Koordinate des Rechtecks.
+	 * @param w Breite des Rechtecks.
+	 * @param h Höhe des Rechtecks.
+	 * @param radius Radius der Eckenkreise.
+	 * @param anchor Ankerpunkt de Rechtecks.
+	 */
+	public void roundedRect( double x, double y, double w, double h, double radius, Options.Direction anchor ) {
+		Point2D.Double anchorPoint = this.getOriginPoint(x, y, w, h, anchor);
+		Shape rect = new RoundRectangle2D.Double(anchorPoint.getX(), anchorPoint.getY(), w, h, radius, radius);
+		fillShape(rect);
+		drawShape(rect);
+	}
+
 	public void point( double x, double y ) {
 		ellipse(x - 1, y - 1, 2, 2, shapeDelegate.getAnchor());
 	}

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,8 +20,13 @@ 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.
+	 * 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
@@ -27,7 +34,8 @@ public class FontLoader {
 	 * 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;
@@ -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);
@@ -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() {
 	}