src/main/java/projekt/enigma/model/Walze.java

+package projekt.enigma.model;
+
+/**
+ * Klasse Walze
+ * <br>
+ * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
+ * <br>
+ * 1. Walzennummer (Die Walze enthaelt die 26 Buchstaben des Alphabets und codiert diese.
+ * Fuenf verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabets
+ * vertauschen).
+ * <br>
+ * 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
+ * den Drehzeitpunkt der linken Nachbarwalze).
+ */
+public class Walze {
+
+	//region Variablen
+	/**
+	 * Die Anzahl der getaetigten Walzendrehungen.
+	 */
+	private int turns;
+
+	/**
+	 * Das String-Array aller bekannter aktueller Walzen.
+	 */
+	private String[] walzen;
+
+	/**
+	 * alphabet : String : enthaelt die Buchstaben des Alphabets.
+	 */
+	private String alphabet;
+
+	/**
+	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt.
+	 */
+	private char ringstellung;
+
+	/**
+	 * walzenNr : int : Bestimmt, welche Walze genutzt wird.
+	 */
+	private int walzenNr;
+
+	//endregion
+
+	//region Konstruktor
+	/**
+	 * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt.
+	 *
+	 * @param walzenNr     : int : Nummer der gewaehlten Walze.
+	 * @param ringstellung : int : Einstellung des Umsprungpunktes.
+	 */
+	public Walze(int walzenNr, int ringstellung) {
+		this.walzen = new String[5];
+		this.walzen[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
+		this.walzen[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
+		this.walzen[2] = "BDFHJLCPRTXVZNYEIWGAKMUSQO";
+		this.walzen[3] = "ESOVPZJAYQUIRHXLNFTGKDCMWB";
+		this.walzen[4] = "VZBRGITYUPSDNHLXAWMJQOFECK";
+		this.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		this.turns = 0;
+
+		this.setWalzenNr(walzenNr);
+		this.setRingstellung(ringstellung);
+	}
+
+	//endregion
+
+	//region Funktionen & Methoden
+	/**
+	 * Dreht die Walze: Zaehlt die Umdrehungen (turns) um eins hoch oder runter, je nach Drehrichtung.
+	 * <p>
+	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
+	 *
+	 * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurueck.
+	 * @return checkRing : boolean : gibt true zurueck, wenn der Umspringpunkt erreicht wurde.
+	 */
+	boolean dreheWalze(int richtung) {
+		boolean checkRing = false;
+		int korrekturFaktor = 0;
+
+		if ((richtung == -1) || (richtung == 1)) {
+			if (richtung == 1) {
+				this.turns++;
+			} else {
+				korrekturFaktor = 1;
+				this.turns--;
+			}
+
+			// gleicht die Ringstellung mit der aktuellen Position ab
+			if ((this.alphabet.indexOf(this.getPosition()) + korrekturFaktor) % 26
+					== this.alphabet.indexOf(this.ringstellung)) {
+				checkRing = true;
+			}
+		}
+
+		return checkRing;
+	}
+
+	/**
+	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
+	 *
+	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll.
+	 * @return char : verschluesselter Buchstabe.
+	 */
+	public char codiere(char buchstabe) {
+		return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26);
+	}
+
+	/**
+	 * Decodiert den mitgegebenen Buchstaben anhand des Alphabets.
+	 *
+	 * @param buchstabe : char : Buchstabe, der decodiert werden soll.
+	 * @return char : decodierter Buchstabe.
+	 */
+	char codiere2(char buchstabe) {
+		return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) - this.turns + 520) % 26);
+	}
+
+	/**
+	 * @return String : Gibt den Verschluesselungs-String der ausgewaehlten Walze zurueck.
+	 */
+	private String fetchWalze() {
+		return walzen[walzenNr];
+	}
+
+	//endregion
+
+	//region Setter
+	/**
+	 * Setzt die Walzennummer. Es stehen fuenf Walzen zur Auswahl.
+	 *
+	 * @param walzenNr : int : Walzennummer.
+	 */
+	private void setWalzenNr(int walzenNr) {
+		if ((walzenNr > 0) && (walzenNr < 6)) {
+			this.walzenNr = walzenNr - 1;
+		} else {
+			System.err.println("Keine gültige Walzennummer");
+		}
+	}
+
+	/**
+	 * Setzt die Initiale Ringstellung der Walze.
+	 * Es sind nur Zahlen von 1 - 26 zugelassen.
+	 * <br>
+	 * Die Ringstellung wird zum char umgewandelt.
+	 * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+	 *
+	 * @param ringstellung : int : Punkt an dem die Nachbarwalze umspringt.
+	 */
+	void setRingstellung(int ringstellung) {
+		if ((ringstellung > 0) && (ringstellung <= 26)) {
+			this.ringstellung = this.alphabet.charAt(ringstellung - 1);
+		} else {
+			this.ringstellung = 'Z';
+		}
+	}
+
+	/**
+	 * Stellt die Grundeinstellung der Walze ein.
+	 * Ermittelt, wie oft die Walze gedreht werden muss, bis die Grundeinstellung erreicht ist.
+	 *
+	 * @param buchstabe : Character : Einstellung der Walze.
+	 */
+	void setPosition(Character buchstabe) {
+		this.turns = alphabet.indexOf(buchstabe);
+	}
+	//endregion
+
+	//region Getter
+	/**
+	 * Gibt den Buchstaben zurueck, der aktuell in der Walze eingestellt ist.
+	 *
+	 * @return char : Ermittelte Stelle im Alphabet, anhand der aktuellen Anzahl der Drehungen.
+	 */
+	Character getPosition() {
+		return this.alphabet.charAt(turns % 26);
+	}
+
+	/**
+	 * Getter der Walzennummer.
+	 * @return walzenNr : int : gibt Walzennummer zurueck.
+	 */
+	int getWalzenNr() {
+		return this.walzenNr;
+	}
+	//endregion
+}
\ No newline at end of file

