Compare revisions

Jan Schubert · Dennis Eisold · Jan Schubert · Dennis Eisold · Dennis Eisold · Dennis Eisold
--- a/Praesentation/Screenshot.JPG
+++ b/Praesentation/Screenshot.JPG
--- a/Praesentation/praesentation.md
+++ b/Praesentation/praesentation.md
@@ -46,16 +46,18 @@
 * Besondere (für uns) Lösungen
 ### Zahlen, Daten, Fakten
-* Zeilen insgesamt: 4120
+* Zeilen insgesamt: 3056
-  * Code: 1596
+  * Code: 1619 (53%)
  * XML: 110
-  * Kommentare:
+  * Kommentare: 1076 (35%)
-  * Leerzeilen:
+  * Leerzeilen: 365 (12%)
-  * Commits: 373
+  * Commits: 461
-  * Merge Requests: 113
+  * Merge Requests: 146
+  * Tickets: 29
+  * Pipelines 471
 ## Klassendiagram
-![Ablaufdiagram Enigma](http://plantuml.gitrepo.de/png/U9oTM4jpspOGlkjNuDPsLEhGeoRJIMCdxKoir6DvcawJZ0SYLn8Y4601q4wTnh-z2v82IJmerJv8z7wB3yjzOQ6Nsb1bwfBFPeOP3kJkRlNxvUkhxpIvu5HhSideJj7oxkwZcCq84RG4NT4SIANaPpYO1GYsAodvYk0GBcK1l9CIaZTSuoMBHcLnWP-REjyxNVkN4SN4JXlWl1OxiYHCc0-VHWe8veTxK1icYbOdtrFruPEdPcYtV2HzeFmH1ASxY73FoT6cxtyOYRTWylqjBj8wt_CQlu1xAZimDmFBGtGzDZjKGFvG-DxPws56herrrKZyH7J8arbXqhO6dRAjKOYOyMrsLeWPA51UY0yWn4xLLMM3qBx621SqtokMxqqSrfN24FMHE4-hjILAsSIzCTHpSjwApv92MMsfsC6xe_49N81QUwR5icqYcHhS2nc8c58RjZJopd_XnZngu8I5c9XlNGn3BEK2MmNJn1pCem7z5-1g45SIjFtsb902jj0uOAF0c6kf_9qKODB-HbNnG8D0DLZAH0sYI8PGJxmsOezmunTa9-zjZQ5DB9A05wEC511Bm84yqXWo5zctijfw41FCCCgPjekZJiEkJ4KXorSsTePk_byNU5EBWw9rEUe2JwuWBDmMQz3BC1OHz9mzZw_XTPws_MCFQ5phDVz4liJBlL2mXsXzsPC0jXnDac5vcMGgk6OVIzSeejCRwOcD9kWUuLfgJ0OPnLBP7VIISmAqaahRXFKZP4KhMc68RXNOfnTjEl_OjUsVH_ixbY1c0dkZSVbwAqzeElXMXadUMeO1ce12_dEyuE8tyaAOS-TmzG7tN8hMqHeRgG5dluYVcLAn7HEKJ-lDIJAtuhNIPCaVwEN6ZF10EuNNi07LTlsXrY23p_5FawQUQoYlzlYQYK736qNjc3aUCMibT7B8T9pUOFhGbKkmS4vY9y7a3F9JiYk5tILTscbaOWfnRIGueFe1On2V_hE_AXGKSungcBuj7BKMbtXyYGqLX_NVd1dmIWRVC3gzsvOY1EGcQanqnr-gQa3-5Il1iFoRdIbpF4LjNErtg30d9ML3BwANx2rh876wpQX-8sKKp0YNj7Zpv-ggGoUC_RLc5r8O9JaV3TfTMJMtbdLitZfn0Z-vkM2KJBQT55YA-S4WD-R62EDGspuZni9mZCj82Q8U2LAdVNS3MQ7-AoDkuOlnePWiUf9bqNCi6yneYO4w2mUrYOZqCs8qC4ZsmEnzKbuhLbBrpsd65QPLB2D72MVNDtsmfNWF6mtgdkNGBapVKER4de30k8SqP35BNloRrLL6FjDxklsoe5N5MKwjhstb79_3jRQikgKHrb0_wiSu0LA7wyUL4LyOsoDaycwpCWjul9yqbj6V34BYP6yxPuj1ntk-oMvGNf9zzvWYSwf9idwSMPAa6q_J32QP9T6RvnErH_woEt9FPSYKpriluWpmV4-xQn0cH_UO8dEgIR9-V5wICcbKhsM9-evWNUB-cSrUOkkrlmJ-1wA6sF40 "Ablaufdiagram der Enigma")
+![Ablaufdiagram Enigma](http://plantuml.gitrepo.de/png/U9oTM4jpspOGlkjNyDPaNFhGeoVJIU97aedbU2GrpiJrU21gHI820HO0uzHfyjkx8CK7G81Yh8D4xRTOBFODlbIQI5tcR3RJL3E8xk_d7yxEBtzJqIaZIaLdbAIIvFVtV_FPB8euoK4L986eaE8BxFGnS9hc9FgEO1_EnGROdXf5IINBNd9SiHoVulUwJBAMrtpYI9CqEeaernRrWR17u8oaK8EtTnOiAK-L1iPAddeP44nsNq6kAT_KF4b6vEtTxLt3qsC_YXhTdZsto5lGIRP29PHACbRY3p27HOkbDjeuv1GqhXiIRzfp3R55xr13T6cVwDdp5kvn_epKSEFO48F2AtGWt6NmwFrZDidd52H8n-Sxu3oLPL4OxzRsit1EaapI9DD-M1KIVTMvP1fNhKj090R7ve58ey_R_QE59qtmdhInuWPGTL37RqbDdaI5lDWIdi9LS_W0pa4kdQFvmdOacYhSSJbm7rFjzZ1ovHwumZw2t9QGhj68husUcgm7Ggfp40q7ZeA1_xuDbY4MifN9bt713FIZ1lKPS3NmIm7A_3fCA0AsK5bgBK7hQo7TdIHWTZGXus0A-2ReJZLoCiGUOJ6iAXMzKyU7rdwv5efgAjppT1oEu-Bw77vTusW3lf3jqJqrC6vT_5uKMmUY7DKZZ2gps6izr8ZmZSZR0FgbkdC16GFPBpeeyEAlgzFLkmzNzzUByujtdto50BdcvylbgpVdOqneo4myd4if97PD9ko38smAn07Yf5EKV2T9cLlLioi41gwBd2_kFEYKFHjdE1MxxiTeZIfwVCssYiZANCqV9xws33SJ4baMpREbTI29_CLo8o43RtKoZRIH7-YYlkHfUxCllxs82c-aHZOQ4VS8OtaRgWU3IZp5pNCXbKbUry-6D2S5EcabmJozgCF_ztqQ_6djtqeP-8nZPz5jxgx40SuMNebXmjUQeOD6eA7yALPe_UTac1jpKsHr3dTCYjgH4hkBxZL3_n0Y94qf9soSxoWAnfO_LweemPvSgp4S1mxX9Qn1rgsmp-MV2yPx_nH3Ll7is92m8aD1WU7DkGsOIT--OfIIg-0bevNfLBM7VLuD5XxLHV1NHhq_WkLhM8R2DI2CZ5yTlBDQRwmV8Ds4r_DSzzrT_ZO4_KiKZD__6gxZCvm6-9hmtV8VHZKuMOUQUkzXfYfn3edsAkFTyLLHz8H_noZKDFbXpfpWK68yRdvdtGvfWiGt9JqLN4l1S7ZeWLNdTiAWbNaKvOJsNO8ECLTjYu97EtDc0kpZN5iNXbPaTOjR2A5zO1mnGJONd-QNUtJ43DQ1UWQ9wvolRhPBtuGSZmyPFzi1pWfWT5H6jzjJAXDcqrS4etD1ogs7MZfcC1LpWzKcsMceE2oCGMbAARU9m_4zZdBWfKK8ZKLxUyoH_xNcA_YcNSX7ypRhsDkguzxW7hXnnRrUFfaSKi1xh-ZcSM_xGDz9i43dieEI7oYM1KF-Y8Fxsd5n_kzAf2d3gg-ruCh2C2nJ7AHKFIsNuDdtHiYT4mRxsM0X8AVetfNuJ3Bcup3qbMZuaEDGNimnOttrmSfbixxgLxM86rWha5zf0lN2y8NzA39A0MKEKWdpQVBYlxWiukWB-Kgstuv9KJ2Q4EDOKyUQv-5QK-JsIprIX_nsDV2lH9d3XSwx714FbZbl-4wyRyw6WeEDOSeMlNRnT9NVTkzzikwzppXhKDYYTyUHJnUpx5-drFhfWkf9wcG_oHmAY36RrrR4qUhfbculinWS-yUGi9OrAAoxlfn4UL2fZii8wXBOcAJz4rIYUeNWKy7aoEmbDXFpDlr_rhUkvW00 "Ablaufdiagram der Enigma")
 ## Interesannte Codestellen
 * Walze:
@@ -85,12 +87,6 @@
 * Dann String (Warum)
 * Vorteile Enum (Warum)
-## Die GUI der Enigma (Elemente, etc)
-* Besondere GUI Elemente
-* ControlsFX (ProgressDialog)
-## GUI Controller
 ## Enigma Demo
 * Kenngruppe Abfrage
  * Testen Kenngruppe Dialog und Fehler
@@ -103,4 +99,9 @@
  * Empfang einer Nachricht
  * Zurücksetzen
  * Setzen von Walzen und Ringen
+  * Setzen von gleichen Walzen und Fehler
  * Senden & Empfangen
+## GUI Controller
+![Screenshot](Screenshot.JPG "Screenshot der Enigma")
\ No newline at end of file
--- a/README.md
+++ b/README.md
@@ -17,3 +17,5 @@ Ebenfalls wichtig ist eure Kenngruppe. Dies hat früher den Personenkreis bezeic
 Wenn ihr also auf mehreren Clients die selbe Kenngruppe nutzt, dann könnt ihr untereinander eure Nachrichten lesen.\
 \
 Im [Wiki](https://www.gitrepo.de/alfatrainingkurse/java/enigma/wikis/home) findet ihr auch noch einige Informationen zu dem Projekt.
+![Screenshot](Praesentation/Screenshot.JPG "Screenshot der Enigma")
\ No newline at end of file
--- a/enigma.jar
+++ b/enigma.jar
--- a/src/main/java/projekt/enigma/App.java
+++ b/src/main/java/projekt/enigma/App.java
@@ -22,57 +22,59 @@ import java.io.IOException;
 public class App extends Application {
    /**
-     * Deklariert den GuiController
+     * Deklariert den GuiController.
     */
    private static GuiController gc;
    /**
-     * debug : int : fuer die Funktion debug der Klasse Fehler notwendig
+     * debug : int : fuer die Funktion debug der Klasse Fehler notwendig.
     */
    private static int debug;
    /**
-     * Startet die Klasse App und setzt den debug-Wert 1
+     * Startet die Klasse App und setzt den debug-Wert 1.
     *
-     * @param args : String[] : Standard-Kommandozeilen-Argument
+     * @param args : String[] : Standard-Kommandozeilen-Argument.
     */
    public static void main(String[] args) {
-        debug = 1;
+        debug = 0;
        launch(args);
    }
    /**
-     * gibt der Getter einen int > 0 zurueck, wird eine Meldung auf der Konsole ausgegeben
+     * Gibt der Getter einen int > 0 zurueck, wird eine Meldung auf der Konsole ausgegeben.
     *
-     * @return debug : int : bestimmt die Eingabe der debung-Methode in der Klasse Fehler
+     * @return debug : int : bestimmt die Eingabe der debung-Methode in der Klasse Fehler.
     */
    public static int getDebug() {
        return debug;
    }
    /**
-     * Initialisieren der Variablen fuer die JavaFX Scene Kenngruppe.
+     * Initialisierung der Variablen fuer die JavaFX Scene Kenngruppe.
     * Abfrage der Kenngruppe und Reaktion auf die Eingabe.
     *
-     * @param primaryStage : Stage : Fenster zur Eingabe der Kenngruppe
+     * @param primaryStage : Stage : Fenster zur Eingabe der Kenngruppe.
-     * @throws IOException : wird bei fehlerhafter Eingabe geworfen
+     * @throws IOException : wird bei fehlerhafter Eingabe geworfen.
     */
    @Override
    public void start(Stage primaryStage) throws IOException {
        primaryStage.setTitle("Enigma");
+        primaryStage.setResizable(false);
        Label lblEingbae = new Label("Bitte Kenngruppe eingeben!");
        TextField tfEingabe = new TextField();
        Button btnKenngruppe = new Button("Kenngruppe setzen!");
        VBox layout = new VBox();
-        layout.setSpacing(30);
+        layout.setSpacing(10);
-        layout.setPadding(new Insets(30, 30, 30, 30));
+        layout.setPadding(new Insets(20, 30, 10, 30));
        btnKenngruppe.setMaxWidth(Double.MAX_VALUE);
        // baut die Scene fuer die Kenngruppenabfrage auf
        layout.getChildren().addAll(lblEingbae, tfEingabe, btnKenngruppe);
        Scene sceKenngruppe = new Scene(layout);
-        // laden der FXML und der Ansicht, um Ladezeiten zu verringern
+        // laden der FXML und der Enigma-Ansicht, um Ladezeiten zu verringern
        FXMLLoader guiLoader = new FXMLLoader(App.class.getResource("gui.fxml"));
        Scene sceApp = new Scene(guiLoader.load(), 962, 677);
@@ -110,8 +112,8 @@ public class App extends Application {
     * Ueberprueft die Gueltigkeit der Kenngruppeneingabe.
     * Nur Zeichen von A-Z sind zugelassen und die Kenngruppe muss aus mind. 4 und max. 8 Zeichen bestehen.
     *
-     * @param kenngruppe : String : Eingabewert aus dem Fenster
+     * @param kenngruppe : String : Eingabewert aus dem Fenster.
-     * @return result : boolean : ist die Kenngruppe ungueltig wird false zurueckgegeben, sonst true
+     * @return result : boolean : ist die Kenngruppe ungueltig wird false zurueckgegeben, sonst true.
     */
    private boolean enter(String kenngruppe) {
        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -129,5 +131,4 @@ public class App extends Application {
        return result;
    }
 }
--- a/src/main/java/projekt/enigma/GuiController.java
+++ b/src/main/java/projekt/enigma/GuiController.java
--- a/src/main/java/projekt/enigma/Main.java
+++ b/src/main/java/projekt/enigma/Main.java
 package projekt.enigma;
-import java.sql.SQLException;
 /**
 * Startpunkt des Programms. Startet die Klasse App und damit die GUI.
 */
@@ -10,9 +8,9 @@ public class Main {
    /**
     * Startet die App
     *
-     * @param args : String[] : Standard-Kommandozeilen-Parameter
+     * @param args : String[] : Standard-Kommandozeilen-Parameter.
     */
-    public static void main(String[] args) throws SQLException {
+    public static void main(String[] args) {
        App.main(args);
    }
 }
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
--- a/src/main/java/projekt/enigma/model/Fehler.java
+++ b/src/main/java/projekt/enigma/model/Fehler.java
@@ -5,10 +5,12 @@ import javafx.scene.control.Alert.AlertType;
 import projekt.enigma.App;
 /**
- * In dieser Klasse werden Fehler behandelt und an den User/Admin/Entwickler ausgegeben
+ * In dieser Klasse werden Fehler behandelt und an den User/Admin/Entwickler ausgegeben.
 */
 public class Fehler {
+    /**
+     * Konstanten die anzeigen ob es sich um eine Funktion oder um eine Nachricht handelt.
+     */
    private static final String FUNCTION_PREFIX = "- ";
    private static final String MESSAGE_PREFIX = "--> ";
@@ -23,7 +25,7 @@ public class Fehler {
        Alert alert;
        new Fehler().debug(this.getClass().getName() + "."
-                + new Throwable().getStackTrace()[0].getMethodName(), true);
+                            + new Throwable().getStackTrace()[0].getMethodName(), true);
        /* Der Titel darf auch als leerer String uebergeben werden, dann wird ein Default gesetzt */
        if (subject.equals("")) {
@@ -61,7 +63,7 @@ public class Fehler {
     * Ueber diesen Getter kann man steuern ob Meldungen in der Konsole angezeigt werden sollen oder nicht.
     *
     * @param message    : String : Nachricht
-     * @param isFunction : boolean : Gibt an ob ein Funktionsname übergeben wird oder eine Debug Meldung
+     * @param isFunction : boolean : Gibt an ob ein Funktionsname uebergeben wird oder eine Debug Meldung
     */
    public void debug(String message, boolean isFunction) {
        if (App.getDebug() != 0) {
@@ -74,15 +76,14 @@ public class Fehler {
    }
    /**
-     * Umter zuhilfenahme dieser Funktion koennen Debug Meldungen auf der Konsole ausgegeben werden,
+     * Unter Zuhilfenahme dieser Funktion koennen Debug Meldungen auf der Konsole ausgegeben werden,
     * wenn in der App.java der Getter getDebug einen int > 0 zurueck gibt.
     * Ueber diesen Getter kann man steuern ob Meldungen in der Konsole angezeigt werden sollen oder nicht.
     *
     * @param message    : String : Nachricht
-     * @param isFunction : boolean : Gibt an ob ein Funktionsname übergeben wird oder eine Debug Meldung
+     * @param isFunction : boolean : Gibt an ob ein Funktionsname uebergeben wird oder eine Debug Meldung.
     */
    public void debug(String message, boolean isFunction, int debugLevel) {
        if (App.getDebug() != 0 && (App.getDebug() >= debugLevel || App.getDebug() == 3)) {
            if (isFunction) {
                System.out.println(FUNCTION_PREFIX + message);

--- a/src/main/java/projekt/enigma/model/Funkraum.java
+++ b/src/main/java/projekt/enigma/model/Funkraum.java
@@ -34,8 +34,8 @@ public class Funkraum {
     *
     * @param kenngruppe : String : Kenngruppe dieser Enigma
     * @return funkspruch : String[] : String Array wobei Index 0 dem Empfangstag entspricht und Index 1
-     * der empfangenen Nachricht
+     *                                 der empfangenen Nachricht.
-     * @throws NullPointerException : Exception : Keine Nachricht
+     * @throws NullPointerException : Exception : Keine Nachricht vorhanden.
     */
    public String[] empfangeFunkspruch(String kenngruppe) {
        String[] funkspruch = new String[2];
@@ -49,7 +49,7 @@ public class Funkraum {
            params.add(new BasicNameValuePair("k", kenngruppe));
            httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
-            // POST Request ausführen und Rückgabe verarbeiten
+            // POST Request ausfuehren und Rueckgabe verarbeiten
            HttpResponse response = httpclient.execute(httppost);
            HttpEntity entity = response.getEntity();
@@ -80,13 +80,13 @@ public class Funkraum {
     * Dem Service senden wir unsere Nachricht als POST Parameter (m) und unsere Kenngruppe (k).
     * Dieser nimmt die Daten entgegen und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
     * irgendwann, auf Anfrage, wieder abgerufen werden koennen.
-     * <p>
+     * <br>
     * Darauf antwortet der Server mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
     * {'result': 200}
-     * <p>
+     * <br>
-     * Die 200 heißt hier, dass alles erfolgreich durchgefuehrt werden konnte. Steht hier etwas anderes, ist ein Fehler
+     * Die 200 heisst hier, dass alles erfolgreich durchgefuehrt werden konnte. Steht hier etwas anderes, ist ein Fehler
     * aufgetreten und die Anfrage war nicht erfolgreich.
-     * In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggf spaeter erneut versucht werden.
+     * In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggf. spaeter erneut versucht werden.
     *
     * @param funkspruch : String : Der zu sendende Funkspruch
     * @param kenngruppe : String : Die Kenngruppe dieser Engima
@@ -102,7 +102,7 @@ public class Funkraum {
        params.add(new BasicNameValuePair("m", funkspruch));
        httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
-        // POST Request ausführen und Rückgabe verarbeiten
+        // POST Request ausfuehren und Rueckgabe verarbeiten
        HttpResponse response = httpclient.execute(httppost);
        HttpEntity entity = response.getEntity();
@@ -111,8 +111,8 @@ public class Funkraum {
            JSONObject result = new JSONObject(reader.readLine());
            if (result.getInt("result") != 200) {
                new Fehler().showErrorDialog("error", "HTTP Exception",
-                        "Der andere Funker mag deine Nachricht nicht. " +
+                        "Der andere Funker mag deine Nachricht nicht. "
-                                "Rüge ihn wenn du ihn wieder siehst...");
+                                + "Rüge ihn wenn du ihn wieder siehst...");
            }
        }
    }

--- a/src/main/java/projekt/enigma/model/Hardware.java
+++ b/src/main/java/projekt/enigma/model/Hardware.java
 package projekt.enigma.model;
 /**
- * In dieser Klasse wird die Hardware zusammen gefasst.
+ * In dieser Klasse wird die Hardware zusammengefasst.
- * Alle Komponenter der Enigma laufen hier zusammen.
+ * Alle Komponenten der Enigma laufen hier zusammen.
 *
 * <p>
 * walzen : Walze[] :           Ist ein Array der drei eingebauten Walzen Objekte
 * steckbrett : Steckbrett :    Das Steckbrett mit den Verbindungen aus dem Codebuch
 * reflektor : Reflektor :      Dies ist das Objekt der Reflektors
- * nachricht : String :         Die verschlüsselte Nachricht wird in diesem String zusammen gesetzt und gespeichert
+ * nachricht : String :         Die verschluesselte Nachricht wird in diesem String zusammengesetzt und gespeichert
- * kenngruppe : String :        Früher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
+ * kenngruppe : String :        Frueher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
 * Wir missbrauchen die Kenngruppe für einen Benutzernamen
 * </p>
 */
 public class Hardware {
-    //region Variablen
+	//region Variablen
-    /**
+	/**
-     * walzen: Walze-Array: erzeugt ein privates Array mit der die Anzahl der Walzen festgelegt wird.
+	 * walzen: Walze-Array: erzeugt ein privates Array mit der die Anzahl der Walzen festgelegt wird.
-     */
+	 */
-    private Walze[] walzen;
+	private Walze[] walzen;
-    /**
+	/**
-     * steckbrett: Steckbrett: erzeugt ein privates Steckbrett-Objekt
+	 * steckbrett: Steckbrett: erzeugt ein privates Steckbrett-Objekt
-     */
+	 */
-    private Steckbrett steckbrett;
+	private Steckbrett steckbrett;
-    /**
+	/**
-     * reflektor: Reflektor: erzeugt ein privates Reflektor-Objekt.
+	 * reflektor: Reflektor: erzeugt ein privates Reflektor-Objekt.
-     */
+	 */
-    private Reflektor reflektor;
+	private Reflektor reflektor;
-    //endregion
+	//endregion
-    //region Konstruktor
+	//region Konstruktor
    /**
-     * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann.
+     * Im Konstruktor legen wir die Anzahl der Walzen fest, welche die Hardware aufnehmen kann.
-     * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
+     * Die Enigma I, welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
     */
    public Hardware() {
        this.walzen = new Walze[3];
    }
    //endregion
-    //region Funktionen & Methoden
+	//region Funktionen & Methoden
    /**
-     * Setzt eine Walze ein
+     * Setzt eine Walze ein.
     *
-     * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein
+     * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein.
-     * @param walzenNr : int : Die Nummer der einzusetzenden Walze
+     * @param walzenNr : int : Die Nummer der einzusetzenden Walze.
+     * @param ringstellung : int : Setzt den Ring der Walze auf die angegebene Nummer.
     */
    public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
        this.walzen[walze] = new Walze(walzenNr, ringstellung);
    }
    /**
-     * Setzt den Notch der Walze
+     * Setzt den Notch der Walze.
     *
-     * @param walze    : int : Position der Walze
+     * @param walze    : int : Position der Walze.
-     * @param position : int : Umspringpunkt auf der Walze
+     * @param position : int : Umspringpunkt auf der Walze.
     */
    public void setzeRing(int walze, int position) {
        this.walzen[walze].setRingstellung(position);
    }
    /**
-     * Setzt den Startwert (position) der Walze (walze)
+     * Setzt den Startwert (position) der Walze (walze).
     *
-     * @param walze     : int : Nummer der Walze
+     * @param walze     : int : Nummer der Walze.
-     * @param buchstabe : char : Buchstabe der zugewiesen soll
+     * @param buchstabe : char : Buchstabe der zugewiesen werden soll.
     */
    public void setzePosition(int walze, char buchstabe) {
        this.walzen[walze].setPosition(buchstabe);
    }
    /**
-     * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu
+     * Verschluesselt den uebergebenen Buchstaben und fuegt ihn der Nachricht hinzu.
+     * Debug Ausgabe auf der Konsole wird zusaetzlich ausgegeben.
     *
-     * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
+     * @param buchstabe char : Der zu ver/entschluesselnde Buchstabe.
-     * @return char : Der ver/entschlüsselte Buchstabe
+     * @return char : Der ver/entschluesselte Buchstabe.
     */
    public char codiere(char buchstabe) {
        new Fehler().debug(this.getClass().getName() + "." +
                new Throwable().getStackTrace()[0].getMethodName(), true);
        buchstabe = Character.toUpperCase(buchstabe);
        String debug = String.format("Positionen: W1:%s W2:%s W3:%s",
                this.walzen[0].getPosition(),
@@ -92,8 +94,10 @@ public class Hardware {
                this.walzen[2].getPosition());
        debug += "\nI\tS\t3\t2\t1\tR\t1\t2\t3\tS\n" + buchstabe;
-        this.dreheWalzen(1);
+		this.dreheWalzen(1);
+        //Codiere Vorgang wird fuer jede Walze bis zum Reflektor mit der codiere Funktion durchgefuehrt.
+        //Auf dem Rueckweg wird mit der codiere2 Funktion codiert.
        buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
        debug += "\t" + buchstabe;
        buchstabe = this.walzen[2].codiere(buchstabe);
@@ -114,12 +118,14 @@ public class Hardware {
        debug += "\t" + buchstabe;
        new Fehler().debug(debug, false);
-        return buchstabe;
+		return buchstabe;
-    }
+	}
    /**
-     * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
+     * Nach jeder Codierung eines Buchstabens muessen die Walzen gedreht werden.
-     * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
+     * Hier ueberpruefen wir, welche der Walzen gedreht werden muessen und stossen den Vorgang an.
+     *
+     * @param richtung : int : +1 fuer eine Vorwaertsdrehung und -1 fuer eine Rueckwaertsdrehung.
     */
    public void dreheWalzen(int richtung) {
        if (richtung > 0) {
@@ -142,56 +148,56 @@ public class Hardware {
    }
    //endregion
-    //region Setter
+	//region Setter
    /**
-     * Setzt eine Walze ein und speichert das Objekt im Walzen Array
+     * Setzt eine Walze ein und speichert das Objekt im Walzen Array.
     *
-     * @param position     : int : Position der Walze
+     * @param position     : int : Position der Walze.
-     * @param walze        : int : Die Nummer der Walze
+     * @param walze        : int : Die Nummer der Walze.
-     * @param ringstellung : int : Umsprung Punkt der Walze
+     * @param ringstellung : int : Umsprungpunkt der Walze.
     */
    public void setWalzen(int position, int walze, int ringstellung) {
        this.walzen[position] = new Walze(walze, ringstellung);
    }
    /**
-     * Gibt das Objekt des Steckbretts zurück
+     * Gibt das Objekt des Steckbretts zurueck.
     *
-     * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt
+     * @return steckbrett : Steckbrett-Objekt:  Das eingesetzte Steckbrett mit seinen Kabeln, wenn eingesteckt.
     */
    public Steckbrett getSteckbrett() {
        return steckbrett;
    }
    /**
-     * Setzt das übergebene Steckbrett Objekt in die Hardware ein
+     * Setzt das uebergebene Steckbrett Objekt in die Hardware ein.
     *
-     * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln
+     * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln.
     */
    public void setSteckbrett(Steckbrett steckbrett) {
        this.steckbrett = steckbrett;
    }
    //endregion
-    //region Getter
+	//region Getter
    /**
     * Setzt den Reflektor ein.
-     * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor.
+     * In der Enigma I, welche hier nachgebaut wird, gab es nur einen Reflektor.
-     * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt,
+     * Spaetere Versionen hatten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafuer erstellt,
     * welches ausgetauscht werden kann.
     *
-     * @param reflektor : Reflektor : Das Obejtk des Reflektors
+     * @param reflektor : Reflektor : Das Objekt des Reflektors.
     */
    public void setReflektor(Reflektor reflektor) {
        this.reflektor = reflektor;
    }
    /**
-     * Gibt die verbauten Walzen Objekte zurück
+     * Gibt die verbauten Walzen Objekte zurück.
     *
-     * @return Walze[] : Array mit den Walzen Objekten
+     * @return walzen : Walze[] : Array mit den Walzen Objekten.
     */
    public Walze[] getWalzen() {
        return this.walzen;

--- a/src/main/java/projekt/enigma/model/Morsecode.java
+++ b/src/main/java/projekt/enigma/model/Morsecode.java
@@ -10,7 +10,7 @@ import java.util.TreeMap;
 public class Morsecode {
    /**
-     * Anlegen der codeMap als TreeMap
+     * Anlegen der codeMap als TreeMap.
     */
    private TreeMap<String, String> codeMap;
@@ -63,8 +63,8 @@ public class Morsecode {
     * Diese Funktion ueberprueft ob der uebergebene Buchstabe in der codeMap enthalten ist.
     * Wenn er enthalten ist, wird der zugehoerige Morsecode zurueck gegeben, ansonsten null.
     *
-     * @param buchstabe : char : Zu uebersetzender Buchstabe
+     * @param buchstabe : char : Zu uebersetzender Buchstabe.
-     * @return String : Der zugehoerige Morsecode aus der codeMap
+     * @return String : Der zugehoerige Morsecode aus der codeMap.
     */
    private String getMorsecode(char buchstabe) {
        return this.codeMap.getOrDefault(String.valueOf(buchstabe).toUpperCase(), null);
@@ -72,13 +72,13 @@ public class Morsecode {
    /**
     * Der uebergebene String wird in seine einzelnen Zeichen (char) zerlegt und an die Funktion getMorsecode
-     * uebergeben und der zugehoerige Morsecode raus gesucht.
+     * uebergeben und der zugehoerige Morsecode rausgesucht.
-     * Mittels eines StringBuilders werden die Ergebnisse zu einem Rückgabe String zusammen gesetzt.
+     * Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe-String zusammengesetzt.
     * Wenn kein zugehoeriger Code in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
     * Enigma nicht vorhanden war.
     *
-     * @param input : String : Zu konvertierender Text
+     * @param input : String : Zu konvertierender Text.
-     * @return String : Der in Morsecode konvertierte Text
+     * @return String : Der in Morsecode konvertierte Text.
     */
    public String convertBuchstabeToMorsecode(String input) {
        StringBuilder sb = new StringBuilder();
@@ -97,10 +97,10 @@ public class Morsecode {
    /**
     * Diese Funktion ueberprueft ob der uebergebene Morsecode in der codeMap enthalten ist.
-     * Wenn er enthalten ist, wird der zugehoerige Buchstabe zurueck gegeben, ansonsten null
+     * Wenn er enthalten ist, wird der zugehoerige Buchstabe zurueckgegeben, ansonsten null.
     *
-     * @param morsecode : String : Der zu uebersetzende Morsecode
+     * @param morsecode : String : Der zu uebersetzende Morsecode.
-     * @return : String : Der zugehoerige Buchstabe aus der codeMap
+     * @return : String : Der zugehoerige Buchstabe aus der codeMap.
     */
    private String getBuchstabe(String morsecode) {
        String result = null;
@@ -116,15 +116,15 @@ public class Morsecode {
    }
    /**
-     * Der uebergebene String wird in ein String Array zerlegt. Als Trennzeichen wird das Leerzeichen genutzt.
+     * Der uebergebene String wird in ein String-Array zerlegt. Als Trennzeichen wird das Leerzeichen genutzt.
     * Anschließend wird das Array durchlaufen und die Elemente an die Funktion getBuchstabe uebergeben um den
     * zugehoerigen Buchstaben zu erhalten.
     * Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe String zusammengesetzt.
-     * Wenn kein zugehoeriger Buchstabe in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
+     * Wenn kein zugehoeriger Buchstabe in der codeMap gefunden wurde, wird das Zeichen ignoriert, da es bei der
     * Enigma nicht vorhanden war.
     *
-     * @param input : String : Zu konvertierender Morsecode
+     * @param input : String : Zu konvertierender Morsecode.
-     * @return String : Der in Text konvertierte Morsecode
+     * @return String : Der in Text konvertierte Morsecode.
     */
    public String convertMorsecodeToBuchstabe(String input) {
        StringBuilder sb = new StringBuilder();

--- a/src/main/java/projekt/enigma/model/Reflektor.java
+++ b/src/main/java/projekt/enigma/model/Reflektor.java
@@ -3,10 +3,10 @@ package projekt.enigma.model;
 /**
 * Klasse Reflektor
 * <br>
- * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und codiert diesen.
+ * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und codiert diesen.
- * Der codierte Buchstabe wird an die Klasse Walze wieder zurückgegeben.
+ * Der codierte Buchstabe wird an die Klasse Walze wieder zurueckgegeben.
 * <br>
- * Prinzipiell verhaelt sich die Klasse Reflektor wie die Klasse Walze, außer das sie sich
+ * Prinzipiell verhaelt sich die Klasse Reflektor wie die Klasse Walze, ausser das sie sich
 * nach Betaetigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
 * an andere Walzen zum Drehen.
 */
@@ -18,14 +18,11 @@ public class Reflektor {
     * Durchsucht den String alphabet nach der Position des mitgegebenen Buchstabens und
     * gibt den Character an der entsprechenden Position im String reflektor zurueck.
     *
-     * @return char : Der codierte Buchstabe aus dem Reflektor
+     * @param buchstabe : Character : der zu codierende Buchstabe.
+     * @return char : Der codierte Buchstabe aus dem Reflektor.
     */
    public char codiere(Character buchstabe) {
-        // alphabet : String mit den Werten des Alphabeths (26 Werte)
        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-        // reflektor : String mit den Werten des Reflektors (26 Werte)
        String reflektor = "EJMZALYXVBWFCRQUONTSPIKHGD";
        return reflektor.charAt(alphabet.indexOf(buchstabe));

--- a/src/main/java/projekt/enigma/model/Steckbrett.java
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -4,27 +4,26 @@ package projekt.enigma.model;
 * <p>
 * Klasse Steckbrett
 * <br>
- * Das Steckbrett diente dazu Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
+ * Das Steckbrett diente dazu, Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
 * Die Klasse Steckbrett nimmt bis zu 10 paarweise zu vertauschende Buchstabenpaare entgegen, prueft diese auf
 * Zulaessigkeit und tauscht diese dann paarweise aus.
 */
 public class Steckbrett {
    /**
-     * orginalBuchstaben: String : der jeweils den ersten zu vertauschenden Buchstaben enthaelt
+     * orginalBuchstaben: String : der jeweils den ersten zu vertauschenden Buchstaben enthaelt.
     */
    private String originalBuchstaben;
    /**
-     * getauschteBuchstaben: String : der jeweils den zweiten zu vertauschenden Buchstaben enthaelt
+     * getauschteBuchstaben: String : der jeweils den zweiten zu vertauschenden Buchstaben enthaelt.
     */
    private String getauschteBuchstaben;
    /**
     * Konstruktor Steckbrett
     * <br>
-     * Erzeugt zwei Strings und initialisiert diese mit einer leeren Menge.
+     * Erzeugt zwei Strings und initialisiert diese.
     */
    public Steckbrett() {
        originalBuchstaben = "";
@@ -37,15 +36,15 @@ public class Steckbrett {
     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) uebergeben.
     * Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
     * <br>
-     * Anschließend wird:
+     * Anschliessend wird:
     * <p>
     * buchstabe1 dem String orginalBuchstaben angehaengt.
-     * buchstabe2 dem String  getauschteBuchstaben angehaengt.
+     * buchstabe2 dem String getauschteBuchstaben angehaengt.
     * </p>
     *
     * @param buchstabe1 : char : Gibt den ersten Buchstaben an, der getauscht werden soll.
     * @param buchstabe2 : char : gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
-     * @return boolean : Wenn die Vertauschung zulaessig ist, true, ansonsten false
+     * @return boolean : Wenn die Vertauschung zulaessig ist, true, ansonsten false.
     */
    public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
        if ((!ueberpruefeVertauschungen(buchstabe1)) && (!ueberpruefeVertauschungen(buchstabe2))
@@ -64,22 +63,42 @@ public class Steckbrett {
     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port uebergeben.
     * Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
     * <br>
-     * Anschließend wird:
+     * Anschliessend wird:
     * <p>
-     * buchstabe1 in den String orginalBuchstaben auf die Position (steckbrettPorts) geschrieben
+     * buchstabe1 in den String orginalBuchstaben auf die Position (steckbrettPort) geschrieben.
     * buchstabe2 in den String getauschteBuchstaben auf die Position (steckbrettPort) geschrieben.
     * </p>
     *
     * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
     * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
-     * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
+     * @return boolean : Wenn die Vertauschung zulaessig ist, true, ansonsten false.
     */
    public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
-        if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
+        char[] original;
-            originalBuchstaben = originalBuchstaben.replace(originalBuchstaben.charAt(steckbrettPort), buchstabe1);
+        char[] getauscht;
-            getauschteBuchstaben = getauschteBuchstaben.replace(getauschteBuchstaben.charAt(steckbrettPort), buchstabe2);
+        new Fehler().debug("setzeVertauschung(int " + steckbrettPort + ", char |" + buchstabe1 + "|, char |" + buchstabe2 + "|)", false);
+        if ((!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) ||
+                (buchstabe1 == ' ' && buchstabe2 == ' ')) {
+            new Fehler().debug("-> Original:\t" + originalBuchstaben, false);
+            new Fehler().debug("-> Getauscht:\t" + getauschteBuchstaben, false);
+            original = originalBuchstaben.toCharArray();
+            getauscht = getauschteBuchstaben.toCharArray();
+            original[steckbrettPort] = buchstabe1;
+            getauscht[steckbrettPort] = buchstabe2;
+            originalBuchstaben = String.valueOf(original);
+            getauschteBuchstaben = String.valueOf(getauscht);
+            new Fehler().debug("<- Original:\t" + originalBuchstaben, false);
+            new Fehler().debug("<- Getauscht:\t" + getauschteBuchstaben, false);
+            new Fehler().debug("true\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
            return true;
        } else {
+            new Fehler().debug("false\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
            return false;
        }
    }
@@ -87,13 +106,14 @@ public class Steckbrett {
    /**
     * Funktion ueberpruefeVertauschungen
     * <br>
-     * Die Funktion ueberpruefeVertauschungen prueft ob der uebergebene Buchstabe bereits in den beiden Strings
+     * Die Funktion ueberpruefeVertauschungen prueft, ob der uebergebene Buchstabe bereits in den beiden Strings
     * orginalBuchstaben und getauschteBuchstaben vorhanden ist.
     * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
     * (ein Buchstabe nicht mehrmals vertauscht wird).
     *
+     * @param buchstabe : Character: zu pruefender Buchstabe.
     * @return result : boolean : Wenn false, dann darf der Buchstabe genutzt werden. Wenn er schon vorhanden ist,
-     * wird true zurueck gegeben
+     * wird true zurueckgegeben.
     */
    public boolean ueberpruefeVertauschungen(Character buchstabe) {
        boolean result = false;
@@ -125,10 +145,10 @@ public class Steckbrett {
    }
    /**
-     * Tauscht die Buchstaben im Alphabet aus und gibt ein modifiziertes Alphabet zurueck
+     * Tauscht die Buchstaben im Alphabet aus und gibt ein modifiziertes Alphabet zurueck.
     *
-     * @param port : int : Platz der getauschten Buchstaben
+     * @param port : int : Platz der getauschten Buchstaben.
-     * @return alphabet : String : Alphabet mit getauschen Buchstabenpaaren
+     * @return alphabet : String : Alphabet mit getauschtem Buchstabenpaar.
     */
    public String fetchVerfuegbareBuchstaben(int port) {
        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -5,34 +5,38 @@ package projekt.enigma.model;
 * <br>
 * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
 * <br>
- * 1. Walzennummer (Die Walze enthaelt die 26 Buchstaben des Alphabeths und codiert diese.
+ * 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 Alphabeths
+ * Fuenf verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabets
- * vertauschen)
+ * vertauschen).
 * <br>
 * 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
- * den Drehzeitpunkt der linken Nachbarwalze.)
+ * den Drehzeitpunkt der linken Nachbarwalze).
 */
 public class Walze {
 	//region Variablen
 	/**
-	 * Die Anzahl der getaetigten Walzen Drehungen
+	 * Die Anzahl der getaetigten Walzendrehungen.
 	 */
 	private int turns;
 	/**
-	 * Das String Array aller bekannter aktueller Walzen
+	 * Das String-Array aller bekannter aktueller Walzen.
 	 */
 	private String[] walzen;
 	/**
-	 * alphabet : String : enthaelt die Buchstaben des Alphabets
+	 * alphabet : String : enthaelt die Buchstaben des Alphabets.
 	 */
 	private String alphabet;
 	/**
-	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
+	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt.
 	 */
 	private char ringstellung;
 	/**
-	 * walzenNr : int : Bestimmt, welche Walze genutzt wird
+	 * walzenNr : int : Bestimmt, welche Walze genutzt wird.
 	 */
 	private int walzenNr;
@@ -40,10 +44,10 @@ public class Walze {
 	//region Konstruktor
 	/**
-	 * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt
+	 * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt.
 	 *
-	 * @param walzenNr     : int : Nummer der gewaehlten Walze
+	 * @param walzenNr     : int : Nummer der gewaehlten Walze.
-	 * @param ringstellung : int : Einstellung des Umsprungpunktes
+	 * @param ringstellung : int : Einstellung des Umsprungpunktes.
 	 */
 	public Walze(int walzenNr, int ringstellung) {
 		this.walzen = new String[5];
@@ -67,8 +71,8 @@ public class Walze {
 	 * <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
+	 * @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
+	 * @return checkRing : boolean : gibt true zurueck, wenn der Umspringpunkt erreicht wurde.
 	 */
 	boolean dreheWalze(int richtung) {
 		boolean checkRing = false;
@@ -77,7 +81,7 @@ public class Walze {
 		if ((richtung == -1) || (richtung == 1)) {
 			if (richtung == 1) {
 				this.turns++;
-			} else if (richtung == -1) {
+			} else {
 				korrekturFaktor = 1;
 				this.turns--;
 			}
@@ -93,10 +97,10 @@ public class Walze {
 	}
 	/**
-	 * Codiert den mitgegebenen Buchstaben anhand er gewaehlten Walze.
+	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
 	 *
-	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
+	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll.
-	 * @return char : verschluesselter Buchstabe
+	 * @return char : verschluesselter Buchstabe.
 	 */
 	public char codiere(char buchstabe) {
 		return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26);
@@ -105,15 +109,15 @@ public class Walze {
 	/**
 	 * Decodiert den mitgegebenen Buchstaben anhand des Alphabets.
 	 *
-	 * @param buchstabe : char : Buchstabe, der decodiert werden soll
+	 * @param buchstabe : char : Buchstabe, der decodiert werden soll.
-	 * @return char : decodierter Buchstabe
+	 * @return char : decodierter Buchstabe.
 	 */
 	char codiere2(char buchstabe) {
-		return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) - this.turns + 260) % 26);
+		return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) - this.turns + 520) % 26);
 	}
 	/**
-	 * @return String : Gibt den Verschluesselunngsstring der ausgewaehlten Walze zurueck.
+	 * @return String : Gibt den Verschluesselungs-String der ausgewaehlten Walze zurueck.
 	 */
 	private String fetchWalze() {
 		return walzen[walzenNr];
@@ -123,9 +127,9 @@ public class Walze {
 	//region Setter
 	/**
-	 * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
+	 * Setzt die Walzennummer. Es stehen fuenf Walzen zur Auswahl.
 	 *
-	 * @param walzenNr : int : Walzennummer
+	 * @param walzenNr : int : Walzennummer.
 	 */
 	private void setWalzenNr(int walzenNr) {
 		if ((walzenNr > 0) && (walzenNr < 6)) {
@@ -142,7 +146,7 @@ public class Walze {
 	 * Die Ringstellung wird zum char umgewandelt.
 	 * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
 	 *
-	 * @param ringstellung : int : Punkt an dem die Nachbarwalze umspringt
+	 * @param ringstellung : int : Punkt an dem die Nachbarwalze umspringt.
 	 */
 	void setRingstellung(int ringstellung) {
 		if ((ringstellung > 0) && (ringstellung <= 26)) {
@@ -156,7 +160,7 @@ public class Walze {
 	 * 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
+	 * @param buchstabe : Character : Einstellung der Walze.
 	 */
 	void setPosition(Character buchstabe) {
 		this.turns = alphabet.indexOf(buchstabe);
@@ -165,14 +169,18 @@ public class Walze {
 	//region Getter
 	/**
-	 * Gibt den Buchstabe zurueck, der aktuell in der Walze eingestellt ist.
+	 * Gibt den Buchstaben zurueck, der aktuell in der Walze eingestellt ist.
 	 *
-	 * @return char : Ermittelte stelle im Alphabet, anhand der aktuellen Anzahl der Drehungen
+	 * @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;
 	}

--- a/src/main/java/projekt/enigma/view/ChkBoxGridPane.java
+++ b/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.ContentDisplay;
+import javafx.scene.control.ToggleButton;
-import javafx.scene.control.Label;
 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 {
-	/*private static JPanel panel = new JPanel();*/
-	private static CheckBox[] checkbox;
-	private static Character[] alphabet;/* = {'A','B','C','D'};*/
-	private static int charSize;
-	public ChkBoxGridPane(Character[] alphabet) {
+    // Der globale Checkbox Array
-		charSize = alphabet.length;
+    private CheckBox[] checkbox;
-		ChkBoxGridPane.alphabet = alphabet;
+    // Die Buchstaben die für das jeweilige Pane selectiert werden sollen
-		initializeComponents();
+    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
-	 * Es wird ein GridPane erzeugt, das zwei Spalten und abhängig von der Länge des
+                    for (CheckBox cb : checkbox) {
-	 * Arrays (Character[] alphabet) Reihen hat. Das Label der CheckBoxen soll
+                        if (cb != null && cb.isSelected()) {
-	 * abhängig von deren Index links bzw. recht erzeugt werden
+                            zaehler++;
-	 */
+                        }
-	private void initializeComponents() {
+                    }
-		checkbox = new CheckBox[charSize];
+                    // 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
-		 * => bei ungerader Anzahl Buchstaben
+                this.addRow(i + 1);
-		 * CheckBox und deren Label erzeugen,  bei geraden Index Zahlen
+                this.add(checkbox[i], 2, i + 1, 1, 1);
-		 * das Label rechts setzen bei ungeraden links
+            }
-		 * => bei gerader Anzahl Buchstaben
+        }
-		 * CheckBox und deren Label erzeugen,  bei geraden Index Zahlen
+        // Das Pane anzeigen
-		 * das Label rechts setzen bei ungeraden links
+        this.setVisible(true);
-		 */
+    }
-		for (int i = 0; i < charSize; i++) {
-			Label lb = new Label(alphabet[i] + "");
-			lb.setGraphic(checkbox[i] = new CheckBox());
-			if (i % 2 == 0) lb.setContentDisplay(ContentDisplay.RIGHT);
-			else if (!(i % 2 == 0)) lb.setContentDisplay(ContentDisplay.LEFT);
-			if (!(charSize % 2 == 0)) {
-				this.add(checkbox[i], 2, (charSize + 1) / 2);
-			} else {
-				this.add(checkbox[i], 2, (charSize / 2));
-			}
-			//if (i==0)checkbox[0].setSelected(true);
-		}
-		this.setVisible(true);
-	}
-	/**
+    /**
-	 * Prüft welche CheckBox aus gewählt und gibt deren
+     * Gibt den Anzahl der zur Verfügung stehenden Buchstaben zurück.
-	 * Index zurück
+     * Anhang dieses Wertes, wird die Anzahl der Checkboxen festgelegt.
-	 *
+     *
-	 * @return Integer
+     * @return int : Anzahl der möglcihen chars
-	 */
+     */
-	private Integer isCheckedChkBoxIndex() {
+    public int getCharSize() {
-		for (int i = 0; i < charSize; i++) {
+        return charSize;
-			if (checkbox[i].isSelected()) {
+    }
-				return i;
-			} else {
-				return null;
-			}
-		}
-		return null;
-	}
 }
--- a/src/main/resources/projekt/enigma/gui.fxml
+++ b/src/main/resources/projekt/enigma/gui.fxml
No results found