src/main/java/projekt/enigma/view/ChkBoxGridPane.java

+package projekt.enigma.view;
+
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.layout.GridPane;
+import projekt.enigma.model.Codierer;
+
+import java.util.Arrays;
+
+/**
+ * Die Klasse ChkBoxGripPane erweitert das GridPane Objekt.
+ * Wir erstellen ein GridPane in welches Checkboxen gelegt werden.
+ * Die Anzahl der Checkboxen wird durch die verfuegbarenBuchstaben festgelegt.
+ * Für jeden Buchstaben in diesem char Array, wird eine Checkbox erstellt und auf das Gridpane gelegt.
+ */
+public class ChkBoxGridPane extends GridPane {
+
+    // Der globale Checkbox Array
+    private CheckBox[] checkbox;
+    // Die Buchstaben die für das jeweilige Pane selectiert werden sollen
+    private String checkedBuchstaben;
+    // Die Anzahl der möglichen Checkboxen
+    private int charSize;
+    // Das Codierer Objekt. Dieses wird benötigt um auf die Funktionen für das Steckbrett zuzugreifen
+    private Codierer codierer;
+    // Der Steckbrett Port für welchen das Pane und die Checkboxen erstellt werden sollen
+    private int port;
+    // Die verfügbaren Buchstaben für den jeweiligen Port
+    private char[] verfuegbareBuchstaben;
+    // Das Button Objekt des Ports über den dieses Pane gesteuert wird
+    private ToggleButton tBtnPort;
+
+    /**
+     * Hier werfen wir die Checkboxen auf das Gridpane und weißen ihnen die Propertys zu.
+     * Außerdem wird hier auch der Listener generiert womit wir prüfen ob die maximale Auswahlmöglichkeit
+     * erreicht ist.
+     * Es können maximal zwei Checkboxen ausgewählt werden. Wenn zwei erreicht sind, werden die restlichen Checkboxen
+     * deaktiviert. Wenn nur noch eine oder keine Box ausgewählt ist, werden die restlichen wieder aktiviert.
+     * Bei null und zwei Boxen, werden die Buchstaben in das Steckbrett geschrieben.
+     * Andere Auswahlmöglchkeiten stehen nicht zur Verfügung, da ein Kabel nur zwei Enden hat in der Regel.
+     *
+     * @param codierer : Codierer Objekt
+     * @param port     : int
+     * @param tBtnPort : ToogleButton
+     */
+    public ChkBoxGridPane(Codierer codierer, int port, ToggleButton tBtnPort) {
+        this.codierer = codierer;
+        this.port = port;
+        this.tBtnPort = tBtnPort;
+        this.verfuegbareBuchstaben = this.codierer.fetchVerfuegbareBuchstaben(this.port).toCharArray();
+        Arrays.sort(this.verfuegbareBuchstaben);
+        charSize = this.verfuegbareBuchstaben.length;
+        this.checkedBuchstaben = tBtnPort.getText();
+        initializeComponents();
+    }
+
+    /**
+     * Es wird ein GridPane erzeugt, das zwei Spalten und abhängig von der Länge des
+     * Arrays (Character[] alphabet) Reihen hat. Das Label der CheckBoxen soll
+     * abhängig von deren Index links bzw. recht erzeugt werden
+     */
+    private void initializeComponents() {
+        checkbox = new CheckBox[charSize];
+
+        this.setAlignment(Pos.CENTER);
+
+        // Für jeden verfügbaren Buchstaben einen Durchlauf
+        for (int i = 0; i < this.verfuegbareBuchstaben.length; i++) {
+            if (this.verfuegbareBuchstaben[i] != 20 && this.verfuegbareBuchstaben[i] != ' ') {
+                checkbox[i] = new CheckBox(this.verfuegbareBuchstaben[i] + "");
+                checkbox[i].setPadding(new Insets(1, 1, 1, 1));
+
+                if (!checkedBuchstaben.equals("")) {
+                    if (!checkedBuchstaben.contains(String.valueOf(this.verfuegbareBuchstaben[i]))) {
+                        checkbox[i].setDisable(true);
+                    } else {
+                        checkbox[i].setSelected(true);
+                    }
+                } else {
+                    checkbox[i].setSelected(false);
+                    checkbox[i].setDisable(false);
+                }
+
+                // Der Listener für die jeweilige Checkbox
+                checkbox[i].selectedProperty().addListener((observable, oldValue, newValue) -> {
+                    String portSelection = "";
+                    int zaehler = 0;
+
+                    // Die selektierten Chechkboxen zählen
+                    for (CheckBox cb : checkbox) {
+                        if (cb != null && cb.isSelected()) {
+                            zaehler++;
+                        }
+                    }
+                    // Wenn nur eine oder keine Checkbox ausgewählt ist
+                    if (zaehler == 1 || zaehler == 0) {
+                        for (CheckBox cb : checkbox) {
+                            if (cb != null && cb.isDisabled()) {
+                                cb.setDisable(false);
+                            }
+                        }
+                    }
+                    // Es ist keine Checkbox ausgewählt
+                    if (zaehler == 0) {
+                        // Daten ins Steckbrett schreiben
+                        this.codierer.setzeSteckbrett(this.port, "");
+                        // Und den Button neu beschreiben
+                        tBtnPort.setText(portSelection);
+                    }
+                    // Das Maximum an selektierten Checkboxen (2) ist erreicht
+                    if (zaehler == 2) {
+                        for (CheckBox cb : checkbox) {
+                            if (cb != null && !cb.isSelected()) {
+                                cb.setDisable(true);
+                            } else {
+                                if (cb != null) {
+                                    portSelection += cb.getText();
+                                }
+                            }
+                        }
+                        // Daten ins Steckbrett schreiben
+                        this.codierer.setzeSteckbrett(this.port, "");
+                        this.codierer.setzeSteckbrett(this.port, portSelection);
+                        // Und den Button neu beschreiben
+                        tBtnPort.setText(portSelection);
+                    }
+                });
+
+                // Eine neue Row im Gridpane anlegen für den nächsten Button
+                this.addRow(i + 1);
+                this.add(checkbox[i], 2, i + 1, 1, 1);
+            }
+        }
+        // Das Pane anzeigen
+        this.setVisible(true);
+    }
+
+    /**
+     * Gibt den Anzahl der zur Verfügung stehenden Buchstaben zurück.
+     * Anhang dieses Wertes, wird die Anzahl der Checkboxen festgelegt.
+     *
+     * @return int : Anzahl der möglcihen chars
+     */
+    public int getCharSize() {
+        return charSize;
+    }
+}
+

src/main/resources/Enigma/primary.fxml

-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.scene.layout.VBox?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.Button?>
-<?import javafx.geometry.Insets?>
-
-<VBox alignment="CENTER" spacing="20.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="Enigma.PrimaryController">
-   <children>
-      <Label text="Primary View" />
-      <Button fx:id="primaryButton" text="Switch to Secondary View" onAction="#switchToSecondary"/>
-   </children>
-   <padding>
-      <Insets bottom="20.0" left="20.0" right="20.0" top="20.0" />
-   </padding>
-</VBox>

src/main/resources/Enigma/secondary.fxml

-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.scene.layout.VBox?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.Button?>
-<?import javafx.geometry.Insets?>
-
-<VBox alignment="CENTER" spacing="20.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="Enigma.SecondaryController">
-    <children>
-        <Label text="Secondary View" />
-        <Button fx:id="secondaryButton" text="Switch to Primary View" onAction="#switchToPrimary" />
-    </children>
-    <padding>
-        <Insets bottom="20.0" left="20.0" right="20.0" top="20.0" />
-    </padding>
-</VBox>

src/test/java/projekt/enigma/model/CodebuchTest.java

+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CodebuchTest {
+
+	@Test
+	public void testToString() {
+		String expected = "Tag: 1\n" +
+				"Walzenlage: 1,3,2\n" +
+				"Ringstellung: 16,11,13\n" +
+				"Steckverbindung: E:U,O:H,T:Z,A:S,M:R,I:V,C:G,F:Q,B:X,Y:K\n";
+
+		// Ausgabe auf der Konsole
+		Codebuch cb = new Codebuch();
+		cb.fetchTagesschluessel(1);
+		String result = cb.toString();
+		Assert.assertEquals(result, expected, result);
+	}
+
+	@Test
+	public void getTag() {
+		Codebuch cb = new Codebuch();
+		cb.setTag(1);
+		Assert.assertEquals(1, cb.getTag());
+	}
+}
\ No newline at end of file

src/test/java/projekt/enigma/model/HardwareTest.java

+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class HardwareTest {
+
+	@Test
+	public void tippeBuchstabe() {
+
+		Hardware h = new Hardware();
+		h.setReflektor(new Reflektor());
+		h.setSteckbrett(new Steckbrett());
+
+		/*
+        Walze nach der Chiffrierung
+        Alphabet    "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
+        Steckbrett  "W S L V H Y G I X A"
+        Steckbrett  "J E F B K P M Q U C"
+
+		Walze 3   "E K M F L G D Q V Z N T O W Y H X U S P A I B R C J"
+        Walze 2     "V Z B R G I T Y U P S D N H L X A W M J Q O F E C K"
+        Walze 1   	"A J D K S I R U X B L H W T M C Q G Z N P Y F V O E"
+        Reflektor   "E J M Z A L Y X V B W F C R Q U O N T S P I K H G D"
+		*/
+
+		char result;
+		h.setWalzen(0, 2, 25);
+		h.setWalzen(1, 5, 25);
+		h.setWalzen(2, 1, 25);
+		result = h.codiere('A');
+		Assert.assertEquals("Codiere: A Erwartet N, erhalten " + result, 'N', result);
+		result = h.codiere('B');
+		Assert.assertEquals("Codiere: B Erwartet K, erhalten " + result, 'K', result);
+		result = h.codiere('I');
+		Assert.assertEquals("Codiere: I Erwartet V, erhalten " + result, 'V', result);
+		result = h.codiere('F');
+		Assert.assertEquals("Codiere: F Erwartet T, erhalten " + result, 'T', result);
+
+		h.setWalzen(0, 2, 25);
+		h.setWalzen(1, 5, 25);
+		h.setWalzen(2, 1, 25);
+		result = h.codiere('N');
+		Assert.assertEquals("Decodiere: N Erwartet A, erhalten " + result, 'A', result);
+		result = h.codiere('K');
+		Assert.assertEquals("Decodiere: K Erwartet B, erhalten " + result, 'B', result);
+		result = h.codiere('V');
+		Assert.assertEquals("Decodiere: V Erwartet I, erhalten " + result, 'I', result);
+		result = h.codiere('T');
+		Assert.assertEquals("Decodiere: T Erwartet F, erhalten " + result, 'F', result);
+
+		h.setWalzen(0, 2, 25);
+		h.setWalzen(1, 5, 25);
+		h.setWalzen(2, 1, 25);
+		h.getSteckbrett().setzeVertauschung('B', 'G');
+		h.getSteckbrett().setzeVertauschung('D', 'F');
+		h.getSteckbrett().setzeVertauschung('I', 'L');
+		h.getSteckbrett().setzeVertauschung('M', 'Q');
+		h.getSteckbrett().setzeVertauschung('N', 'X');
+		h.getSteckbrett().setzeVertauschung('K', 'Y');
+		h.getSteckbrett().setzeVertauschung('U', 'Z');
+		h.getSteckbrett().setzeVertauschung('A', 'O');
+		h.getSteckbrett().setzeVertauschung('E', 'S');
+
+		result = h.codiere('I');
+		Assert.assertEquals("Codiere: I Erwartet C, erhalten " + result, 'C', result);
+
+		h.setWalzen(0, 2, 25);
+		h.setWalzen(1, 5, 25);
+		h.setWalzen(2, 1, 25);
+		result = h.codiere('C');
+		Assert.assertEquals("Codiere: C Erwartet I, erhalten " + result, 'I', result);
+
+		h.setWalzen(0, 2, 25);
+		h.setWalzen(1, 5, 25);
+		h.setWalzen(2, 1, 25);
+		h.getSteckbrett().setzeVertauschung('A', 'B');
+		h.getSteckbrett().setzeVertauschung('C', 'D');
+		result = h.codiere('A');
+		Assert.assertEquals("Codiere: A Erwartet M, erhalten " + result, 'M', result);
+	}
+}
\ No newline at end of file

src/test/java/projekt/enigma/model/ReflektorTest.java

+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ReflektorTest {
+
+	@Test
+	public void codiere() {
+		Reflektor r = new Reflektor();
+
+		Assert.assertEquals('E', r.codiere('A'));
+		Assert.assertEquals('Z', r.codiere('D'));
+		Assert.assertEquals('X', r.codiere('H'));
+		Assert.assertEquals('O', r.codiere('Q'));
+		Assert.assertEquals('I', r.codiere('V'));
+		Assert.assertEquals('A', r.codiere('E'));
+		Assert.assertEquals('D', r.codiere('Z'));
+		Assert.assertEquals('H', r.codiere('X'));
+		Assert.assertEquals('Q', r.codiere('O'));
+		Assert.assertEquals('V', r.codiere('I'));
+	}
+}
\ No newline at end of file

src/test/java/projekt/enigma/model/SteckbrettTest.java

+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SteckbrettTest {
+
+	@Test
+	public void setzeVertauschung() {
+		Steckbrett sb = new Steckbrett();
+		sb.setzeVertauschung('A', 'G');
+		sb.setzeVertauschung('C', 'H');
+		Assert.assertEquals('H', sb.codiere('C'));
+		Assert.assertEquals('G', sb.codiere('A'));
+	}
+
+	@Test
+	public void codiere() {
+		Steckbrett sb = new Steckbrett();
+		sb.setzeVertauschung('A', 'G');
+		sb.setzeVertauschung('C', 'H');
+		Assert.assertEquals('H', sb.codiere('C'));
+		Assert.assertEquals('G', sb.codiere('A'));
+	}
+}
\ No newline at end of file

src/test/java/projekt/enigma/model/WalzeTest.java

+package projekt.enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class WalzeTest {
+
+	@Test
+	public void setRingstellung() {
+		Walze w = new Walze(1, 1);
+		char temp = w.getPosition();
+		Assert.assertEquals('A', temp);
+	}
+
+	@Test
+	public void dreheWalze() {
+		Walze w = new Walze(1, 4);
+		assertFalse("false erwartet, true geliefert", w.dreheWalze(1));
+		char temp = w.getPosition();
+		Assert.assertEquals("B erwartet, " + temp + " zurück gegeben", 'B', temp);
+	}
+
+	@Test
+	public void getPosition() {
+		Walze w = new Walze(1, 1);
+		char temp = w.getPosition();
+		Assert.assertEquals('A', temp);
+	}
+
+	@Test
+	public void codiere() {
+		Walze w = new Walze(1, 1);
+		char result = w.codiere('G');
+		Assert.assertEquals("Erwartet D erhalten " + result, 'D', result);
+	}
+
+	@Test
+	public void codiere2() {
+		Walze w = new Walze(1, 1);
+		char result = w.codiere2('E');
+		Assert.assertEquals("Erwartet A erhalten " + result, 'A', result);
+	}
+}
\ No newline at end of file